* plaintext.c: Copyright.
[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     aExportAll,
117     aExportSecret,
118     aExportSecretSub,
119     aCheckKeys,
120     aGenRevoke,
121     aDesigRevoke,
122     aPrimegen,
123     aPrintMD,
124     aPrintMDs,
125     aCheckTrustDB,
126     aUpdateTrustDB,
127     aFixTrustDB,
128     aListTrustDB,
129     aListTrustPath,
130     aExportOwnerTrust,
131     aListOwnerTrust,
132     aImportOwnerTrust,
133     aDeArmor,
134     aEnArmor,
135     aGenRandom,
136     aPipeMode,
137     aRebuildKeydbCaches,
138     aRefreshKeys,
139     aCardStatus,
140     aCardEdit,
141     aChangePIN,
142
143     oTextmode,
144     oNoTextmode,
145     oExpert,
146     oNoExpert,
147     oAskSigExpire,
148     oNoAskSigExpire,
149     oAskCertExpire,
150     oNoAskCertExpire,
151     oAskCertLevel,
152     oNoAskCertLevel,
153     oFingerprint,
154     oWithFingerprint,
155     oAnswerYes,
156     oAnswerNo,
157     oDefCertLevel,
158     oMinCertLevel,
159     oKeyring,
160     oPrimaryKeyring,
161     oSecretKeyring,
162     oShowKeyring,
163     oDefaultKey,
164     oDefRecipient,
165     oDefRecipientSelf,
166     oNoDefRecipient,
167     oOptions,
168     oDebug,
169     oDebugAll,
170     oStatusFD,
171 #ifdef __riscos__
172     oStatusFile,
173 #endif /* __riscos__ */
174     oAttributeFD,
175 #ifdef __riscos__
176     oAttributeFile,
177 #endif /* __riscos__ */
178     oSKComments,
179     oNoSKComments,
180     oEmitVersion,
181     oNoEmitVersion,
182     oCompletesNeeded,
183     oMarginalsNeeded,
184     oMaxCertDepth,
185     oLoadExtension,
186     oGnuPG,
187     oRFC1991,
188     oRFC2440,
189     oOpenPGP,
190     oPGP2,
191     oPGP6,
192     oPGP7,
193     oPGP8,
194     oCipherAlgo,
195     oDigestAlgo,
196     oCertDigestAlgo,
197     oCompressAlgo,
198     oCompressLevel,
199     oBZ2CompressLevel,
200     oBZ2CompressLowmem,
201     oPasswdFD,
202 #ifdef __riscos__
203     oPasswdFile,
204 #endif /* __riscos__ */
205     oCommandFD,
206 #ifdef __riscos__
207     oCommandFile,
208 #endif /* __riscos__ */
209     oQuickRandom,
210     oNoVerbose,
211     oTrustDBName,
212     oNoSecmemWarn,
213     oNoPermissionWarn,
214     oNoMDCWarn,
215     oNoArmor,
216     oNoDefKeyring,
217     oNoGreeting,
218     oNoTTY,
219     oNoOptions,
220     oNoBatch,
221     oHomedir,
222     oWithColons,
223     oWithKeyData,
224     oSkipVerify,
225     oCompressKeys,
226     oCompressSigs,
227     oAlwaysTrust,
228     oTrustModel,
229     oForceOwnertrust,
230     oRunAsShmCP,
231     oSetFilename,
232     oForYourEyesOnly,
233     oNoForYourEyesOnly,
234     oSetPolicyURL,
235     oSigPolicyURL,
236     oCertPolicyURL,
237     oShowPolicyURL,
238     oNoShowPolicyURL,
239     oSigKeyserverURL,
240     oUseEmbeddedFilename,
241     oComment,
242     oDefaultComment,
243     oNoComments,
244     oThrowKeyid,
245     oNoThrowKeyid,
246     oShowPhotos,
247     oNoShowPhotos,
248     oPhotoViewer,
249     oForceV3Sigs,
250     oNoForceV3Sigs,
251     oForceV4Certs,
252     oNoForceV4Certs,
253     oForceMDC,
254     oNoForceMDC,
255     oDisableMDC,
256     oNoDisableMDC,
257     oS2KMode,
258     oS2KDigest,
259     oS2KCipher,
260     oSimpleSKChecksum,                          
261     oCharset,
262     oNotDashEscaped,
263     oEscapeFrom,
264     oNoEscapeFrom,
265     oLockOnce,
266     oLockMultiple,
267     oLockNever,
268     oKeyServer,
269     oKeyServerOptions,
270     oImportOptions,
271     oExportOptions,
272     oListOptions,
273     oVerifyOptions,
274     oTempDir,
275     oExecPath,
276     oEncryptTo,
277     oHiddenEncryptTo,
278     oNoEncryptTo,
279     oLoggerFD,
280 #ifdef __riscos__
281     oLoggerFile,
282 #endif /* __riscos__ */
283     oUtf8Strings,
284     oNoUtf8Strings,
285     oDisableCipherAlgo,
286     oDisablePubkeyAlgo,
287     oAllowNonSelfsignedUID,
288     oNoAllowNonSelfsignedUID,
289     oAllowFreeformUID,
290     oNoAllowFreeformUID,
291     oAllowSecretKeyImport,                      
292     oEnableSpecialFilenames,
293     oNoLiteral,
294     oSetFilesize,
295     oHonorHttpProxy,
296     oFastListMode,
297     oListOnly,
298     oIgnoreTimeConflict,
299     oIgnoreValidFrom,
300     oIgnoreCrcError,
301     oIgnoreMDCError,
302     oShowSessionKey,
303     oOverrideSessionKey,
304     oNoRandomSeedFile,
305     oAutoKeyRetrieve,
306     oNoAutoKeyRetrieve,
307     oUseAgent,
308     oNoUseAgent,
309     oGpgAgentInfo,
310     oMergeOnly,
311     oTryAllSecrets,
312     oTrustedKey,
313     oNoExpensiveTrustChecks,
314     oFixedListMode,
315     oNoSigCache,
316     oNoSigCreateCheck,
317     oAutoCheckTrustDB,
318     oNoAutoCheckTrustDB,
319     oPreservePermissions,
320     oDefaultPreferenceList,
321     oPersonalCipherPreferences,
322     oPersonalDigestPreferences,
323     oPersonalCompressPreferences,
324     oDisplay,
325     oTTYname,
326     oTTYtype,
327     oLCctype,
328     oLCmessages,
329     oGroup,
330     oUnGroup,
331     oNoGroups,
332     oStrict,
333     oNoStrict,
334     oMangleDosFilenames,
335     oNoMangleDosFilenames,
336     oEnableProgressFilter,
337     oMultifile,
338
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     { aExportAll, "export-all"    , 256, "@" },
388     { aExportSecret, "export-secret-keys" , 256, "@" },
389     { aExportSecretSub, "export-secret-subkeys" , 256, "@" },
390     { aImport, "import",      256     , N_("import/merge keys")},
391     { aFastImport, "fast-import",  256 , "@"},
392 #ifdef ENABLE_CARD_SUPPORT
393     { aCardStatus,  "card-status", 256, N_("print the card status")},
394     { aCardEdit,   "card-edit",  256, N_("change data on a card")},
395     { aChangePIN,  "change-pin", 256, N_("change a card's PIN")},
396 #endif
397     { aListConfig, "list-config", 256, "@"},
398     { aListPackets, "list-packets",256, "@"},
399     { aExportOwnerTrust, "export-ownertrust", 256, "@"},
400     { aImportOwnerTrust, "import-ownertrust", 256, "@"},
401     { aUpdateTrustDB,
402               "update-trustdb",0 , N_("update the trust database")},
403     { aCheckTrustDB, "check-trustdb", 0, "@"},
404     { aFixTrustDB, "fix-trustdb", 0, "@"},
405     { aDeArmor, "dearmor", 256, "@"},
406     { aDeArmor, "dearmour", 256, "@"},
407     { aEnArmor, "enarmor", 256, "@"},
408     { aEnArmor, "enarmour", 256, "@"},
409     { aPrintMD,  "print-md" , 256, N_("|algo [files]|print message digests")},
410     { aPrimegen, "gen-prime" , 256, "@" },
411     { aGenRandom, "gen-random" , 256, "@" },
412
413     { 301, NULL, 0, N_("@\nOptions:\n ") },
414
415     { oArmor, "armor",     0, N_("create ascii armored output")},
416     { oArmor, "armour",     0, "@" },
417     { oRecipient, "recipient", 2, N_("|NAME|encrypt for NAME")},
418     { oHiddenRecipient, "hidden-recipient", 2, "@" },
419     { oRecipient, "remote-user", 2, "@"},  /* old option name */
420     { oDefRecipient, "default-recipient", 2, "@"},
421     { oDefRecipientSelf, "default-recipient-self", 0, "@"},
422     { oNoDefRecipient, "no-default-recipient", 0, "@" },
423     { oTempDir, "temp-directory", 2, "@" },
424     { oExecPath, "exec-path", 2, "@" },
425     { oEncryptTo, "encrypt-to", 2, "@" },
426     { oHiddenEncryptTo, "hidden-encrypt-to", 2, "@" },
427     { oNoEncryptTo, "no-encrypt-to", 0, "@" },
428     { oUser, "local-user",2, N_("use this user-id to sign or decrypt")},
429     { oCompress, NULL, 1, N_("|N|set compress level N (0 disables)") },
430     { oCompressLevel, "compress-level", 1, "@" },
431     { oBZ2CompressLevel, "bzip2-compress-level", 1, "@" },
432     { oBZ2CompressLowmem, "bzip2-compress-lowmem", 0, "@" },
433     { oTextmodeShort, NULL,   0, "@"},
434     { oTextmode, "textmode",  0, N_("use canonical text mode")},
435     { oNoTextmode, "no-textmode",  0, "@"},
436     { oExpert, "expert",   0, "@"},
437     { oNoExpert, "no-expert",   0, "@"},
438     { oAskSigExpire, "ask-sig-expire",   0, "@"},
439     { oNoAskSigExpire, "no-ask-sig-expire",   0, "@"},
440     { oAskCertExpire, "ask-cert-expire",   0, "@"},
441     { oNoAskCertExpire, "no-ask-cert-expire",   0, "@"},
442     { oAskCertLevel, "ask-cert-level",   0, "@"},
443     { oNoAskCertLevel, "no-ask-cert-level",   0, "@"},
444     { oOutput, "output",    2, N_("use as output file")},
445     { oMaxOutput, "max-output", 16|4, "@" },
446     { oVerbose, "verbose",   0, N_("verbose") },
447     { oQuiet,   "quiet",   0, "@"},
448     { oNoTTY, "no-tty", 0, "@"},
449     { oForceV3Sigs, "force-v3-sigs", 0, "@"},
450     { oNoForceV3Sigs, "no-force-v3-sigs", 0, "@"},
451     { oForceV4Certs, "force-v4-certs", 0, "@"},
452     { oNoForceV4Certs, "no-force-v4-certs", 0, "@"},
453     { oForceMDC, "force-mdc", 0, "@"},
454     { oNoForceMDC, "no-force-mdc", 0, "@" },
455     { oDisableMDC, "disable-mdc", 0, "@"},
456     { oNoDisableMDC, "no-disable-mdc", 0, "@" },
457     { oDryRun, "dry-run",   0, N_("do not make any changes") },
458     { oInteractive, "interactive", 0, N_("prompt before overwriting") },
459     { oUseAgent, "use-agent",0, "@"},
460     { oNoUseAgent, "no-use-agent",0, "@"},
461     { oGpgAgentInfo, "gpg-agent-info",2, "@"},
462     { oBatch, "batch", 0, "@"},
463     { oAnswerYes, "yes", 0, "@"},
464     { oAnswerNo, "no", 0, "@"},
465     { oKeyring, "keyring", 2, "@"},
466     { oPrimaryKeyring, "primary-keyring",2, "@" },
467     { oSecretKeyring, "secret-keyring", 2, "@"},
468     { oShowKeyring, "show-keyring", 0, "@"},
469     { oDefaultKey, "default-key", 2, "@"},
470     { oKeyServer, "keyserver", 2, "@"},
471     { oKeyServerOptions, "keyserver-options",2,"@"},
472     { oImportOptions, "import-options",2,"@"},
473     { oExportOptions, "export-options",2,"@"},
474     { oListOptions, "list-options",2,"@"},
475     { oVerifyOptions, "verify-options",2,"@"},
476     { oCharset, "charset", 2, "@"},
477     { oOptions, "options", 2, "@"},
478     { oDebug, "debug"     ,4|16, "@"},
479     { oDebugAll, "debug-all" ,0, "@"},
480     { oStatusFD, "status-fd" ,1, "@"},
481 #ifdef __riscos__
482     { oStatusFile, "status-file" ,2, "@"},
483 #endif /* __riscos__ */
484     { oAttributeFD, "attribute-fd" ,1, "@" },
485 #ifdef __riscos__
486     { oAttributeFile, "attribute-file" ,2, "@" },
487 #endif /* __riscos__ */
488     { oNoSKComments, "no-sk-comments", 0,   "@"},
489     { oSKComments, "sk-comments", 0,   "@"},
490     { oCompletesNeeded, "completes-needed", 1, "@"},
491     { oMarginalsNeeded, "marginals-needed", 1, "@"},
492     { oMaxCertDepth,    "max-cert-depth", 1, "@" },
493     { oTrustedKey, "trusted-key", 2, "@"},
494     { oLoadExtension, "load-extension", 2, "@"},
495     { oGnuPG, "gnupg",   0, "@"},
496     { oGnuPG, "no-pgp2", 0, "@"},
497     { oGnuPG, "no-pgp6", 0, "@"},
498     { oGnuPG, "no-pgp7", 0, "@"},
499     { oGnuPG, "no-pgp8", 0, "@"},
500     { oRFC1991, "rfc1991",   0, "@"},
501     { oRFC2440, "rfc2440", 0, "@" },
502     { oOpenPGP, "openpgp", 0, N_("use strict OpenPGP behavior")},
503     { oPGP2, "pgp2", 0, N_("generate PGP 2.x compatible messages")},
504     { oPGP6, "pgp6", 0, "@"},
505     { oPGP7, "pgp7", 0, "@"},
506     { oPGP8, "pgp8", 0, "@"},
507     { oS2KMode, "s2k-mode", 1, "@"},
508     { oS2KDigest, "s2k-digest-algo", 2, "@"},
509     { oS2KCipher, "s2k-cipher-algo", 2, "@"},
510     { oSimpleSKChecksum, "simple-sk-checksum", 0, "@"},
511     { oCipherAlgo, "cipher-algo", 2, "@"},
512     { oDigestAlgo, "digest-algo", 2, "@"},
513     { oCertDigestAlgo, "cert-digest-algo", 2 , "@" },
514     { oCompressAlgo,"compress-algo", 2, "@"},
515     { oThrowKeyid, "throw-keyid", 0, "@"},
516     { oNoThrowKeyid, "no-throw-keyid", 0, "@" },
517     { oShowPhotos,   "show-photos", 0, "@" },
518     { oNoShowPhotos, "no-show-photos", 0, "@" },
519     { oPhotoViewer,  "photo-viewer", 2, "@" },
520     { oSetNotation,  "set-notation", 2, "@" },
521     { oSetNotation,  "notation-data", 2, "@" }, /* Alias */
522     { oSigNotation,  "sig-notation", 2, "@" },
523     { oCertNotation, "cert-notation", 2, "@" },
524
525     { 302, NULL, 0, N_(
526   "@\n(See the man page for a complete listing of all commands and options)\n"
527                       )},
528
529     { 303, NULL, 0, N_("@\nExamples:\n\n"
530     " -se -r Bob [file]          sign and encrypt for user Bob\n"
531     " --clearsign [file]         make a clear text signature\n"
532     " --detach-sign [file]       make a detached signature\n"
533     " --list-keys [names]        show keys\n"
534     " --fingerprint [names]      show fingerprints\n"  ) },
535
536   /* hidden options */
537     { aListOwnerTrust, "list-ownertrust", 256, "@"}, /* deprecated */
538     { oCompressAlgo, "compression-algo", 1, "@"}, /* alias */
539     { aPrintMDs, "print-mds" , 256, "@"}, /* old */
540     { aListTrustDB, "list-trustdb",0 , "@"},
541     /* Not yet used */
542     /* { aListTrustPath, "list-trust-path",0, "@"}, */
543     { aPipeMode,  "pipemode", 0, "@" },
544     { oKOption, NULL,    0, "@"},
545     { oPasswdFD, "passphrase-fd",1, "@" },
546 #ifdef __riscos__
547     { oPasswdFile, "passphrase-file",2, "@" },
548 #endif /* __riscos__ */
549     { oCommandFD, "command-fd",1, "@" },
550 #ifdef __riscos__
551     { oCommandFile, "command-file",2, "@" },
552 #endif /* __riscos__ */
553     { oQuickRandom, "quick-random", 0, "@"},
554     { oNoVerbose, "no-verbose", 0, "@"},
555     { oTrustDBName, "trustdb-name", 2, "@" },
556     { oNoSecmemWarn, "no-secmem-warning", 0, "@" }, /* used only by regression tests */
557     { oNoPermissionWarn, "no-permission-warning", 0, "@" },
558     { oNoMDCWarn, "no-mdc-warning", 0, "@" },
559     { oNoArmor, "no-armor",   0, "@"},
560     { oNoArmor, "no-armour",   0, "@"},
561     { oNoDefKeyring, "no-default-keyring", 0, "@" },
562     { oNoGreeting, "no-greeting", 0, "@" },
563     { oNoOptions, "no-options", 0, "@" }, /* shortcut for --options /dev/null */
564     { oHomedir, "homedir", 2, "@" },   /* defaults to "~/.gnupg" */
565     { oNoBatch, "no-batch", 0, "@" },
566     { oWithColons, "with-colons", 0, "@"},
567     { oWithKeyData,"with-key-data", 0, "@"},
568     { aListKeys, "list-key", 0, "@" }, /* alias */
569     { aListSigs, "list-sig", 0, "@" }, /* alias */
570     { aCheckKeys, "check-sig",0, "@" }, /* alias */
571     { oSkipVerify, "skip-verify",0, "@" },
572     { oCompressKeys, "compress-keys",0, "@"},
573     { oCompressSigs, "compress-sigs",0, "@"},
574     { oDefCertLevel, "default-cert-check-level", 1, "@"}, /* Old option */
575     { oDefCertLevel, "default-cert-level", 1, "@"},
576     { oMinCertLevel, "min-cert-level", 1, "@"},
577     { oAlwaysTrust, "always-trust", 0, "@"},
578     { oTrustModel, "trust-model", 2, "@"},
579     { oForceOwnertrust, "force-ownertrust", 2, "@"},
580     { oRunAsShmCP, "run-as-shm-coprocess", 4, "@" },
581     { oSetFilename, "set-filename", 2, "@" },
582     { oForYourEyesOnly, "for-your-eyes-only", 0, "@" },
583     { oNoForYourEyesOnly, "no-for-your-eyes-only", 0, "@" },
584     { oSetPolicyURL, "set-policy-url", 2, "@" },
585     { oSigPolicyURL, "sig-policy-url", 2, "@" },
586     { oCertPolicyURL, "cert-policy-url", 2, "@" },
587     { oShowPolicyURL, "show-policy-url", 0, "@" },
588     { oNoShowPolicyURL, "no-show-policy-url", 0, "@" },
589     { oSigKeyserverURL, "sig-keyserver-url", 2, "@" },
590     { oShowNotation, "show-notation", 0, "@" },
591     { oNoShowNotation, "no-show-notation", 0, "@" },
592     { oComment, "comment", 2, "@" },
593     { oDefaultComment, "default-comment", 0, "@" },
594     { oNoComments, "no-comments", 0, "@" },
595     { oEmitVersion, "emit-version", 0, "@"},
596     { oNoEmitVersion, "no-emit-version", 0, "@"},
597     { oNoEmitVersion, "no-version", 0, "@"}, /* alias */
598     { oNotDashEscaped, "not-dash-escaped", 0, "@" },
599     { oEscapeFrom, "escape-from-lines", 0, "@" },
600     { oNoEscapeFrom, "no-escape-from-lines", 0, "@" },
601     { oLockOnce, "lock-once", 0, "@" },
602     { oLockMultiple, "lock-multiple", 0, "@" },
603     { oLockNever, "lock-never", 0, "@" },
604     { oLoggerFD, "logger-fd",1, "@" },
605 #ifdef __riscos__
606     { oLoggerFile, "logger-file",2, "@" },
607 #endif /* __riscos__ */
608     { oUseEmbeddedFilename, "use-embedded-filename", 0, "@" },
609     { oUtf8Strings, "utf8-strings", 0, "@" },
610     { oNoUtf8Strings, "no-utf8-strings", 0, "@" },
611     { oWithFingerprint, "with-fingerprint", 0, "@" },
612     { oDisableCipherAlgo,  "disable-cipher-algo", 2, "@" },
613     { oDisablePubkeyAlgo,  "disable-pubkey-algo", 2, "@" },
614     { oAllowNonSelfsignedUID, "allow-non-selfsigned-uid", 0, "@" },
615     { oNoAllowNonSelfsignedUID, "no-allow-non-selfsigned-uid", 0, "@" },
616     { oAllowFreeformUID, "allow-freeform-uid", 0, "@" },
617     { oNoAllowFreeformUID, "no-allow-freeform-uid", 0, "@" },
618     { oNoLiteral, "no-literal", 0, "@" },
619     { oSetFilesize, "set-filesize", 20, "@" },
620     { oHonorHttpProxy,"honor-http-proxy", 0, "@" },
621     { oFastListMode,"fast-list-mode", 0, "@" },
622     { oFixedListMode,"fixed-list-mode", 0, "@" },
623     { oListOnly, "list-only", 0, "@"},
624     { oIgnoreTimeConflict, "ignore-time-conflict", 0, "@" },
625     { oIgnoreValidFrom,    "ignore-valid-from",    0, "@" },
626     { oIgnoreCrcError, "ignore-crc-error", 0,"@" },
627     { oIgnoreMDCError, "ignore-mdc-error", 0,"@" },
628     { oShowSessionKey, "show-session-key", 0, "@" },
629     { oOverrideSessionKey, "override-session-key", 2, "@" },
630     { oNoRandomSeedFile,  "no-random-seed-file", 0, "@" },
631     { oAutoKeyRetrieve, "auto-key-retrieve", 0, "@" },
632     { oNoAutoKeyRetrieve, "no-auto-key-retrieve", 0, "@" },
633     { oNoSigCache,         "no-sig-cache", 0, "@" },
634     { oNoSigCreateCheck,   "no-sig-create-check", 0, "@" },
635     { oAutoCheckTrustDB, "auto-check-trustdb", 0, "@"},
636     { oNoAutoCheckTrustDB, "no-auto-check-trustdb", 0, "@"},
637     { oMergeOnly,         "merge-only", 0, "@" },
638     { oAllowSecretKeyImport, "allow-secret-key-import", 0, "@" },
639     { oTryAllSecrets,  "try-all-secrets", 0, "@" },
640     { oEnableSpecialFilenames, "enable-special-filenames", 0, "@" },
641     { oNoExpensiveTrustChecks, "no-expensive-trust-checks", 0, "@" },
642     { aDeleteSecretAndPublicKeys, "delete-secret-and-public-keys",256, "@" },
643     { aRebuildKeydbCaches, "rebuild-keydb-caches", 256, "@"},
644     { oPreservePermissions, "preserve-permissions", 0, "@"},
645     { oDefaultPreferenceList,  "default-preference-list", 2, "@"},
646     { oPersonalCipherPreferences,  "personal-cipher-preferences", 2, "@"},
647     { oPersonalDigestPreferences,  "personal-digest-preferences", 2, "@"},
648     { oPersonalCompressPreferences,  "personal-compress-preferences", 2, "@"},
649     /* Aliases.  I constantly mistype these, and assume other people
650        do as well. */
651     { oPersonalCipherPreferences, "personal-cipher-prefs", 2, "@"},
652     { oPersonalDigestPreferences, "personal-digest-prefs", 2, "@"},
653     { oPersonalCompressPreferences, "personal-compress-prefs", 2, "@"},
654     { oDisplay,    "display",     2, "@" },
655     { oTTYname,    "ttyname",     2, "@" },
656     { oTTYtype,    "ttytype",     2, "@" },
657     { oLCctype,    "lc-ctype",    2, "@" },
658     { oLCmessages, "lc-messages", 2, "@" },
659     { oGroup,      "group",       2, "@" },
660     { oUnGroup,    "ungroup",     2, "@" },
661     { oNoGroups,   "no-groups",    0, "@" },
662     { oStrict,     "strict",      0, "@" },
663     { oNoStrict,   "no-strict",   0, "@" },
664     { oMangleDosFilenames, "mangle-dos-filenames", 0, "@" },
665     { oNoMangleDosFilenames, "no-mangle-dos-filenames", 0, "@" },
666     { oEnableProgressFilter, "enable-progress-filter", 0, "@" },
667     { oMultifile, "multifile", 0, "@" },
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=
1437       EXPORT_INCLUDE_NON_RFC|EXPORT_INCLUDE_ATTRIBUTES;
1438     opt.keyserver_options.import_options=IMPORT_REPAIR_PKS_SUBKEY_BUG;
1439     opt.keyserver_options.export_options=
1440       EXPORT_INCLUDE_NON_RFC|EXPORT_INCLUDE_ATTRIBUTES;
1441     opt.keyserver_options.include_subkeys=1;
1442     opt.keyserver_options.include_revoked=1;
1443     opt.keyserver_options.try_dns_srv=1;
1444     opt.verify_options=
1445       VERIFY_SHOW_POLICY_URLS|VERIFY_SHOW_NOTATIONS|VERIFY_SHOW_KEYSERVER_URLS;
1446     opt.trust_model=TM_AUTO;
1447     opt.mangle_dos_filenames=0;
1448     opt.min_cert_level=2;
1449     set_screen_dimensions();
1450 #if defined (_WIN32)
1451     set_homedir ( read_w32_registry_string( NULL,
1452                                     "Software\\GNU\\GnuPG", "HomeDir" ));
1453 #else
1454     set_homedir ( getenv("GNUPGHOME") );
1455 #endif
1456     if( !*opt.homedir )
1457         set_homedir ( GNUPG_HOMEDIR );
1458
1459 #ifdef ENABLE_CARD_SUPPORT
1460 # ifdef _WIN32
1461     opt.pcsc_driver = "winscard.dll"; 
1462 #else
1463     opt.pcsc_driver = "libpcsclite.so"; 
1464 #endif
1465 #endif /*ENABLE_CARD_SUPPORT*/
1466
1467     /* check whether we have a config file on the commandline */
1468     orig_argc = argc;
1469     orig_argv = argv;
1470     pargs.argc = &argc;
1471     pargs.argv = &argv;
1472     pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
1473     while( arg_parse( &pargs, opts) ) {
1474         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
1475             parse_debug++;
1476         else if( pargs.r_opt == oOptions ) {
1477             /* yes there is one, so we do not try the default one, but
1478              * read the option file when it is encountered at the commandline
1479              */
1480             default_config = 0;
1481         }
1482         else if( pargs.r_opt == oNoOptions )
1483             default_config = 0; /* --no-options */
1484         else if( pargs.r_opt == oHomedir )
1485             set_homedir ( pargs.r.ret_str );
1486         else if( pargs.r_opt == oNoPermissionWarn )
1487             opt.no_perm_warn=1;
1488         else if (pargs.r_opt == oStrict )
1489           {
1490             opt.strict=1;
1491             log_set_strict(1);
1492           }
1493         else if (pargs.r_opt == oNoStrict )
1494           {
1495             opt.strict=0;
1496             log_set_strict(0);
1497           }
1498 #ifdef USE_SHM_COPROCESSING
1499         else if( pargs.r_opt == oRunAsShmCP ) {
1500             /* does not make sense in a options file, we do it here,
1501              * so that we are the able to drop setuid as soon as possible */
1502             opt.shm_coprocess = 1;
1503             requested_shm_size = pargs.r.ret_ulong;
1504         }
1505         else if ( pargs.r_opt == oStatusFD ) {
1506             /* this is needed to ensure that the status-fd filedescriptor is
1507              * initialized when init_shm_coprocessing() is called */
1508             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1509         }
1510 #endif
1511     }
1512
1513 #ifdef HAVE_DOSISH_SYSTEM
1514     if ( strchr (opt.homedir,'\\') ) {
1515         char *d, *buf = m_alloc (strlen (opt.homedir)+1);
1516         const char *s = opt.homedir;
1517         for (d=buf,s=opt.homedir; *s; s++)
1518             *d++ = *s == '\\'? '/': *s;
1519         *d = 0;
1520         set_homedir (buf);
1521     }
1522 #endif
1523 #ifdef USE_SHM_COPROCESSING
1524     if( opt.shm_coprocess ) {
1525         init_shm_coprocessing(requested_shm_size, 1 );
1526     }
1527 #endif
1528     /* initialize the secure memory. */
1529     secmem_init( 32768 );
1530     maybe_setuid = 0;
1531     /* Okay, we are now working under our real uid */
1532
1533     set_native_charset (NULL); /* Try to auto set the character set */
1534
1535     /* Try for a version specific config file first */
1536     if( default_config )
1537       {
1538         char *name=m_strdup("gpg" EXTSEP_S "conf-" SAFE_VERSION);
1539         char *ver=&name[strlen("gpg" EXTSEP_S "conf-")];
1540
1541         do
1542           {
1543             if(configname)
1544               {
1545                 char *tok;
1546
1547                 m_free(configname);
1548                 configname=NULL;
1549
1550                 if((tok=strrchr(ver,SAFE_VERSION_DASH)))
1551                   *tok='\0';
1552                 else if((tok=strrchr(ver,SAFE_VERSION_DOT)))
1553                   *tok='\0';
1554                 else
1555                   break;
1556               }
1557
1558             configname = make_filename(opt.homedir,name,NULL);
1559           }
1560         while(access(configname,R_OK));
1561
1562         m_free(name);
1563
1564         if(!configname)
1565           configname=make_filename(opt.homedir, "gpg" EXTSEP_S "conf", NULL );
1566         if (!access (configname, R_OK))
1567           { /* Print a warning when both config files are present. */
1568             char *p = make_filename(opt.homedir, "options", NULL );
1569             if (!access (p, R_OK))
1570               log_info (_("NOTE: old default options file `%s' ignored\n"), p);
1571             m_free (p);
1572           }
1573         else
1574           { /* Keep on using the old default one. */
1575             m_free (configname);
1576             configname = make_filename(opt.homedir, "options", NULL );
1577           }
1578       }
1579     argc = orig_argc;
1580     argv = orig_argv;
1581     pargs.argc = &argc;
1582     pargs.argv = &argv;
1583     pargs.flags=  1;  /* do not remove the args */
1584
1585     /* By this point we have a homedir, and cannot change it. */
1586     check_permissions(opt.homedir,0);
1587
1588   next_pass:
1589     if( configname ) {
1590       if(check_permissions(configname,1))
1591         {
1592           /* If any options file is unsafe, then disable any external
1593              programs for keyserver calls or photo IDs.  Since the
1594              external program to call is set in the options file, a
1595              unsafe options file can lead to an arbitrary program
1596              being run. */
1597
1598           opt.exec_disable=1;
1599         }
1600
1601         configlineno = 0;
1602         configfp = fopen( configname, "r" );
1603         if( !configfp ) {
1604             if( default_config ) {
1605                 if( parse_debug )
1606                     log_info(_("NOTE: no default option file `%s'\n"),
1607                                                             configname );
1608             }
1609             else {
1610                 log_error(_("option file `%s': %s\n"),
1611                                     configname, strerror(errno) );
1612                 g10_exit(2);
1613             }
1614             m_free(configname); configname = NULL;
1615         }
1616         if( parse_debug && configname )
1617             log_info(_("reading options from `%s'\n"), configname );
1618         default_config = 0;
1619     }
1620
1621     while( optfile_parse( configfp, configname, &configlineno,
1622                                                 &pargs, opts) )
1623       {
1624         switch( pargs.r_opt )
1625           {
1626           case aCheckKeys: set_cmd( &cmd, aCheckKeys); break;
1627           case aListConfig: set_cmd( &cmd, aListConfig); break;
1628           case aListPackets: set_cmd( &cmd, aListPackets); break;
1629           case aImport: set_cmd( &cmd, aImport); break;
1630           case aFastImport: set_cmd( &cmd, aFastImport); break;
1631           case aSendKeys: set_cmd( &cmd, aSendKeys); break;
1632           case aRecvKeys: set_cmd( &cmd, aRecvKeys); break;
1633           case aSearchKeys: set_cmd( &cmd, aSearchKeys); break;
1634           case aRefreshKeys: set_cmd( &cmd, aRefreshKeys); break;
1635           case aExport: set_cmd( &cmd, aExport); break;
1636           case aExportAll:
1637             opt.export_options|=EXPORT_INCLUDE_NON_RFC;
1638             set_cmd(&cmd,aExport);
1639             break;
1640           case aListKeys: set_cmd( &cmd, aListKeys); break;
1641           case aListSigs: set_cmd( &cmd, aListSigs); break;
1642           case aExportSecret: set_cmd( &cmd, aExportSecret); break;
1643           case aExportSecretSub: set_cmd( &cmd, aExportSecretSub); break;
1644           case aDeleteSecretKeys:
1645             set_cmd( &cmd, aDeleteSecretKeys);
1646             greeting=1;
1647             break;
1648           case aDeleteSecretAndPublicKeys:
1649             set_cmd( &cmd, aDeleteSecretAndPublicKeys);
1650             greeting=1; 
1651             break;
1652           case aDeleteKeys: set_cmd( &cmd, aDeleteKeys); greeting=1; break;
1653
1654           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
1655           case aSym: set_cmd( &cmd, aSym); break;
1656
1657           case aDecryptFiles: multifile=1; /* fall through */
1658           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
1659
1660           case aEncrFiles: multifile=1; /* fall through */
1661           case aEncr: set_cmd( &cmd, aEncr); break;
1662
1663           case aVerifyFiles: multifile=1; /* fall through */
1664           case aVerify: set_cmd( &cmd, aVerify); break;
1665
1666           case aSign: set_cmd( &cmd, aSign );  break;
1667           case aKeygen: set_cmd( &cmd, aKeygen); greeting=1; break;
1668           case aSignKey: set_cmd( &cmd, aSignKey); break;
1669           case aLSignKey: set_cmd( &cmd, aLSignKey); break;
1670           case aNRSignKey: set_cmd( &cmd, aNRSignKey); break;
1671           case aNRLSignKey: set_cmd( &cmd, aNRLSignKey); break;
1672           case aStore: set_cmd( &cmd, aStore); break;
1673           case aEditKey: set_cmd( &cmd, aEditKey); greeting=1; break;
1674           case aClearsign: set_cmd( &cmd, aClearsign); break;
1675           case aGenRevoke: set_cmd( &cmd, aGenRevoke); break;
1676           case aDesigRevoke: set_cmd( &cmd, aDesigRevoke); break;
1677           case aPrimegen: set_cmd( &cmd, aPrimegen); break;
1678           case aGenRandom: set_cmd( &cmd, aGenRandom); break;
1679           case aPrintMD: set_cmd( &cmd, aPrintMD); break;
1680           case aPrintMDs: set_cmd( &cmd, aPrintMDs); break;
1681           case aListTrustDB: set_cmd( &cmd, aListTrustDB); break;
1682           case aCheckTrustDB: set_cmd( &cmd, aCheckTrustDB); break;
1683           case aUpdateTrustDB: set_cmd( &cmd, aUpdateTrustDB); break;
1684           case aFixTrustDB: set_cmd( &cmd, aFixTrustDB); break;
1685           case aListTrustPath: set_cmd( &cmd, aListTrustPath); break;
1686           case aDeArmor: set_cmd( &cmd, aDeArmor); break;
1687           case aEnArmor: set_cmd( &cmd, aEnArmor); break;
1688           case aListOwnerTrust:
1689             deprecated_warning(configname,configlineno,
1690                                "--list-ownertrust","--export-ownertrust","");
1691           case aExportOwnerTrust: set_cmd( &cmd, aExportOwnerTrust); break;
1692           case aImportOwnerTrust: set_cmd( &cmd, aImportOwnerTrust); break;
1693           case aPipeMode: set_cmd( &cmd, aPipeMode); break;
1694           case aRebuildKeydbCaches: set_cmd( &cmd, aRebuildKeydbCaches); break;
1695
1696 #ifdef ENABLE_CARD_SUPPORT
1697           case aCardStatus: set_cmd (&cmd, aCardStatus); break;
1698           case aCardEdit: set_cmd (&cmd, aCardEdit); break;
1699           case aChangePIN: set_cmd (&cmd, aChangePIN); break;
1700           case oReaderPort:
1701             card_set_reader_port (pargs.r.ret_str);
1702             break;
1703           case octapiDriver: opt.ctapi_driver = pargs.r.ret_str; break;
1704           case opcscDriver: opt.pcsc_driver = pargs.r.ret_str; break;
1705           case oDisableCCID: opt.disable_ccid = 1; break;
1706 #endif /* ENABLE_CARD_SUPPORT*/
1707
1708           case oArmor: opt.armor = 1; opt.no_armor=0; break;
1709           case oOutput: opt.outfile = pargs.r.ret_str; break;
1710           case oMaxOutput: opt.max_output = pargs.r.ret_ulong; break;
1711           case oQuiet: opt.quiet = 1; break;
1712           case oNoTTY: tty_no_terminal(1); break;
1713           case oDryRun: opt.dry_run = 1; break;
1714           case oInteractive: opt.interactive = 1; break;
1715           case oVerbose:
1716             g10_opt_verbose++;
1717             opt.verbose++;
1718             opt.list_options|=LIST_SHOW_UNUSABLE_UIDS;
1719             opt.list_options|=LIST_SHOW_UNUSABLE_SUBKEYS;
1720             break;
1721           case oKOption: set_cmd( &cmd, aKMode ); break;
1722
1723           case oBatch: opt.batch = 1; nogreeting = 1; break;
1724           case oUseAgent:
1725 #ifndef __riscos__
1726             opt.use_agent = 1;
1727 #else /* __riscos__ */
1728             opt.use_agent = 0;
1729             riscos_not_implemented("use-agent");
1730 #endif /* __riscos__ */
1731             break;
1732           case oNoUseAgent: opt.use_agent = 0; break;
1733           case oGpgAgentInfo: opt.gpg_agent_info = pargs.r.ret_str; break;
1734           case oAnswerYes: opt.answer_yes = 1; break;
1735           case oAnswerNo: opt.answer_no = 1; break;
1736           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
1737           case oPrimaryKeyring:
1738             sl=append_to_strlist( &nrings, pargs.r.ret_str);
1739             sl->flags=2;
1740             break;
1741           case oShowKeyring:
1742             deprecated_warning(configname,configlineno,"--show-keyring",
1743                                "--list-options ","show-keyring");
1744             opt.list_options|=LIST_SHOW_KEYRING;
1745             break;
1746           case oDebug: opt.debug |= pargs.r.ret_ulong; break;
1747           case oDebugAll: opt.debug = ~0; break;
1748           case oStatusFD:
1749             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1750             break;
1751 #ifdef __riscos__
1752           case oStatusFile:
1753             set_status_fd( iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 1), 1) );
1754             break;
1755 #endif /* __riscos__ */
1756           case oAttributeFD:
1757             set_attrib_fd(iobuf_translate_file_handle (pargs.r.ret_int, 1));
1758             break;
1759 #ifdef __riscos__
1760           case oAttributeFile:
1761             set_attrib_fd(iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 1), 1) );
1762             break;
1763 #endif /* __riscos__ */
1764           case oLoggerFD:
1765             log_set_logfile( NULL,
1766                              iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1767             break;
1768 #ifdef __riscos__
1769           case oLoggerFile:
1770             log_set_logfile( NULL,
1771                              iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 1), 1) );
1772             break;
1773 #endif /* __riscos__ */
1774           case oWithFingerprint:
1775             opt.with_fingerprint = 1;
1776             with_fpr=1; /*fall thru*/
1777           case oFingerprint: opt.fingerprint++; break;
1778           case oSecretKeyring: append_to_strlist( &sec_nrings, pargs.r.ret_str); break;
1779           case oOptions:
1780             /* config files may not be nested (silently ignore them) */
1781             if( !configfp ) {
1782                 m_free(configname);
1783                 configname = m_strdup(pargs.r.ret_str);
1784                 goto next_pass;
1785             }
1786             break;
1787           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
1788           case oNoDefKeyring: default_keyring = 0; break;
1789           case oDefCertLevel: opt.def_cert_level=pargs.r.ret_int; break;
1790           case oMinCertLevel: opt.min_cert_level=pargs.r.ret_int; break;
1791           case oNoGreeting: nogreeting = 1; break;
1792           case oNoVerbose: g10_opt_verbose = 0;
1793                            opt.verbose = 0; opt.list_sigs=0; break;
1794           case oQuickRandom: quick_random_gen(1); break;
1795           case oSKComments: opt.sk_comments=1; break;
1796           case oNoSKComments: opt.sk_comments=0; break;
1797           case oEmitVersion: opt.no_version=0; break;
1798           case oNoEmitVersion: opt.no_version=1; break;
1799           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
1800           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
1801           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
1802           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
1803           case oDefaultKey: opt.def_secret_key = pargs.r.ret_str; break;
1804           case oDefRecipient:
1805                     if( *pargs.r.ret_str )
1806                         opt.def_recipient = make_username(pargs.r.ret_str);
1807                     break;
1808           case oDefRecipientSelf:
1809                     m_free(opt.def_recipient); opt.def_recipient = NULL;
1810                     opt.def_recipient_self = 1;
1811                     break;
1812           case oNoDefRecipient:
1813                     m_free(opt.def_recipient); opt.def_recipient = NULL;
1814                     opt.def_recipient_self = 0;
1815                     break;
1816           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
1817           case oHomedir: break;
1818           case oNoBatch: opt.batch = 0; break;
1819           case oWithKeyData: opt.with_key_data=1; /* fall thru */
1820           case oWithColons: opt.with_colons=':'; break;
1821
1822           case oSkipVerify: opt.skip_verify=1; break;
1823           case oCompressKeys: opt.compress_keys = 1; break;
1824           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
1825             /* There are many programs (like mutt) that call gpg with
1826                --always-trust so keep this option around for a long
1827                time. */
1828           case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
1829           case oTrustModel:
1830             if(ascii_strcasecmp(pargs.r.ret_str,"pgp")==0)
1831               opt.trust_model=TM_PGP;
1832             else if(ascii_strcasecmp(pargs.r.ret_str,"classic")==0)
1833               opt.trust_model=TM_CLASSIC;
1834             else if(ascii_strcasecmp(pargs.r.ret_str,"always")==0)
1835               opt.trust_model=TM_ALWAYS;
1836             else if(ascii_strcasecmp(pargs.r.ret_str,"auto")==0)
1837               opt.trust_model=TM_AUTO;
1838             else
1839               log_error("unknown trust model \"%s\"\n",pargs.r.ret_str);
1840             break;
1841           case oForceOwnertrust:
1842             log_info(_("NOTE: %s is not for normal use!\n"),
1843                      "--force-ownertrust");
1844             opt.force_ownertrust=string_to_trust_value(pargs.r.ret_str);
1845             if(opt.force_ownertrust==-1)
1846               {
1847                 log_error("invalid ownertrust \"%s\"\n",pargs.r.ret_str);
1848                 opt.force_ownertrust=0;
1849               }
1850             break;
1851           case oLoadExtension:
1852 #ifndef __riscos__
1853 #if defined(USE_DYNAMIC_LINKING) || defined(_WIN32)
1854             if(check_permissions(pargs.r.ret_str,2))
1855               log_info(_("cipher extension \"%s\" not loaded due to "
1856                          "unsafe permissions\n"),pargs.r.ret_str);
1857             else
1858               register_cipher_extension(orig_argc? *orig_argv:NULL,
1859                                         pargs.r.ret_str);
1860 #endif
1861 #else /* __riscos__ */
1862             riscos_not_implemented("load-extension");
1863 #endif /* __riscos__ */
1864             break;
1865           case oRFC1991:
1866             opt.compliance = CO_RFC1991;
1867             opt.force_v4_certs = 0;
1868             opt.escape_from = 1;
1869             break;
1870           case oRFC2440:
1871           case oOpenPGP:
1872             /* TODO: When 2440bis becomes a RFC, these may need
1873                changing. */
1874             opt.compliance = CO_RFC2440;
1875             opt.allow_non_selfsigned_uid = 1;
1876             opt.allow_freeform_uid = 1;
1877             opt.pgp2_workarounds = 0;
1878             opt.escape_from = 0;
1879             opt.force_v3_sigs = 0;
1880             opt.compress_keys = 0;          /* not mandated  but we do it */
1881             opt.compress_sigs = 0;          /* ditto. */
1882             opt.not_dash_escaped = 0;
1883             opt.def_cipher_algo = 0;
1884             opt.def_digest_algo = 0;
1885             opt.cert_digest_algo = 0;
1886             opt.compress_algo = -1;
1887             opt.s2k_mode = 3; /* iterated+salted */
1888             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
1889             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
1890             break;
1891           case oPGP2:  opt.compliance = CO_PGP2;  break;
1892           case oPGP6:  opt.compliance = CO_PGP6;  break;
1893           case oPGP7:  opt.compliance = CO_PGP7;  break;
1894           case oPGP8:  opt.compliance = CO_PGP8;  break;
1895           case oGnuPG: opt.compliance = CO_GNUPG; break;
1896           case oCompressSigs: opt.compress_sigs = 1; break;
1897           case oRunAsShmCP:
1898 #ifndef __riscos__
1899 # ifndef USE_SHM_COPROCESSING
1900             /* not possible in the option file,
1901              * but we print the warning here anyway */
1902             log_error("shared memory coprocessing is not available\n");
1903 # endif
1904 #else /* __riscos__ */
1905             riscos_not_implemented("run-as-shm-coprocess");
1906 #endif /* __riscos__ */
1907             break;
1908           case oSetFilename: opt.set_filename = pargs.r.ret_str; break;
1909           case oForYourEyesOnly: eyes_only = 1; break;
1910           case oNoForYourEyesOnly: eyes_only = 0; break;
1911           case oSetPolicyURL:
1912             add_policy_url(pargs.r.ret_str,0);
1913             add_policy_url(pargs.r.ret_str,1);
1914             break;
1915           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
1916           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
1917           case oShowPolicyURL:
1918             deprecated_warning(configname,configlineno,"--show-policy-url",
1919                                "--list-options ","show-policy-urls");
1920             deprecated_warning(configname,configlineno,"--show-policy-url",
1921                                "--verify-options ","show-policy-urls");
1922             opt.list_options|=LIST_SHOW_POLICY_URLS;
1923             opt.verify_options|=VERIFY_SHOW_POLICY_URLS;
1924             break;
1925           case oNoShowPolicyURL:
1926             deprecated_warning(configname,configlineno,"--no-show-policy-url",
1927                                "--list-options ","no-show-policy-urls");
1928             deprecated_warning(configname,configlineno,"--no-show-policy-url",
1929                                "--verify-options ","no-show-policy-urls");
1930             opt.list_options&=~LIST_SHOW_POLICY_URLS;
1931             opt.verify_options&=~VERIFY_SHOW_POLICY_URLS;
1932             break;
1933           case oSigKeyserverURL: add_keyserver_url(pargs.r.ret_str,0); break;
1934           case oUseEmbeddedFilename: opt.use_embedded_filename = 1; break;
1935           case oComment:
1936             if(pargs.r.ret_str[0])
1937               add_to_strlist(&opt.comments,pargs.r.ret_str);
1938             break;
1939           case oDefaultComment:
1940             deprecated_warning(configname,configlineno,
1941                                "--default-comment","--no-comments","");
1942             /* fall through */
1943           case oNoComments:
1944             free_strlist(opt.comments);
1945             opt.comments=NULL;
1946             break;
1947           case oThrowKeyid: opt.throw_keyid = 1; break;
1948           case oNoThrowKeyid: opt.throw_keyid = 0; break;
1949           case oShowPhotos:
1950             deprecated_warning(configname,configlineno,"--show-photos",
1951                                "--list-options ","show-photos");
1952             deprecated_warning(configname,configlineno,"--show-photos",
1953                                "--verify-options ","show-photos");
1954             opt.list_options|=LIST_SHOW_PHOTOS;
1955             opt.verify_options|=VERIFY_SHOW_PHOTOS;
1956             break;
1957           case oNoShowPhotos:
1958             deprecated_warning(configname,configlineno,"--no-show-photos",
1959                                "--list-options ","no-show-photos");
1960             deprecated_warning(configname,configlineno,"--no-show-photos",
1961                                "--verify-options ","no-show-photos");
1962             opt.list_options&=~LIST_SHOW_PHOTOS;
1963             opt.verify_options&=~VERIFY_SHOW_PHOTOS;
1964             break;
1965           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
1966           case oForceV3Sigs: opt.force_v3_sigs = 1; break;
1967           case oNoForceV3Sigs: opt.force_v3_sigs = 0; break;
1968           case oForceV4Certs: opt.force_v4_certs = 1; break;
1969           case oNoForceV4Certs: opt.force_v4_certs = 0; break;
1970           case oForceMDC: opt.force_mdc = 1; break;
1971           case oNoForceMDC: opt.force_mdc = 0; break;
1972           case oDisableMDC: opt.disable_mdc = 1; break;
1973           case oNoDisableMDC: opt.disable_mdc = 0; break;
1974           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
1975           case oS2KDigest: s2k_digest_string = m_strdup(pargs.r.ret_str); break;
1976           case oS2KCipher: s2k_cipher_string = m_strdup(pargs.r.ret_str); break;
1977           case oSimpleSKChecksum: opt.simple_sk_checksum = 1; break;
1978           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
1979           case oEncryptTo: /* store the recipient in the second list */
1980             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1981             sl->flags = 1;
1982             break;
1983           case oHiddenEncryptTo: /* store the recipient in the second list */
1984             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1985             sl->flags = 1|2;
1986             break;
1987           case oRecipient: /* store the recipient */
1988             add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1989             any_explicit_recipient = 1;
1990             break;
1991           case oHiddenRecipient: /* store the recipient with a flag */
1992             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1993             sl->flags = 2;
1994             any_explicit_recipient = 1;
1995             break;
1996           case oTextmodeShort: opt.textmode = 2; break;
1997           case oTextmode: opt.textmode=1;  break;
1998           case oNoTextmode: opt.textmode=0;  break;
1999           case oExpert: opt.expert = 1; break;
2000           case oNoExpert: opt.expert = 0; break;
2001           case oAskSigExpire: opt.ask_sig_expire = 1; break;
2002           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
2003           case oAskCertExpire: opt.ask_cert_expire = 1; break;
2004           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
2005           case oAskCertLevel: opt.ask_cert_level = 1; break;
2006           case oNoAskCertLevel: opt.ask_cert_level = 0; break;
2007           case oUser: /* store the local users */
2008             add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
2009             break;
2010           case oCompress:
2011             /* this is the -z command line option */
2012             opt.compress_level = opt.bz2_compress_level = pargs.r.ret_int;
2013             break;
2014           case oCompressLevel: opt.compress_level = pargs.r.ret_int; break;
2015           case oBZ2CompressLevel: opt.bz2_compress_level = pargs.r.ret_int; break;
2016           case oBZ2CompressLowmem: opt.bz2_compress_lowmem=1; break;
2017           case oPasswdFD:
2018             pwfd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
2019             opt.use_agent = 0;
2020             break;
2021 #ifdef __riscos__
2022           case oPasswdFile:
2023             pwfd = iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 0), 0);
2024             break;
2025 #endif /* __riscos__ */
2026           case oCommandFD:
2027             opt.command_fd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
2028             break;
2029 #ifdef __riscos__
2030           case oCommandFile:
2031             opt.command_fd = iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 0), 0);
2032             break;
2033 #endif /* __riscos__ */
2034           case oCipherAlgo: def_cipher_string = m_strdup(pargs.r.ret_str); break;
2035           case oDigestAlgo: def_digest_string = m_strdup(pargs.r.ret_str); break;
2036           case oCompressAlgo:
2037             /* If it is all digits, stick a Z in front of it for
2038                later.  This is for backwards compatibility with
2039                versions that took the compress algorithm number. */
2040             {
2041               char *pt=pargs.r.ret_str;
2042               while(*pt)
2043                 {
2044                   if(!isdigit(*pt))
2045                     break;
2046
2047                   pt++;
2048                 }
2049
2050               if(*pt=='\0')
2051                 {
2052                   compress_algo_string=m_alloc(strlen(pargs.r.ret_str)+2);
2053                   strcpy(compress_algo_string,"Z");
2054                   strcat(compress_algo_string,pargs.r.ret_str);
2055                 }
2056               else
2057                 compress_algo_string = m_strdup(pargs.r.ret_str);
2058             }
2059             break;
2060           case oCertDigestAlgo: cert_digest_string = m_strdup(pargs.r.ret_str); break;
2061           case oNoSecmemWarn: secmem_set_flags( secmem_get_flags() | 1 ); break;
2062           case oNoPermissionWarn: opt.no_perm_warn=1; break;
2063           case oNoMDCWarn: opt.no_mdc_warn=1; break;
2064           case oCharset:
2065             if( set_native_charset( pargs.r.ret_str ) )
2066                 log_error(_("%s is not a valid character set\n"),
2067                                                     pargs.r.ret_str);
2068             break;
2069           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
2070           case oEscapeFrom: opt.escape_from = 1; break;
2071           case oNoEscapeFrom: opt.escape_from = 0; break;
2072           case oLockOnce: opt.lock_once = 1; break;
2073           case oLockNever: disable_dotlock(); break;
2074           case oLockMultiple:
2075 #ifndef __riscos__
2076             opt.lock_once = 0;
2077 #else /* __riscos__ */
2078             riscos_not_implemented("lock-multiple");
2079 #endif /* __riscos__ */
2080             break;
2081           case oKeyServer:
2082             opt.keyserver_uri=m_strdup(pargs.r.ret_str);
2083             if(parse_keyserver_uri(pargs.r.ret_str,configname,configlineno))
2084               log_error(_("could not parse keyserver URI\n"));
2085             break;
2086           case oKeyServerOptions:
2087             parse_keyserver_options(pargs.r.ret_str);
2088             break;
2089           case oImportOptions:
2090             if(!parse_import_options(pargs.r.ret_str,&opt.import_options,1))
2091               {
2092                 if(configname)
2093                   log_error(_("%s:%d: invalid import options\n"),
2094                             configname,configlineno);
2095                 else
2096                   log_error(_("invalid import options\n"));
2097               }
2098             break;
2099           case oExportOptions:
2100             if(!parse_export_options(pargs.r.ret_str,&opt.export_options,1))
2101               {
2102                 if(configname)
2103                   log_error(_("%s:%d: invalid export options\n"),
2104                             configname,configlineno);
2105                 else
2106                   log_error(_("invalid export options\n"));
2107               }
2108             break;
2109           case oListOptions:
2110             {
2111               struct parse_options lopts[]=
2112                 {
2113                   {"show-photos",LIST_SHOW_PHOTOS,NULL},
2114                   {"show-policy-urls",LIST_SHOW_POLICY_URLS,NULL},
2115                   {"show-notations",LIST_SHOW_NOTATIONS,NULL},
2116                   {"show-keyserver-urls",LIST_SHOW_KEYSERVER_URLS,NULL},
2117                   {"show-validity",LIST_SHOW_VALIDITY,NULL},
2118                   {"show-long-keyids",LIST_SHOW_LONG_KEYIDS,NULL},
2119                   {"show-unusable-uids",LIST_SHOW_UNUSABLE_UIDS,NULL},
2120                   {"show-unusable-subkeys",LIST_SHOW_UNUSABLE_SUBKEYS,NULL},
2121                   {"show-keyring",LIST_SHOW_KEYRING,NULL},
2122                   {"show-sig-expire",LIST_SHOW_SIG_EXPIRE,NULL},
2123                   {NULL,0,NULL}
2124                 };
2125
2126               if(!parse_options(pargs.r.ret_str,&opt.list_options,lopts,1))
2127                 {
2128                   if(configname)
2129                     log_error(_("%s:%d: invalid list options\n"),
2130                               configname,configlineno);
2131                   else
2132                     log_error(_("invalid list options\n"));
2133                 }
2134             }
2135             break;
2136           case oVerifyOptions:
2137             {
2138               struct parse_options vopts[]=
2139                 {
2140                   {"show-photos",VERIFY_SHOW_PHOTOS,NULL},
2141                   {"show-policy-urls",VERIFY_SHOW_POLICY_URLS,NULL},
2142                   {"show-notations",VERIFY_SHOW_NOTATIONS,NULL},
2143                   {"show-keyserver-urls",VERIFY_SHOW_KEYSERVER_URLS,NULL},
2144                   {"show-validity",VERIFY_SHOW_VALIDITY,NULL},
2145                   {"show-long-keyids",VERIFY_SHOW_LONG_KEYIDS,NULL},
2146                   {"show-unusable-uids",VERIFY_SHOW_UNUSABLE_UIDS,NULL},
2147                   {NULL,0,NULL}
2148                 };
2149
2150               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts,1))
2151                 {
2152                   if(configname)
2153                     log_error(_("%s:%d: invalid verify options\n"),
2154                               configname,configlineno);
2155                   else
2156                     log_error(_("invalid verify options\n"));
2157                 }
2158             }
2159             break;
2160           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
2161           case oExecPath:
2162             if(set_exec_path(pargs.r.ret_str,0))
2163               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
2164             else
2165               opt.exec_path_set=1;
2166             break;
2167           case oSetNotation:
2168             add_notation_data( pargs.r.ret_str, 0 );
2169             add_notation_data( pargs.r.ret_str, 1 );
2170             break;
2171           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
2172           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
2173           case oShowNotation:
2174             deprecated_warning(configname,configlineno,"--show-notation",
2175                                "--list-options ","show-notations");
2176             deprecated_warning(configname,configlineno,"--show-notation",
2177                                "--verify-options ","show-notations");
2178             opt.list_options|=LIST_SHOW_NOTATIONS;
2179             opt.verify_options|=VERIFY_SHOW_NOTATIONS;
2180             break;
2181           case oNoShowNotation:
2182             deprecated_warning(configname,configlineno,"--no-show-notation",
2183                                "--list-options ","no-show-notations");
2184             deprecated_warning(configname,configlineno,"--no-show-notation",
2185                                "--verify-options ","no-show-notations");
2186             opt.list_options&=~LIST_SHOW_NOTATIONS;
2187             opt.verify_options&=~VERIFY_SHOW_NOTATIONS;
2188             break;
2189           case oUtf8Strings: utf8_strings = 1; break;
2190           case oNoUtf8Strings: utf8_strings = 0; break;
2191           case oDisableCipherAlgo:
2192                 disable_cipher_algo( string_to_cipher_algo(pargs.r.ret_str) );
2193                 break;
2194           case oDisablePubkeyAlgo:
2195                 disable_pubkey_algo( string_to_pubkey_algo(pargs.r.ret_str) );
2196                 break;
2197           case oNoSigCache: opt.no_sig_cache = 1; break;
2198           case oNoSigCreateCheck: opt.no_sig_create_check = 1; break;
2199           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
2200           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
2201           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
2202           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
2203           case oNoLiteral: opt.no_literal = 1; break;
2204           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
2205           case oHonorHttpProxy:
2206                 add_to_strlist(&opt.keyserver_options.other,"http-proxy");
2207                 deprecated_warning(configname,configlineno,
2208                                    "--honor-http-proxy",
2209                                    "--keyserver-options ","http-proxy");
2210                 break;
2211           case oFastListMode: opt.fast_list_mode = 1; break;
2212           case oFixedListMode: opt.fixed_list_mode = 1; break;
2213           case oListOnly: opt.list_only=1; break;
2214           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
2215           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
2216           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
2217           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
2218           case oNoRandomSeedFile: use_random_seed = 0; break;
2219           case oAutoKeyRetrieve:
2220           case oNoAutoKeyRetrieve:
2221                 opt.keyserver_options.auto_key_retrieve=
2222                                              (pargs.r_opt==oAutoKeyRetrieve);
2223                 deprecated_warning(configname,configlineno,
2224                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
2225                                "--no-auto-key-retrieve","--keyserver-options ",
2226                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
2227                                "no-auto-key-retrieve");
2228                 break;
2229           case oShowSessionKey: opt.show_session_key = 1; break;
2230           case oOverrideSessionKey:
2231                 opt.override_session_key = pargs.r.ret_str;
2232                 break;
2233           case oMergeOnly:
2234                 deprecated_warning(configname,configlineno,"--merge-only",
2235                                    "--import-options ","merge-only");
2236                 opt.import_options|=IMPORT_MERGE_ONLY;
2237             break;
2238           case oAllowSecretKeyImport: /* obsolete */ break;
2239           case oTryAllSecrets: opt.try_all_secrets = 1; break;
2240           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
2241           case oEnableSpecialFilenames:
2242             iobuf_enable_special_filenames (1);
2243             break;
2244           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
2245           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
2246           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
2247           case oPreservePermissions: opt.preserve_permissions=1; break;
2248           case oDefaultPreferenceList:
2249             opt.def_preference_list = pargs.r.ret_str;
2250             break;
2251           case oPersonalCipherPreferences:
2252             pers_cipher_list=pargs.r.ret_str;
2253             break;
2254           case oPersonalDigestPreferences:
2255             pers_digest_list=pargs.r.ret_str;
2256             break;
2257           case oPersonalCompressPreferences:
2258             pers_compress_list=pargs.r.ret_str;
2259             break;
2260           case oDisplay: opt.display = pargs.r.ret_str; break;
2261           case oTTYname: opt.ttyname = pargs.r.ret_str; break;
2262           case oTTYtype: opt.ttytype = pargs.r.ret_str; break;
2263           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
2264           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
2265           case oGroup: add_group(pargs.r.ret_str); break;
2266           case oUnGroup: rm_group(pargs.r.ret_str); break;
2267           case oNoGroups:
2268             while(opt.grouplist)
2269               {
2270                 struct groupitem *iter=opt.grouplist;
2271                 free_strlist(iter->values);
2272                 opt.grouplist=opt.grouplist->next;
2273                 m_free(iter);
2274               }
2275             break;
2276           case oStrict: opt.strict=1; log_set_strict(1); break;
2277           case oNoStrict: opt.strict=0; log_set_strict(0); break;
2278           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
2279           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
2280           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
2281           case oMultifile: multifile=1; break;
2282
2283           default : pargs.err = configfp? 1:2; break;
2284           }
2285       }
2286
2287     if( configfp ) {
2288         fclose( configfp );
2289         configfp = NULL;
2290         m_free(configname); configname = NULL;
2291         goto next_pass;
2292     }
2293     m_free( configname ); configname = NULL;
2294     if( log_get_errorcount(0) )
2295         g10_exit(2);
2296     if( nogreeting )
2297         greeting = 0;
2298
2299     if( greeting ) {
2300         fprintf(stderr, "%s %s; %s\n",
2301                         strusage(11), strusage(13), strusage(14) );
2302         fprintf(stderr, "%s\n", strusage(15) );
2303     }
2304 #ifdef IS_DEVELOPMENT_VERSION
2305     if( !opt.batch )
2306       {
2307         const char *s;
2308
2309         if((s=strusage(20)))
2310           log_info("%s\n",s);
2311         if((s=strusage(21)))
2312           log_info("%s\n",s);
2313         if((s=strusage(22)))
2314           log_info("%s\n",s);
2315       }
2316 #endif
2317
2318     if (opt.verbose > 2)
2319         log_info ("using character set `%s'\n", get_native_charset ());
2320
2321     if( may_coredump && !opt.quiet )
2322         log_info(_("WARNING: program may create a core file!\n"));
2323
2324     if (eyes_only) {
2325       if (opt.set_filename)
2326           log_info(_("WARNING: %s overrides %s\n"),
2327                    "--for-your-eyes-only","--set-filename");
2328
2329       opt.set_filename="_CONSOLE";
2330     }
2331
2332     if (opt.no_literal) {
2333         log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
2334         if (opt.textmode)
2335             log_error(_("%s not allowed with %s!\n"),
2336                        "--textmode", "--no-literal" );
2337         if (opt.set_filename)
2338             log_error(_("%s makes no sense with %s!\n"),
2339                         eyes_only?"--for-your-eyes-only":"--set-filename",
2340                         "--no-literal" );
2341     }
2342
2343     if (opt.set_filesize)
2344         log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
2345     if( opt.batch )
2346         tty_batchmode( 1 );
2347
2348     secmem_set_flags( secmem_get_flags() & ~2 ); /* resume warnings */
2349
2350     set_debug();
2351
2352     /* Do these after the switch(), so they can override settings. */
2353     if(PGP2)
2354       {
2355         int unusable=0;
2356
2357         if(cmd==aSign && !detached_sig)
2358           {
2359             log_info(_("you can only make detached or clear signatures "
2360                        "while in --pgp2 mode\n"));
2361             unusable=1;
2362           }
2363         else if(cmd==aSignEncr || cmd==aSignSym)
2364           {
2365             log_info(_("you can't sign and encrypt at the "
2366                        "same time while in --pgp2 mode\n"));
2367             unusable=1;
2368           }
2369         else if(argc==0 && (cmd==aSign || cmd==aEncr || cmd==aSym))
2370           {
2371             log_info(_("you must use files (and not a pipe) when "
2372                        "working with --pgp2 enabled.\n"));
2373             unusable=1;
2374           }
2375         else if(cmd==aEncr || cmd==aSym)
2376           {
2377             /* Everything else should work without IDEA (except using
2378                a secret key encrypted with IDEA and setting an IDEA
2379                preference, but those have their own error
2380                messages). */
2381
2382             if(check_cipher_algo(CIPHER_ALGO_IDEA))
2383               {
2384                 log_info(_("encrypting a message in --pgp2 mode requires "
2385                            "the IDEA cipher\n"));
2386                 idea_cipher_warn(1);
2387                 unusable=1;
2388               }
2389             else if(cmd==aSym)
2390               {
2391                 /* This only sets IDEA for symmetric encryption
2392                    since it is set via select_algo_from_prefs for
2393                    pk encryption. */
2394                 m_free(def_cipher_string);
2395                 def_cipher_string = m_strdup("idea");
2396               }
2397
2398             /* PGP2 can't handle the output from the textmode
2399                filter, so we disable it for anything that could
2400                create a literal packet (only encryption and
2401                symmetric encryption, since we disable signing
2402                above). */
2403             if(!unusable)
2404               opt.textmode=0;
2405           }
2406
2407         if(unusable)
2408           compliance_failure();
2409         else
2410           {
2411             opt.force_v4_certs = 0;
2412             opt.sk_comments = 0;
2413             opt.escape_from = 1;
2414             opt.force_v3_sigs = 1;
2415             opt.pgp2_workarounds = 1;
2416             opt.ask_sig_expire = 0;
2417             opt.ask_cert_expire = 0;
2418             m_free(def_digest_string);
2419             def_digest_string = m_strdup("md5");
2420             opt.compress_algo = COMPRESS_ALGO_ZIP;
2421           }
2422       }
2423     else if(PGP6)
2424       {
2425         opt.sk_comments=0;
2426         opt.escape_from=1;
2427         opt.force_v3_sigs=1;
2428         opt.ask_sig_expire=0;
2429       }
2430     else if(PGP7)
2431       {
2432         opt.sk_comments=0;
2433         opt.escape_from=1;
2434         opt.force_v3_sigs=1;
2435         opt.ask_sig_expire=0;
2436       }
2437     else if(PGP8)
2438       {
2439         opt.escape_from=1;
2440       }
2441
2442     /* must do this after dropping setuid, because string_to...
2443      * may try to load an module */
2444     if( def_cipher_string ) {
2445         opt.def_cipher_algo = string_to_cipher_algo(def_cipher_string);
2446         if(opt.def_cipher_algo==0 &&
2447            (ascii_strcasecmp(def_cipher_string,"idea")==0
2448             || ascii_strcasecmp(def_cipher_string,"s1")==0))
2449           idea_cipher_warn(1);
2450         m_free(def_cipher_string); def_cipher_string = NULL;
2451         if( check_cipher_algo(opt.def_cipher_algo) )
2452             log_error(_("selected cipher algorithm is invalid\n"));
2453     }
2454     if( def_digest_string ) {
2455         opt.def_digest_algo = string_to_digest_algo(def_digest_string);
2456         m_free(def_digest_string); def_digest_string = NULL;
2457         if( check_digest_algo(opt.def_digest_algo) )
2458             log_error(_("selected digest algorithm is invalid\n"));
2459     }
2460     if( compress_algo_string ) {
2461         opt.compress_algo = string_to_compress_algo(compress_algo_string);
2462         m_free(compress_algo_string); compress_algo_string = NULL;
2463         if( check_compress_algo(opt.compress_algo) )
2464             log_error(_("selected compression algorithm is invalid\n"));
2465     }
2466     if( cert_digest_string ) {
2467         opt.cert_digest_algo = string_to_digest_algo(cert_digest_string);
2468         m_free(cert_digest_string); cert_digest_string = NULL;
2469         if( check_digest_algo(opt.cert_digest_algo) )
2470             log_error(_("selected certification digest algorithm is invalid\n"));
2471     }
2472     if( s2k_cipher_string ) {
2473         opt.s2k_cipher_algo = string_to_cipher_algo(s2k_cipher_string);
2474         m_free(s2k_cipher_string); s2k_cipher_string = NULL;
2475         if( check_cipher_algo(opt.s2k_cipher_algo) )
2476             log_error(_("selected cipher algorithm is invalid\n"));
2477     }
2478     if( s2k_digest_string ) {
2479         opt.s2k_digest_algo = string_to_digest_algo(s2k_digest_string);
2480         m_free(s2k_digest_string); s2k_digest_string = NULL;
2481         if( check_digest_algo(opt.s2k_digest_algo) )
2482             log_error(_("selected digest algorithm is invalid\n"));
2483     }
2484     if( opt.completes_needed < 1 )
2485       log_error(_("completes-needed must be greater than 0\n"));
2486     if( opt.marginals_needed < 2 )
2487       log_error(_("marginals-needed must be greater than 1\n"));
2488     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
2489       log_error(_("max-cert-depth must be in the range from 1 to 255\n"));
2490     if(opt.def_cert_level<0 || opt.def_cert_level>3)
2491       log_error(_("invalid default-cert-level; must be 0, 1, 2, or 3\n"));
2492     if( opt.min_cert_level < 1 || opt.min_cert_level > 3 )
2493       log_error(_("invalid min-cert-level; must be 1, 2, or 3\n"));
2494     switch( opt.s2k_mode ) {
2495       case 0:
2496         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
2497         break;
2498       case 1: case 3: break;
2499       default:
2500         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
2501     }
2502
2503     /* This isn't actually needed, but does serve to error out if the
2504        string is invalid. */
2505     if(opt.def_preference_list &&
2506         keygen_set_std_prefs(opt.def_preference_list,0))
2507       log_error(_("invalid default preferences\n"));
2508
2509     /* We provide defaults for the personal digest list.  This is
2510        SHA-1. */
2511     if(!pers_digest_list)
2512       pers_digest_list="h2";
2513
2514     if(pers_cipher_list &&
2515        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
2516       log_error(_("invalid personal cipher preferences\n"));
2517
2518     if(pers_digest_list &&
2519        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
2520       log_error(_("invalid personal digest preferences\n"));
2521
2522     if(pers_compress_list &&
2523        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
2524       log_error(_("invalid personal compress preferences\n"));
2525
2526     /* We don't support all possible commands with multifile yet */
2527     if(multifile)
2528       {
2529         char *cmdname;
2530
2531         switch(cmd)
2532           {
2533           case aSign:
2534             cmdname="--sign";
2535             break;
2536           case aClearsign:
2537             cmdname="--clearsign";
2538             break;
2539           case aDetachedSign:
2540             cmdname="--detach-sign";
2541             break;
2542           case aSym:
2543             cmdname="--symmetric";
2544             break;
2545           case aEncrSym:
2546             cmdname="--symmetric --encrypt";
2547             break;
2548           case aStore:
2549             cmdname="--store";
2550             break;
2551           default:
2552             cmdname=NULL;
2553             break;
2554           }
2555
2556         if(cmdname)
2557           log_error(_("%s does not yet work with %s\n"),cmdname,"--multifile");
2558       }
2559
2560     if( log_get_errorcount(0) )
2561         g10_exit(2);
2562
2563     if(opt.compress_level==0)
2564       opt.compress_algo=COMPRESS_ALGO_NONE;
2565
2566     /* Check our chosen algorithms against the list of legal
2567        algorithms. */
2568
2569     if(!GNUPG)
2570       {
2571         const char *badalg=NULL;
2572         preftype_t badtype=PREFTYPE_NONE;
2573
2574         if(opt.def_cipher_algo
2575            && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
2576           {
2577             badalg=cipher_algo_to_string(opt.def_cipher_algo);
2578             badtype=PREFTYPE_SYM;
2579           }
2580         else if(opt.def_digest_algo
2581                 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
2582           {
2583             badalg=digest_algo_to_string(opt.def_digest_algo);
2584             badtype=PREFTYPE_HASH;
2585           }
2586         else if(opt.cert_digest_algo
2587                 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
2588           {
2589             badalg=digest_algo_to_string(opt.cert_digest_algo);
2590             badtype=PREFTYPE_HASH;
2591           }
2592         else if(opt.compress_algo!=-1
2593                 && !algo_available(PREFTYPE_ZIP,opt.compress_algo,NULL))
2594           {
2595             badalg=compress_algo_to_string(opt.compress_algo);
2596             badtype=PREFTYPE_ZIP;
2597           }
2598
2599         if(badalg)
2600           {
2601             switch(badtype)
2602               {
2603               case PREFTYPE_SYM:
2604                 log_info(_("you may not use cipher algorithm \"%s\" "
2605                            "while in %s mode\n"),
2606                          badalg,compliance_option_string());
2607                 break;
2608               case PREFTYPE_HASH:
2609                 log_info(_("you may not use digest algorithm \"%s\" "
2610                            "while in %s mode\n"),
2611                          badalg,compliance_option_string());
2612                 break;
2613               case PREFTYPE_ZIP:
2614                 log_info(_("you may not use compression algorithm \"%s\" "
2615                            "while in %s mode\n"),
2616                          badalg,compliance_option_string());
2617                 break;
2618               default:
2619                 BUG();
2620               }
2621
2622             compliance_failure();
2623           }
2624       }
2625
2626     /* set the random seed file */
2627     if( use_random_seed ) {
2628         char *p = make_filename(opt.homedir, "random_seed", NULL );
2629         set_random_seed_file(p);
2630         m_free(p);
2631     }
2632
2633     if( !cmd && opt.fingerprint && !with_fpr ) {
2634         set_cmd( &cmd, aListKeys);
2635     }
2636
2637     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
2638         if( cmd == aKModeC ) {
2639             opt.fingerprint = 1;
2640             cmd = aKMode;
2641         }
2642         opt.list_sigs = 0;
2643         if( opt.verbose > 2 )
2644             opt.check_sigs++;
2645         if( opt.verbose > 1 )
2646             opt.list_sigs++;
2647
2648         opt.verbose = opt.verbose > 1;
2649         g10_opt_verbose = opt.verbose;
2650     }
2651
2652     /* kludge to let -sat generate a clear text signature */
2653     if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
2654         cmd = aClearsign;
2655
2656     if( opt.verbose > 1 )
2657         set_packet_list_mode(1);
2658
2659     /* Add the keyrings, but not for some special commands and not in
2660        case of "-kvv userid keyring".  Also avoid adding the secret
2661        keyring for a couple of commands to avoid unneeded access in
2662        case the secrings are stored on a floppy */
2663     if( cmd != aDeArmor && cmd != aEnArmor
2664         && !(cmd == aKMode && argc == 2 ) ) 
2665       {
2666         if (cmd != aCheckKeys && cmd != aListSigs && cmd != aListKeys
2667             && cmd != aVerify && cmd != aSym)
2668           {
2669             if (!sec_nrings || default_keyring) /* add default secret rings */
2670               keydb_add_resource ("secring" EXTSEP_S "gpg", 0, 1);
2671             for (sl = sec_nrings; sl; sl = sl->next)
2672               keydb_add_resource ( sl->d, 0, 1 );
2673           }
2674         if( !nrings || default_keyring )  /* add default ring */
2675             keydb_add_resource ("pubring" EXTSEP_S "gpg", 0, 0);
2676         for(sl = nrings; sl; sl = sl->next )
2677             keydb_add_resource ( sl->d, sl->flags, 0 );
2678       }
2679     FREE_STRLIST(nrings);
2680     FREE_STRLIST(sec_nrings);
2681
2682
2683     if( pwfd != -1 )  /* read the passphrase now. */
2684         read_passphrase_from_fd( pwfd );
2685
2686     fname = argc? *argv : NULL;
2687
2688     switch( cmd ) {
2689       case aPrimegen:
2690       case aPrintMD:
2691       case aPrintMDs:
2692       case aGenRandom:
2693       case aDeArmor:
2694       case aEnArmor:
2695       case aFixTrustDB:
2696         break;
2697       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
2698       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
2699       default: rc = setup_trustdb(1, trustdb_name ); break;
2700     }
2701     if( rc )
2702         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
2703
2704
2705     switch (cmd)
2706       {
2707       case aStore: 
2708       case aSym:  
2709       case aSign: 
2710       case aSignSym: 
2711       case aClearsign: 
2712         if (!opt.quiet && any_explicit_recipient)
2713           log_info (_("WARNING: recipients (-r) given "
2714                       "without using public key encryption\n"));
2715         break;
2716       default:
2717         break;
2718       }
2719
2720     switch( cmd )
2721       {
2722       case aStore: /* only store the file */
2723         if( argc > 1 )
2724             wrong_args(_("--store [filename]"));
2725         if( (rc = encode_store(fname)) )
2726             log_error_f( print_fname_stdin(fname),
2727                         "store failed: %s\n", g10_errstr(rc) );
2728         break;
2729       case aSym: /* encrypt the given file only with the symmetric cipher */
2730         if( argc > 1 )
2731             wrong_args(_("--symmetric [filename]"));
2732         if( (rc = encode_symmetric(fname)) )
2733             log_error_f(print_fname_stdin(fname),
2734                         "symmetric encryption failed: %s\n",g10_errstr(rc) );
2735         break;
2736
2737       case aEncr: /* encrypt the given file */
2738         if(multifile)
2739           encode_crypt_files(argc, argv, remusr);
2740         else
2741           {
2742             if( argc > 1 )
2743               wrong_args(_("--encrypt [filename]"));
2744             if( (rc = encode_crypt(fname,remusr,0)) )
2745               log_error("%s: encryption failed: %s\n",
2746                         print_fname_stdin(fname), g10_errstr(rc) );
2747           }
2748         break;
2749
2750       case aEncrSym:
2751         /* This works with PGP 8 in the sense that it acts just like a
2752            symmetric message.  It doesn't work at all with 2 or 6.  It
2753            might work with 7, but alas, I don't have a copy to test
2754            with right now. */
2755         if( argc > 1 )
2756           wrong_args(_("--symmetric --encrypt [filename]"));
2757         else if(opt.s2k_mode==0)
2758           log_error(_("you cannot use --symmetric --encrypt"
2759                       " with --s2k-mode 0\n"));
2760         else if(PGP2 || PGP6 || PGP7 || RFC1991)
2761           log_error(_("you cannot use --symmetric --encrypt"
2762                       " while in %s mode\n"),compliance_option_string());
2763         else
2764           {
2765             if( (rc = encode_crypt(fname,remusr,1)) )
2766               log_error("%s: encryption failed: %s\n",
2767                         print_fname_stdin(fname), g10_errstr(rc) );
2768           }
2769         break;
2770
2771       case aSign: /* sign the given file */
2772         sl = NULL;
2773         if( detached_sig ) { /* sign all files */
2774             for( ; argc; argc--, argv++ )
2775                 add_to_strlist( &sl, *argv );
2776         }
2777         else {
2778             if( argc > 1 )
2779                 wrong_args(_("--sign [filename]"));
2780             if( argc ) {
2781                 sl = m_alloc_clear( sizeof *sl + strlen(fname));
2782                 strcpy(sl->d, fname);
2783             }
2784         }
2785         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
2786             log_error("signing failed: %s\n", g10_errstr(rc) );
2787         free_strlist(sl);
2788         break;
2789
2790       case aSignEncr: /* sign and encrypt the given file */
2791         if( argc > 1 )
2792             wrong_args(_("--sign --encrypt [filename]"));
2793         if( argc ) {
2794             sl = m_alloc_clear( sizeof *sl + strlen(fname));
2795             strcpy(sl->d, fname);
2796         }
2797         else
2798             sl = NULL;
2799         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
2800             log_error("%s: sign+encrypt failed: %s\n",
2801                       print_fname_stdin(fname), g10_errstr(rc) );
2802         free_strlist(sl);
2803         break;
2804
2805       case aSignEncrSym: /* sign and encrypt the given file */
2806         if( argc > 1 )
2807             wrong_args(_("--symmetric --sign --encrypt [filename]"));
2808         else if(opt.s2k_mode==0)
2809           log_error(_("you cannot use --symmetric --sign --encrypt"
2810                       " with --s2k-mode 0\n"));
2811         else if(PGP2 || PGP6 || PGP7 || RFC1991)
2812           log_error(_("you cannot use --symmetric --sign --encrypt"
2813                       " while in %s mode\n"),compliance_option_string());
2814         else
2815           {
2816             if( argc )
2817               {
2818                 sl = m_alloc_clear( sizeof *sl + strlen(fname));
2819                 strcpy(sl->d, fname);
2820               }
2821             else
2822               sl = NULL;
2823             if( (rc = sign_file(sl, detached_sig, locusr, 2, remusr, NULL)) )
2824               log_error("%s: symmetric+sign+encrypt failed: %s\n",
2825                         print_fname_stdin(fname), g10_errstr(rc) );
2826             free_strlist(sl);
2827           }
2828         break;
2829
2830       case aSignSym: /* sign and conventionally encrypt the given file */
2831         if (argc > 1)
2832             wrong_args(_("--sign --symmetric [filename]"));
2833         rc = sign_symencrypt_file (fname, locusr);
2834         if (rc)
2835             log_error("%s: sign+symmetric failed: %s\n",
2836                       print_fname_stdin(fname), g10_errstr(rc) );
2837         break;
2838
2839       case aClearsign: /* make a clearsig */
2840         if( argc > 1 )
2841             wrong_args(_("--clearsign [filename]"));
2842         if( (rc = clearsign_file(fname, locusr, NULL)) )
2843             log_error("%s: clearsign failed: %s\n",
2844                       print_fname_stdin(fname), g10_errstr(rc) );
2845         break;
2846
2847       case aVerify:
2848         if(multifile)
2849           {
2850             if( (rc = verify_files( argc, argv ) ))
2851               log_error("verify files failed: %s\n", g10_errstr(rc) );
2852           }
2853         else
2854           {
2855             if( (rc = verify_signatures( argc, argv ) ))
2856               log_error("verify signatures failed: %s\n", g10_errstr(rc) );
2857           }
2858         break;
2859
2860       case aDecrypt:
2861         if(multifile)
2862           decrypt_messages(argc, argv);
2863         else
2864           {
2865             if( argc > 1 )
2866               wrong_args(_("--decrypt [filename]"));
2867             if( (rc = decrypt_message( fname ) ))
2868               log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
2869           }
2870         break;
2871             
2872       case aSignKey:
2873         if( argc != 1 )
2874           wrong_args(_("--sign-key user-id"));
2875         /* fall through */
2876       case aLSignKey:
2877         if( argc != 1 )
2878           wrong_args(_("--lsign-key user-id"));
2879         /* fall through */
2880       case aNRSignKey:
2881         if( argc != 1 )
2882           wrong_args(_("--nrsign-key user-id"));
2883         /* fall through */
2884       case aNRLSignKey:
2885         if( argc != 1 )
2886           wrong_args(_("--nrlsign-key user-id"));
2887
2888         sl=NULL;
2889
2890         if(cmd==aSignKey)
2891           append_to_strlist(&sl,"sign");
2892         else if(cmd==aLSignKey)
2893           append_to_strlist(&sl,"lsign");
2894         else if(cmd==aNRSignKey)
2895           append_to_strlist(&sl,"nrsign");
2896         else if(cmd==aNRLSignKey)
2897           append_to_strlist(&sl,"nrlsign");
2898         else
2899           BUG();
2900
2901         append_to_strlist( &sl, "save" );
2902         username = make_username( fname );
2903         keyedit_menu(fname, locusr, sl, 0, 0 );
2904         m_free(username);
2905         free_strlist(sl);
2906         break;
2907
2908       case aEditKey: /* Edit a key signature */
2909         if( !argc )
2910             wrong_args(_("--edit-key user-id [commands]"));
2911         username = make_username( fname );
2912         if( argc > 1 ) {
2913             sl = NULL;
2914             for( argc--, argv++ ; argc; argc--, argv++ )
2915                 append_to_strlist( &sl, *argv );
2916             keyedit_menu( username, locusr, sl, 0, 1 );
2917             free_strlist(sl);
2918         }
2919         else
2920             keyedit_menu(username, locusr, NULL, 0, 1 );
2921         m_free(username);
2922         break;
2923
2924       case aDeleteKeys:
2925       case aDeleteSecretKeys:
2926       case aDeleteSecretAndPublicKeys:
2927         sl = NULL;
2928         /* I'm adding these in reverse order as add_to_strlist2
2929            reverses them again, and it's easier to understand in the
2930            proper order :) */
2931         for( ; argc; argc-- )
2932           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
2933         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
2934         free_strlist(sl);
2935         break;
2936
2937       case aCheckKeys:
2938         opt.check_sigs = 1;
2939       case aListSigs:
2940         opt.list_sigs = 1;
2941       case aListKeys:
2942         sl = NULL;
2943         for( ; argc; argc--, argv++ )
2944             add_to_strlist2( &sl, *argv, utf8_strings );
2945         public_key_list( sl );
2946         free_strlist(sl);
2947         break;
2948       case aListSecretKeys:
2949         sl = NULL;
2950         for( ; argc; argc--, argv++ )
2951             add_to_strlist2( &sl, *argv, utf8_strings );
2952         secret_key_list( sl );
2953         free_strlist(sl);
2954         break;
2955
2956       case aKMode: /* list keyring -- NOTE: This will be removed soon */
2957         if( argc < 2 ) { /* -kv [userid] */
2958             sl = NULL;
2959             if (argc && **argv)
2960                 add_to_strlist2( &sl, *argv, utf8_strings );
2961             public_key_list( sl );
2962             free_strlist(sl);
2963         }
2964         else if( argc == 2 ) { /* -kv userid keyring */
2965             if( access( argv[1], R_OK ) ) {
2966                 log_error(_("can't open %s: %s\n"),
2967                                print_fname_stdin(argv[1]), strerror(errno));
2968             }
2969             else {
2970                 /* add keyring (default keyrings are not registered in this
2971                  * special case */
2972                 keydb_add_resource( argv[1], 0, 0 );
2973                 sl = NULL;
2974                 if (**argv)
2975                     add_to_strlist2( &sl, *argv, utf8_strings );
2976                 public_key_list( sl );
2977                 free_strlist(sl);
2978             }
2979         }
2980         else
2981             wrong_args(_("-k[v][v][v][c] [user-id] [keyring]") );
2982         break;
2983
2984       case aKeygen: /* generate a key */
2985         if( opt.batch ) {
2986             if( argc > 1 )
2987                 wrong_args("--gen-key [parameterfile]");
2988             generate_keypair( argc? *argv : NULL, NULL );
2989         }
2990         else {
2991             if( argc )
2992                 wrong_args("--gen-key");
2993             generate_keypair(NULL, NULL);
2994         }
2995         break;
2996
2997       case aFastImport:
2998         opt.import_options |= IMPORT_FAST_IMPORT;
2999       case aImport:
3000         import_keys( argc? argv:NULL, argc, NULL, opt.import_options );
3001         break;
3002
3003       case aExport:
3004       case aSendKeys:
3005       case aRecvKeys:
3006         sl = NULL;
3007         for( ; argc; argc--, argv++ )
3008             add_to_strlist2( &sl, *argv, utf8_strings );
3009         if( cmd == aSendKeys )
3010             rc=keyserver_export( sl );
3011         else if( cmd == aRecvKeys )
3012             rc=keyserver_import( sl );
3013         else
3014             rc=export_pubkeys( sl, opt.export_options );
3015         if(rc)
3016           {
3017             if(cmd==aSendKeys)
3018               log_error(_("keyserver send failed: %s\n"),g10_errstr(rc));
3019             else if(cmd==aRecvKeys)
3020               log_error(_("keyserver receive failed: %s\n"),g10_errstr(rc));
3021             else
3022               log_error(_("key export failed: %s\n"),g10_errstr(rc));
3023           }
3024         free_strlist(sl);
3025         break;
3026
3027      case aSearchKeys:
3028         sl = NULL;
3029         for( ; argc; argc--, argv++ )
3030           append_to_strlist2( &sl, *argv, utf8_strings );
3031         rc=keyserver_search( sl );
3032         if(rc)
3033           log_error(_("keyserver search failed: %s\n"),g10_errstr(rc));
3034         free_strlist(sl);
3035         break;
3036
3037       case aRefreshKeys:
3038         sl = NULL;
3039         for( ; argc; argc--, argv++ )
3040             add_to_strlist2( &sl, *argv, utf8_strings );
3041         rc=keyserver_refresh(sl);
3042         if(rc)
3043           log_error(_("keyserver refresh failed: %s\n"),g10_errstr(rc));
3044         free_strlist(sl);
3045         break;
3046
3047       case aExportSecret:
3048         sl = NULL;
3049         for( ; argc; argc--, argv++ )
3050             add_to_strlist2( &sl, *argv, utf8_strings );
3051         export_seckeys( sl );
3052         free_strlist(sl);
3053         break;
3054
3055       case aExportSecretSub:
3056         sl = NULL;
3057         for( ; argc; argc--, argv++ )
3058             add_to_strlist2( &sl, *argv, utf8_strings );
3059         export_secsubkeys( sl );
3060         free_strlist(sl);
3061         break;
3062
3063       case aGenRevoke:
3064         if( argc != 1 )
3065             wrong_args("--gen-revoke user-id");
3066         username =  make_username(*argv);
3067         gen_revoke( username );
3068         m_free( username );
3069         break;
3070
3071       case aDesigRevoke:
3072         if( argc != 1 )
3073             wrong_args("--desig-revoke user-id");
3074         username =  make_username(*argv);
3075         gen_desig_revoke( username );
3076         m_free( username );
3077         break;
3078
3079       case aDeArmor:
3080         if( argc > 1 )
3081             wrong_args("--dearmor [file]");
3082         rc = dearmor_file( argc? *argv: NULL );
3083         if( rc )
3084             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
3085         break;
3086
3087       case aEnArmor:
3088         if( argc > 1 )
3089             wrong_args("--enarmor [file]");
3090         rc = enarmor_file( argc? *argv: NULL );
3091         if( rc )
3092             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
3093         break;
3094
3095
3096       case aPrimegen:
3097         {   int mode = argc < 2 ? 0 : atoi(*argv);
3098
3099             if( mode == 1 && argc == 2 ) {
3100                 mpi_print( stdout, generate_public_prime( atoi(argv[1]) ), 1);
3101             }
3102             else if( mode == 2 && argc == 3 ) {
3103                 mpi_print( stdout, generate_elg_prime(
3104                                              0, atoi(argv[1]),
3105                                              atoi(argv[2]), NULL,NULL ), 1);
3106             }
3107             else if( mode == 3 && argc == 3 ) {
3108                 MPI *factors;
3109                 mpi_print( stdout, generate_elg_prime(
3110                                              1, atoi(argv[1]),
3111                                              atoi(argv[2]), NULL,&factors ), 1);
3112                 putchar('\n');
3113                 mpi_print( stdout, factors[0], 1 ); /* print q */
3114             }
3115             else if( mode == 4 && argc == 3 ) {
3116                 MPI g = mpi_alloc(1);
3117                 mpi_print( stdout, generate_elg_prime(
3118                                                  0, atoi(argv[1]),
3119                                                  atoi(argv[2]), g, NULL ), 1);
3120                 putchar('\n');
3121                 mpi_print( stdout, g, 1 );
3122                 mpi_free(g);
3123             }
3124             else
3125                 wrong_args("--gen-prime mode bits [qbits] ");
3126             putchar('\n');
3127         }
3128         break;
3129
3130       case aGenRandom:
3131         {
3132             int level = argc ? atoi(*argv):0;
3133             int count = argc > 1 ? atoi(argv[1]): 0;
3134             int endless = !count;
3135
3136             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
3137                 wrong_args("--gen-random 0|1|2 [count]");
3138
3139             while( endless || count ) {
3140                 byte *p;
3141                 /* Wee need a multiple of 3, so that in case of
3142                    armored output we get a correct string.  No
3143                    linefolding is done, as it is best to levae this to
3144                    other tools */
3145                 size_t n = !endless && count < 99? count : 99;
3146
3147                 p = get_random_bits( n*8, level, 0);
3148 #ifdef HAVE_DOSISH_SYSTEM
3149                 setmode ( fileno(stdout), O_BINARY );
3150 #endif
3151                 if (opt.armor) {
3152                     char *tmp = make_radix64_string (p, n);
3153                     fputs (tmp, stdout);
3154                     m_free (tmp);
3155                     if (n%3 == 1)
3156                       putchar ('=');
3157                     if (n%3)
3158                       putchar ('=');
3159                 } else {
3160                     fwrite( p, n, 1, stdout );
3161                 }
3162                 m_free(p);
3163                 if( !endless )
3164                     count -= n;
3165             }
3166             if (opt.armor)
3167                 putchar ('\n');
3168         }
3169         break;
3170
3171       case aPrintMD:
3172         if( argc < 1)
3173             wrong_args("--print-md algo [files]");
3174         {
3175             int all_algos = (**argv=='*' && !(*argv)[1]);
3176             int algo = all_algos? 0 : string_to_digest_algo(*argv);
3177
3178             if( !algo && !all_algos )
3179                 log_error(_("invalid hash algorithm `%s'\n"), *argv );
3180             else {
3181                 argc--; argv++;
3182                 if( !argc )
3183                     print_mds(NULL, algo);
3184                 else {
3185                     for(; argc; argc--, argv++ )
3186                         print_mds(*argv, algo);
3187                 }
3188             }
3189         }
3190         break;
3191
3192       case aPrintMDs: /* old option */
3193         if( !argc )
3194             print_mds(NULL,0);
3195         else {
3196             for(; argc; argc--, argv++ )
3197                 print_mds(*argv,0);
3198         }
3199         break;
3200
3201       case aListTrustDB:
3202         if( !argc )
3203             list_trustdb(NULL);
3204         else {
3205             for( ; argc; argc--, argv++ )
3206                 list_trustdb( *argv );
3207         }
3208         break;
3209
3210       case aUpdateTrustDB:
3211         if( argc )
3212             wrong_args("--update-trustdb");
3213         update_trustdb();
3214         break;
3215
3216       case aCheckTrustDB:
3217         /* Old versions allowed for arguments - ignore them */
3218         check_trustdb();
3219         break;
3220
3221       case aFixTrustDB:
3222         log_error("this command is not yet implemented.\n");
3223         log_error("A workaround is to use \"--export-ownertrust\", remove\n");
3224         log_error("the trustdb file and do an \"--import-ownertrust\".\n" );
3225         break;
3226
3227       case aListTrustPath:
3228         if( !argc )
3229             wrong_args("--list-trust-path <user-ids>");
3230         for( ; argc; argc--, argv++ ) {
3231             username = make_username( *argv );
3232             list_trust_path( username );
3233             m_free(username);
3234         }
3235         break;
3236
3237       case aExportOwnerTrust:
3238         if( argc )
3239             wrong_args("--export-ownertrust");
3240         export_ownertrust();
3241         break;
3242
3243       case aImportOwnerTrust:
3244         if( argc > 1 )
3245             wrong_args("--import-ownertrust [file]");
3246         import_ownertrust( argc? *argv:NULL );
3247         break;
3248       
3249       case aPipeMode:
3250         if ( argc )
3251             wrong_args ("--pipemode");
3252         run_in_pipemode ();
3253         break;
3254
3255       case aRebuildKeydbCaches:
3256         if (argc)
3257             wrong_args ("--rebuild-keydb-caches");
3258         keydb_rebuild_caches (1);
3259         break;
3260
3261 #ifdef ENABLE_CARD_SUPPORT
3262       case aCardStatus:
3263         if (argc)
3264             wrong_args ("--card-status");
3265         card_status (stdout, NULL, 0);
3266         break;
3267
3268       case aCardEdit:
3269         if (argc) {
3270             sl = NULL;
3271             for (argc--, argv++ ; argc; argc--, argv++)
3272                 append_to_strlist (&sl, *argv);
3273             card_edit (sl);
3274             free_strlist (sl);
3275         }
3276         else
3277             card_edit (NULL);
3278         break;
3279
3280       case aChangePIN:
3281         if (!argc)
3282             change_pin (0);
3283         else if (argc == 1)
3284             change_pin ( atoi (*argv));
3285         else
3286         wrong_args ("--change-pin [no]");
3287         break;
3288 #endif /* ENABLE_CARD_SUPPORT*/
3289
3290       case aListConfig:
3291         {
3292           char *str=collapse_args(argc,argv);
3293           list_config(str);
3294           m_free(str);
3295         }
3296         break;
3297
3298       case aListPackets:
3299         opt.list_packets=2;
3300       default:
3301         if( argc > 1 )
3302             wrong_args(_("[filename]"));
3303         /* Issue some output for the unix newbie */
3304         if( !fname && !opt.outfile && isatty( fileno(stdin) )
3305                 && isatty( fileno(stdout) ) && isatty( fileno(stderr) ) )
3306             log_info(_("Go ahead and type your message ...\n"));
3307
3308         if( !(a = iobuf_open(fname)) )
3309             log_error(_("can't open `%s'\n"), print_fname_stdin(fname));
3310         else {
3311
3312             if( !opt.no_armor ) {
3313                 if( use_armor_filter( a ) ) {
3314                     memset( &afx, 0, sizeof afx);
3315                     iobuf_push_filter( a, armor_filter, &afx );
3316                 }
3317             }
3318             if( cmd == aListPackets ) {
3319                 set_packet_list_mode(1);
3320                 opt.list_packets=1;
3321             }
3322             rc = proc_packets(NULL, a );
3323             if( rc )
3324                 log_error("processing message failed: %s\n", g10_errstr(rc) );
3325             iobuf_close(a);
3326         }
3327         break;
3328       }
3329
3330     /* cleanup */
3331     FREE_STRLIST(remusr);
3332     FREE_STRLIST(locusr);
3333     g10_exit(0);
3334     return 8; /*NEVER REACHED*/
3335 }
3336
3337
3338 void
3339 g10_exit( int rc )
3340 {
3341 #ifdef ENABLE_CARD_SUPPORT
3342     card_close ();
3343 #endif
3344     update_random_seed_file();
3345     if( opt.debug & DBG_MEMSTAT_VALUE ) {
3346         m_print_stats("on exit");
3347         random_dump_stats();
3348     }
3349     if( opt.debug )
3350         secmem_dump_stats();
3351     secmem_term();
3352     rc = rc? rc : log_get_errorcount(0)? 2 :
3353                         g10_errors_seen? 1 : 0;
3354     exit(rc );
3355 }
3356
3357
3358 /* Pretty-print hex hashes.  This assumes at least an 80-character
3359    display, but there are a few other similar assumptions in the
3360    display code. */
3361 static void
3362 print_hex( MD_HANDLE md, int algo, const char *fname )
3363 {
3364   int i,n,count,indent=0;
3365   const byte *p;
3366
3367   if(fname)
3368     indent=printf("%s: ",fname);
3369
3370   if(indent>40)
3371     {
3372       printf("\n");
3373       indent=0;
3374     }
3375
3376   if(algo==DIGEST_ALGO_RMD160)
3377     indent+=printf("RMD160 = ");
3378   else if(algo>0)
3379     indent+=printf("%6s = ",digest_algo_to_string(algo));
3380   else
3381     algo=abs(algo);
3382
3383   count=indent;
3384
3385   p = md_read( md, algo );
3386   n = md_digest_length(algo);
3387
3388   count+=printf("%02X",*p++);
3389
3390   for(i=1;i<n;i++,p++)
3391     {
3392       if(n==16)
3393         {
3394           if(count+2>79)
3395             {
3396               printf("\n%*s",indent," ");
3397               count=indent;
3398             }
3399           else
3400             count+=printf(" ");
3401
3402           if(!(i%8))
3403             count+=printf(" ");
3404         }
3405       else if (n==20)
3406         {
3407           if(!(i%2))
3408             {
3409               if(count+4>79)
3410                 {
3411                   printf("\n%*s",indent," ");
3412                   count=indent;
3413                 }
3414               else
3415                 count+=printf(" ");
3416             }
3417
3418           if(!(i%10))
3419             count+=printf(" ");
3420         }
3421       else
3422         {
3423           if(!(i%4))
3424             {
3425               if(count+8>79)
3426                 {
3427                   printf("\n%*s",indent," ");
3428                   count=indent;
3429                 }
3430               else
3431                 count+=printf(" ");
3432             }
3433         }
3434
3435       count+=printf("%02X",*p);
3436     }
3437
3438   printf("\n");
3439 }
3440
3441 static void
3442 print_hashline( MD_HANDLE md, int algo, const char *fname )
3443 {
3444     int i, n;
3445     const byte *p;
3446     
3447     if ( fname ) {
3448         for (p = fname; *p; p++ ) {
3449             if ( *p <= 32 || *p > 127 || *p == ':' || *p == '%' )
3450                 printf("%%%02X", *p );
3451             else 
3452                 putchar( *p );
3453         }
3454     }
3455     putchar(':');
3456     printf("%d:", algo );
3457     p = md_read( md, algo );
3458     n = md_digest_length(algo);
3459     for(i=0; i < n ; i++, p++ ) 
3460         printf("%02X", *p );
3461     putchar(':');
3462     putchar('\n');
3463 }
3464
3465 static void
3466 print_mds( const char *fname, int algo )
3467 {
3468     FILE *fp;
3469     char buf[1024];
3470     size_t n;
3471     MD_HANDLE md;
3472
3473     if( !fname ) {
3474         fp = stdin;
3475 #ifdef HAVE_DOSISH_SYSTEM
3476         setmode ( fileno(fp) , O_BINARY );
3477 #endif
3478     }
3479     else {
3480         fp = fopen( fname, "rb" );
3481     }
3482     if( !fp ) {
3483         log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
3484         return;
3485     }
3486
3487     md = md_open( 0, 0 );
3488     if( algo )
3489         md_enable( md, algo );
3490     else {
3491         md_enable( md, DIGEST_ALGO_MD5 );
3492         md_enable( md, DIGEST_ALGO_SHA1 );
3493         md_enable( md, DIGEST_ALGO_RMD160 );
3494 #ifdef USE_SHA256
3495         md_enable( md, DIGEST_ALGO_SHA256 );
3496 #endif
3497 #ifdef USE_SHA512
3498         md_enable( md, DIGEST_ALGO_SHA384 );
3499         md_enable( md, DIGEST_ALGO_SHA512 );
3500 #endif
3501     }
3502
3503     while( (n=fread( buf, 1, DIM(buf), fp )) )
3504         md_write( md, buf, n );
3505     if( ferror(fp) )
3506         log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
3507     else {
3508         md_final(md);
3509         if ( opt.with_colons ) {
3510             if ( algo ) 
3511                 print_hashline( md, algo, fname );
3512             else {
3513                 print_hashline( md, DIGEST_ALGO_MD5, fname );
3514                 print_hashline( md, DIGEST_ALGO_SHA1, fname );
3515                 print_hashline( md, DIGEST_ALGO_RMD160, fname );
3516 #ifdef USE_SHA256
3517                 print_hashline( md, DIGEST_ALGO_SHA256, fname );
3518 #endif
3519 #ifdef USE_SHA512
3520                 print_hashline( md, DIGEST_ALGO_SHA384, fname );
3521                 print_hashline( md, DIGEST_ALGO_SHA512, fname );
3522 #endif
3523             }
3524         }
3525         else {
3526             if( algo )
3527                print_hex(md,-algo,fname);
3528             else {
3529                 print_hex( md, DIGEST_ALGO_MD5, fname );
3530                 print_hex( md, DIGEST_ALGO_SHA1, fname );
3531                 print_hex( md, DIGEST_ALGO_RMD160, fname );
3532 #ifdef USE_SHA256
3533                 print_hex( md, DIGEST_ALGO_SHA256, fname );
3534 #endif
3535 #ifdef USE_SHA512
3536                 print_hex( md, DIGEST_ALGO_SHA384, fname );
3537                 print_hex( md, DIGEST_ALGO_SHA512, fname );
3538 #endif
3539             }
3540         }
3541     }
3542     md_close(md);
3543
3544     if( fp != stdin )
3545         fclose(fp);
3546 }
3547
3548
3549 /****************
3550  * Check the supplied name,value string and add it to the notation
3551  * data to be used for signatures.  which==0 for sig notations, and 1
3552  * for cert notations.
3553 */
3554 static void
3555 add_notation_data( const char *string, int which )
3556 {
3557     const char *s;
3558     STRLIST sl,*notation_data;
3559     int critical=0;
3560     int highbit=0;
3561     int saw_at=0;
3562
3563     if(which)
3564       notation_data=&opt.cert_notation_data;
3565     else
3566       notation_data=&opt.sig_notation_data;
3567
3568     if( *string == '!' ) {
3569         critical = 1;
3570         string++;
3571     }
3572
3573     /* If and when the IETF assigns some official name tags, we'll
3574        have to add them here. */
3575
3576     for( s=string ; *s != '='; s++ )
3577       {
3578         if( *s=='@')
3579           saw_at=1;
3580
3581         if( !*s || (*s & 0x80) || (!isgraph(*s) && !isspace(*s)) )
3582           {
3583             log_error(_("a notation name must have only printable characters "
3584                         "or spaces, and end with an '='\n") );
3585             return;
3586           }
3587       }
3588
3589     if(!saw_at && !opt.expert)
3590       {
3591         log_error(
3592                 _("a user notation name must contain the '@' character\n"));
3593         return;
3594       }
3595
3596     /* we only support printable text - therefore we enforce the use
3597      * of only printable characters (an empty value is valid) */
3598     for( s++; *s ; s++ ) {
3599         if ((*s & 0x80))
3600           highbit = 1;
3601         else if (iscntrl(*s)) {
3602             log_error(_("a notation value must not use "
3603                         "any control characters\n") );
3604             return;
3605         }
3606     }
3607
3608     if( highbit )   /* must use UTF8 encoding */
3609         sl = add_to_strlist2( notation_data, string, utf8_strings );
3610     else
3611         sl = add_to_strlist( notation_data, string );
3612
3613     if( critical )
3614         sl->flags |= 1;
3615 }
3616
3617 static void
3618 add_policy_url( const char *string, int which )
3619 {
3620   int i,critical=0;
3621   STRLIST sl;
3622
3623   if(*string=='!')
3624     {
3625       string++;
3626       critical=1;
3627     }
3628
3629   for(i=0;i<strlen(string);i++)
3630     if(string[i]&0x80 || iscntrl(string[i]))
3631       break;
3632
3633   if(i==0 || i<strlen(string))
3634     {
3635       if(which)
3636         log_error(_("the given certification policy URL is invalid\n"));
3637       else
3638         log_error(_("the given signature policy URL is invalid\n"));
3639     }
3640
3641   if(which)
3642     sl=add_to_strlist( &opt.cert_policy_url, string );
3643   else
3644     sl=add_to_strlist( &opt.sig_policy_url, string );
3645
3646   if(critical)
3647     sl->flags |= 1;    
3648 }
3649
3650 static void
3651 add_keyserver_url( const char *string, int which )
3652 {
3653   int i,critical=0;
3654   STRLIST sl;
3655
3656   if(*string=='!')
3657     {
3658       string++;
3659       critical=1;
3660     }
3661
3662   for(i=0;i<strlen(string);i++)
3663     if(string[i]&0x80 || iscntrl(string[i]))
3664       break;
3665
3666   if(i==0 || i<strlen(string))
3667     {
3668       if(which)
3669         BUG();
3670       else
3671         log_error(_("the given signature preferred"
3672                     " keyserver URL is invalid\n"));
3673     }
3674
3675   if(which)
3676     BUG();
3677   else
3678     sl=add_to_strlist( &opt.sig_keyserver_url, string );
3679
3680   if(critical)
3681     sl->flags |= 1;    
3682 }