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