* keyedit.c (keyedit_menu, menu_set_keyserver_url): Allow passing
[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_STD_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,0,
2088                                               configname,configlineno);
2089             if(!opt.keyserver)
2090               log_error(_("could not parse keyserver URL\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-std-notations",LIST_SHOW_STD_NOTATIONS,NULL},
2130                   {"show-standard-notations",LIST_SHOW_STD_NOTATIONS,NULL},
2131                   {"show-user-notations",LIST_SHOW_USER_NOTATIONS,NULL},
2132                   {"show-keyserver-urls",LIST_SHOW_KEYSERVER_URLS,NULL},
2133                   {"show-validity",LIST_SHOW_VALIDITY,NULL},
2134                   {"show-unusable-uids",LIST_SHOW_UNUSABLE_UIDS,NULL},
2135                   {"show-unusable-subkeys",LIST_SHOW_UNUSABLE_SUBKEYS,NULL},
2136                   {"show-keyring",LIST_SHOW_KEYRING,NULL},
2137                   {"show-sig-expire",LIST_SHOW_SIG_EXPIRE,NULL},
2138                   {NULL,0,NULL}
2139                 };
2140
2141               if(!parse_options(pargs.r.ret_str,&opt.list_options,lopts,1))
2142                 {
2143                   if(configname)
2144                     log_error(_("%s:%d: invalid list options\n"),
2145                               configname,configlineno);
2146                   else
2147                     log_error(_("invalid list options\n"));
2148                 }
2149             }
2150             break;
2151           case oVerifyOptions:
2152             {
2153               struct parse_options vopts[]=
2154                 {
2155                   {"show-photos",VERIFY_SHOW_PHOTOS,NULL},
2156                   {"show-policy-urls",VERIFY_SHOW_POLICY_URLS,NULL},
2157                   {"show-notations",VERIFY_SHOW_NOTATIONS,NULL},
2158                   {"show-std-notations",VERIFY_SHOW_STD_NOTATIONS,NULL},
2159                   {"show-standard-notations",VERIFY_SHOW_STD_NOTATIONS,NULL},
2160                   {"show-user-notations",VERIFY_SHOW_USER_NOTATIONS,NULL},
2161                   {"show-keyserver-urls",VERIFY_SHOW_KEYSERVER_URLS,NULL},
2162                   {"show-validity",VERIFY_SHOW_VALIDITY,NULL},
2163                   {"show-unusable-uids",VERIFY_SHOW_UNUSABLE_UIDS,NULL},
2164                   {NULL,0,NULL}
2165                 };
2166
2167               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts,1))
2168                 {
2169                   if(configname)
2170                     log_error(_("%s:%d: invalid verify options\n"),
2171                               configname,configlineno);
2172                   else
2173                     log_error(_("invalid verify options\n"));
2174                 }
2175             }
2176             break;
2177           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
2178           case oExecPath:
2179             if(set_exec_path(pargs.r.ret_str,0))
2180               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
2181             else
2182               opt.exec_path_set=1;
2183             break;
2184           case oSetNotation:
2185             add_notation_data( pargs.r.ret_str, 0 );
2186             add_notation_data( pargs.r.ret_str, 1 );
2187             break;
2188           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
2189           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
2190           case oShowNotation:
2191             deprecated_warning(configname,configlineno,"--show-notation",
2192                                "--list-options ","show-notations");
2193             deprecated_warning(configname,configlineno,"--show-notation",
2194                                "--verify-options ","show-notations");
2195             opt.list_options|=LIST_SHOW_NOTATIONS;
2196             opt.verify_options|=VERIFY_SHOW_NOTATIONS;
2197             break;
2198           case oNoShowNotation:
2199             deprecated_warning(configname,configlineno,"--no-show-notation",
2200                                "--list-options ","no-show-notations");
2201             deprecated_warning(configname,configlineno,"--no-show-notation",
2202                                "--verify-options ","no-show-notations");
2203             opt.list_options&=~LIST_SHOW_NOTATIONS;
2204             opt.verify_options&=~VERIFY_SHOW_NOTATIONS;
2205             break;
2206           case oUtf8Strings: utf8_strings = 1; break;
2207           case oNoUtf8Strings: utf8_strings = 0; break;
2208           case oDisableCipherAlgo:
2209                 disable_cipher_algo( string_to_cipher_algo(pargs.r.ret_str) );
2210                 break;
2211           case oDisablePubkeyAlgo:
2212                 disable_pubkey_algo( string_to_pubkey_algo(pargs.r.ret_str) );
2213                 break;
2214           case oNoSigCache: opt.no_sig_cache = 1; break;
2215           case oNoSigCreateCheck: opt.no_sig_create_check = 1; break;
2216           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
2217           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
2218           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
2219           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
2220           case oNoLiteral: opt.no_literal = 1; break;
2221           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
2222           case oHonorHttpProxy:
2223                 add_to_strlist(&opt.keyserver_options.other,"http-proxy");
2224                 deprecated_warning(configname,configlineno,
2225                                    "--honor-http-proxy",
2226                                    "--keyserver-options ","http-proxy");
2227                 break;
2228           case oFastListMode: opt.fast_list_mode = 1; break;
2229           case oFixedListMode: opt.fixed_list_mode = 1; break;
2230           case oListOnly: opt.list_only=1; break;
2231           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
2232           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
2233           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
2234           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
2235           case oNoRandomSeedFile: use_random_seed = 0; break;
2236           case oAutoKeyRetrieve:
2237           case oNoAutoKeyRetrieve:
2238                 if(pargs.r_opt==oAutoKeyRetrieve)
2239                   opt.keyserver_options.options|=KEYSERVER_AUTO_KEY_RETRIEVE;
2240                 else
2241                   opt.keyserver_options.options&=~KEYSERVER_AUTO_KEY_RETRIEVE;
2242
2243                 deprecated_warning(configname,configlineno,
2244                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
2245                                "--no-auto-key-retrieve","--keyserver-options ",
2246                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
2247                                "no-auto-key-retrieve");
2248                 break;
2249           case oShowSessionKey: opt.show_session_key = 1; break;
2250           case oOverrideSessionKey:
2251                 opt.override_session_key = pargs.r.ret_str;
2252                 break;
2253           case oMergeOnly:
2254                 deprecated_warning(configname,configlineno,"--merge-only",
2255                                    "--import-options ","merge-only");
2256                 opt.import_options|=IMPORT_MERGE_ONLY;
2257             break;
2258           case oAllowSecretKeyImport: /* obsolete */ break;
2259           case oTryAllSecrets: opt.try_all_secrets = 1; break;
2260           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
2261           case oEnableSpecialFilenames:
2262             iobuf_enable_special_filenames (1);
2263             break;
2264           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
2265           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
2266           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
2267           case oPreservePermissions: opt.preserve_permissions=1; break;
2268           case oDefaultPreferenceList:
2269             opt.def_preference_list = pargs.r.ret_str;
2270             break;
2271           case oPersonalCipherPreferences:
2272             pers_cipher_list=pargs.r.ret_str;
2273             break;
2274           case oPersonalDigestPreferences:
2275             pers_digest_list=pargs.r.ret_str;
2276             break;
2277           case oPersonalCompressPreferences:
2278             pers_compress_list=pargs.r.ret_str;
2279             break;
2280           case oDisplay: opt.display = pargs.r.ret_str; break;
2281           case oTTYname: opt.ttyname = pargs.r.ret_str; break;
2282           case oTTYtype: opt.ttytype = pargs.r.ret_str; break;
2283           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
2284           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
2285           case oGroup: add_group(pargs.r.ret_str); break;
2286           case oUnGroup: rm_group(pargs.r.ret_str); break;
2287           case oNoGroups:
2288             while(opt.grouplist)
2289               {
2290                 struct groupitem *iter=opt.grouplist;
2291                 free_strlist(iter->values);
2292                 opt.grouplist=opt.grouplist->next;
2293                 m_free(iter);
2294               }
2295             break;
2296           case oStrict: opt.strict=1; log_set_strict(1); break;
2297           case oNoStrict: opt.strict=0; log_set_strict(0); break;
2298           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
2299           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
2300           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
2301           case oMultifile: multifile=1; break;
2302           case oKeyidFormat:
2303             if(ascii_strcasecmp(pargs.r.ret_str,"short")==0)
2304               opt.keyid_format=KF_SHORT;
2305             else if(ascii_strcasecmp(pargs.r.ret_str,"long")==0)
2306               opt.keyid_format=KF_LONG;
2307             else if(ascii_strcasecmp(pargs.r.ret_str,"0xshort")==0)
2308               opt.keyid_format=KF_0xSHORT;
2309             else if(ascii_strcasecmp(pargs.r.ret_str,"0xlong")==0)
2310               opt.keyid_format=KF_0xLONG;
2311             else
2312               log_error("unknown keyid-format \"%s\"\n",pargs.r.ret_str);
2313             break;
2314
2315           default : pargs.err = configfp? 1:2; break;
2316           }
2317       }
2318
2319     if( configfp ) {
2320         fclose( configfp );
2321         configfp = NULL;
2322         m_free(configname); configname = NULL;
2323         goto next_pass;
2324     }
2325     m_free( configname ); configname = NULL;
2326     if( log_get_errorcount(0) )
2327         g10_exit(2);
2328     if( nogreeting )
2329         greeting = 0;
2330
2331     if( greeting ) {
2332         fprintf(stderr, "%s %s; %s\n",
2333                         strusage(11), strusage(13), strusage(14) );
2334         fprintf(stderr, "%s\n", strusage(15) );
2335     }
2336 #ifdef IS_DEVELOPMENT_VERSION
2337     if( !opt.batch )
2338       {
2339         const char *s;
2340
2341         if((s=strusage(20)))
2342           log_info("%s\n",s);
2343         if((s=strusage(21)))
2344           log_info("%s\n",s);
2345         if((s=strusage(22)))
2346           log_info("%s\n",s);
2347       }
2348 #endif
2349
2350     if (opt.verbose > 2)
2351         log_info ("using character set `%s'\n", get_native_charset ());
2352
2353     if( may_coredump && !opt.quiet )
2354         log_info(_("WARNING: program may create a core file!\n"));
2355
2356     if (eyes_only) {
2357       if (opt.set_filename)
2358           log_info(_("WARNING: %s overrides %s\n"),
2359                    "--for-your-eyes-only","--set-filename");
2360
2361       opt.set_filename="_CONSOLE";
2362     }
2363
2364     if (opt.no_literal) {
2365         log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
2366         if (opt.textmode)
2367             log_error(_("%s not allowed with %s!\n"),
2368                        "--textmode", "--no-literal" );
2369         if (opt.set_filename)
2370             log_error(_("%s makes no sense with %s!\n"),
2371                         eyes_only?"--for-your-eyes-only":"--set-filename",
2372                         "--no-literal" );
2373     }
2374
2375     if (opt.set_filesize)
2376         log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
2377     if( opt.batch )
2378         tty_batchmode( 1 );
2379
2380     secmem_set_flags( secmem_get_flags() & ~2 ); /* resume warnings */
2381
2382     set_debug();
2383
2384     /* Do these after the switch(), so they can override settings. */
2385     if(PGP2)
2386       {
2387         int unusable=0;
2388
2389         if(cmd==aSign && !detached_sig)
2390           {
2391             log_info(_("you can only make detached or clear signatures "
2392                        "while in --pgp2 mode\n"));
2393             unusable=1;
2394           }
2395         else if(cmd==aSignEncr || cmd==aSignSym)
2396           {
2397             log_info(_("you can't sign and encrypt at the "
2398                        "same time while in --pgp2 mode\n"));
2399             unusable=1;
2400           }
2401         else if(argc==0 && (cmd==aSign || cmd==aEncr || cmd==aSym))
2402           {
2403             log_info(_("you must use files (and not a pipe) when "
2404                        "working with --pgp2 enabled.\n"));
2405             unusable=1;
2406           }
2407         else if(cmd==aEncr || cmd==aSym)
2408           {
2409             /* Everything else should work without IDEA (except using
2410                a secret key encrypted with IDEA and setting an IDEA
2411                preference, but those have their own error
2412                messages). */
2413
2414             if(check_cipher_algo(CIPHER_ALGO_IDEA))
2415               {
2416                 log_info(_("encrypting a message in --pgp2 mode requires "
2417                            "the IDEA cipher\n"));
2418                 idea_cipher_warn(1);
2419                 unusable=1;
2420               }
2421             else if(cmd==aSym)
2422               {
2423                 /* This only sets IDEA for symmetric encryption
2424                    since it is set via select_algo_from_prefs for
2425                    pk encryption. */
2426                 m_free(def_cipher_string);
2427                 def_cipher_string = m_strdup("idea");
2428               }
2429
2430             /* PGP2 can't handle the output from the textmode
2431                filter, so we disable it for anything that could
2432                create a literal packet (only encryption and
2433                symmetric encryption, since we disable signing
2434                above). */
2435             if(!unusable)
2436               opt.textmode=0;
2437           }
2438
2439         if(unusable)
2440           compliance_failure();
2441         else
2442           {
2443             opt.force_v4_certs = 0;
2444             opt.sk_comments = 0;
2445             opt.escape_from = 1;
2446             opt.force_v3_sigs = 1;
2447             opt.pgp2_workarounds = 1;
2448             opt.ask_sig_expire = 0;
2449             opt.ask_cert_expire = 0;
2450             m_free(def_digest_string);
2451             def_digest_string = m_strdup("md5");
2452             opt.compress_algo = COMPRESS_ALGO_ZIP;
2453           }
2454       }
2455     else if(PGP6)
2456       {
2457         opt.sk_comments=0;
2458         opt.escape_from=1;
2459         opt.force_v3_sigs=1;
2460         opt.ask_sig_expire=0;
2461       }
2462     else if(PGP7)
2463       {
2464         opt.sk_comments=0;
2465         opt.escape_from=1;
2466         opt.force_v3_sigs=1;
2467         opt.ask_sig_expire=0;
2468       }
2469     else if(PGP8)
2470       {
2471         opt.escape_from=1;
2472       }
2473
2474     /* must do this after dropping setuid, because string_to...
2475      * may try to load an module */
2476     if( def_cipher_string ) {
2477         opt.def_cipher_algo = string_to_cipher_algo(def_cipher_string);
2478         if(opt.def_cipher_algo==0 &&
2479            (ascii_strcasecmp(def_cipher_string,"idea")==0
2480             || ascii_strcasecmp(def_cipher_string,"s1")==0))
2481           idea_cipher_warn(1);
2482         m_free(def_cipher_string); def_cipher_string = NULL;
2483         if( check_cipher_algo(opt.def_cipher_algo) )
2484             log_error(_("selected cipher algorithm is invalid\n"));
2485     }
2486     if( def_digest_string ) {
2487         opt.def_digest_algo = string_to_digest_algo(def_digest_string);
2488         m_free(def_digest_string); def_digest_string = NULL;
2489         if( check_digest_algo(opt.def_digest_algo) )
2490             log_error(_("selected digest algorithm is invalid\n"));
2491     }
2492     if( compress_algo_string ) {
2493         opt.compress_algo = string_to_compress_algo(compress_algo_string);
2494         m_free(compress_algo_string); compress_algo_string = NULL;
2495         if( check_compress_algo(opt.compress_algo) )
2496             log_error(_("selected compression algorithm is invalid\n"));
2497     }
2498     if( cert_digest_string ) {
2499         opt.cert_digest_algo = string_to_digest_algo(cert_digest_string);
2500         m_free(cert_digest_string); cert_digest_string = NULL;
2501         if( check_digest_algo(opt.cert_digest_algo) )
2502             log_error(_("selected certification digest algorithm is invalid\n"));
2503     }
2504     if( s2k_cipher_string ) {
2505         opt.s2k_cipher_algo = string_to_cipher_algo(s2k_cipher_string);
2506         m_free(s2k_cipher_string); s2k_cipher_string = NULL;
2507         if( check_cipher_algo(opt.s2k_cipher_algo) )
2508             log_error(_("selected cipher algorithm is invalid\n"));
2509     }
2510     if( s2k_digest_string ) {
2511         opt.s2k_digest_algo = string_to_digest_algo(s2k_digest_string);
2512         m_free(s2k_digest_string); s2k_digest_string = NULL;
2513         if( check_digest_algo(opt.s2k_digest_algo) )
2514             log_error(_("selected digest algorithm is invalid\n"));
2515     }
2516     if( opt.completes_needed < 1 )
2517       log_error(_("completes-needed must be greater than 0\n"));
2518     if( opt.marginals_needed < 2 )
2519       log_error(_("marginals-needed must be greater than 1\n"));
2520     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
2521       log_error(_("max-cert-depth must be in the range from 1 to 255\n"));
2522     if(opt.def_cert_level<0 || opt.def_cert_level>3)
2523       log_error(_("invalid default-cert-level; must be 0, 1, 2, or 3\n"));
2524     if( opt.min_cert_level < 1 || opt.min_cert_level > 3 )
2525       log_error(_("invalid min-cert-level; must be 1, 2, or 3\n"));
2526     switch( opt.s2k_mode ) {
2527       case 0:
2528         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
2529         break;
2530       case 1: case 3: break;
2531       default:
2532         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
2533     }
2534
2535     /* This isn't actually needed, but does serve to error out if the
2536        string is invalid. */
2537     if(opt.def_preference_list &&
2538         keygen_set_std_prefs(opt.def_preference_list,0))
2539       log_error(_("invalid default preferences\n"));
2540
2541     /* We provide defaults for the personal digest list.  This is
2542        SHA-1. */
2543     if(!pers_digest_list)
2544       pers_digest_list="h2";
2545
2546     if(pers_cipher_list &&
2547        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
2548       log_error(_("invalid personal cipher preferences\n"));
2549
2550     if(pers_digest_list &&
2551        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
2552       log_error(_("invalid personal digest preferences\n"));
2553
2554     if(pers_compress_list &&
2555        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
2556       log_error(_("invalid personal compress preferences\n"));
2557
2558     /* We don't support all possible commands with multifile yet */
2559     if(multifile)
2560       {
2561         char *cmdname;
2562
2563         switch(cmd)
2564           {
2565           case aSign:
2566             cmdname="--sign";
2567             break;
2568           case aClearsign:
2569             cmdname="--clearsign";
2570             break;
2571           case aDetachedSign:
2572             cmdname="--detach-sign";
2573             break;
2574           case aSym:
2575             cmdname="--symmetric";
2576             break;
2577           case aEncrSym:
2578             cmdname="--symmetric --encrypt";
2579             break;
2580           case aStore:
2581             cmdname="--store";
2582             break;
2583           default:
2584             cmdname=NULL;
2585             break;
2586           }
2587
2588         if(cmdname)
2589           log_error(_("%s does not yet work with %s\n"),cmdname,"--multifile");
2590       }
2591
2592     if( log_get_errorcount(0) )
2593         g10_exit(2);
2594
2595     if(opt.compress_level==0)
2596       opt.compress_algo=COMPRESS_ALGO_NONE;
2597
2598     /* Check our chosen algorithms against the list of legal
2599        algorithms. */
2600
2601     if(!GNUPG)
2602       {
2603         const char *badalg=NULL;
2604         preftype_t badtype=PREFTYPE_NONE;
2605
2606         if(opt.def_cipher_algo
2607            && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
2608           {
2609             badalg=cipher_algo_to_string(opt.def_cipher_algo);
2610             badtype=PREFTYPE_SYM;
2611           }
2612         else if(opt.def_digest_algo
2613                 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
2614           {
2615             badalg=digest_algo_to_string(opt.def_digest_algo);
2616             badtype=PREFTYPE_HASH;
2617           }
2618         else if(opt.cert_digest_algo
2619                 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
2620           {
2621             badalg=digest_algo_to_string(opt.cert_digest_algo);
2622             badtype=PREFTYPE_HASH;
2623           }
2624         else if(opt.compress_algo!=-1
2625                 && !algo_available(PREFTYPE_ZIP,opt.compress_algo,NULL))
2626           {
2627             badalg=compress_algo_to_string(opt.compress_algo);
2628             badtype=PREFTYPE_ZIP;
2629           }
2630
2631         if(badalg)
2632           {
2633             switch(badtype)
2634               {
2635               case PREFTYPE_SYM:
2636                 log_info(_("you may not use cipher algorithm \"%s\" "
2637                            "while in %s mode\n"),
2638                          badalg,compliance_option_string());
2639                 break;
2640               case PREFTYPE_HASH:
2641                 log_info(_("you may not use digest algorithm \"%s\" "
2642                            "while in %s mode\n"),
2643                          badalg,compliance_option_string());
2644                 break;
2645               case PREFTYPE_ZIP:
2646                 log_info(_("you may not use compression algorithm \"%s\" "
2647                            "while in %s mode\n"),
2648                          badalg,compliance_option_string());
2649                 break;
2650               default:
2651                 BUG();
2652               }
2653
2654             compliance_failure();
2655           }
2656       }
2657
2658     /* set the random seed file */
2659     if( use_random_seed ) {
2660         char *p = make_filename(opt.homedir, "random_seed", NULL );
2661         set_random_seed_file(p);
2662         m_free(p);
2663     }
2664
2665     if( !cmd && opt.fingerprint && !with_fpr ) {
2666         set_cmd( &cmd, aListKeys);
2667     }
2668
2669     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
2670         if( cmd == aKModeC ) {
2671             opt.fingerprint = 1;
2672             cmd = aKMode;
2673         }
2674         opt.list_sigs = 0;
2675         if( opt.verbose > 2 )
2676             opt.check_sigs++;
2677         if( opt.verbose > 1 )
2678             opt.list_sigs++;
2679
2680         opt.verbose = opt.verbose > 1;
2681         g10_opt_verbose = opt.verbose;
2682     }
2683
2684     /* kludge to let -sat generate a clear text signature */
2685     if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
2686         cmd = aClearsign;
2687
2688     if( opt.verbose > 1 )
2689         set_packet_list_mode(1);
2690
2691     /* Add the keyrings, but not for some special commands and not in
2692        case of "-kvv userid keyring".  Also avoid adding the secret
2693        keyring for a couple of commands to avoid unneeded access in
2694        case the secrings are stored on a floppy */
2695     if( cmd != aDeArmor && cmd != aEnArmor
2696         && !(cmd == aKMode && argc == 2 ) ) 
2697       {
2698         if (cmd != aCheckKeys && cmd != aListSigs && cmd != aListKeys
2699             && cmd != aVerify && cmd != aSym)
2700           {
2701             if (!sec_nrings || default_keyring) /* add default secret rings */
2702               keydb_add_resource ("secring" EXTSEP_S "gpg", 0, 1);
2703             for (sl = sec_nrings; sl; sl = sl->next)
2704               keydb_add_resource ( sl->d, 0, 1 );
2705           }
2706         if( !nrings || default_keyring )  /* add default ring */
2707             keydb_add_resource ("pubring" EXTSEP_S "gpg", 0, 0);
2708         for(sl = nrings; sl; sl = sl->next )
2709             keydb_add_resource ( sl->d, sl->flags, 0 );
2710       }
2711     FREE_STRLIST(nrings);
2712     FREE_STRLIST(sec_nrings);
2713
2714
2715     if( pwfd != -1 )  /* read the passphrase now. */
2716         read_passphrase_from_fd( pwfd );
2717
2718     fname = argc? *argv : NULL;
2719
2720     switch( cmd ) {
2721       case aPrimegen:
2722       case aPrintMD:
2723       case aPrintMDs:
2724       case aGenRandom:
2725       case aDeArmor:
2726       case aEnArmor:
2727       case aFixTrustDB:
2728         break;
2729       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
2730       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
2731       default: rc = setup_trustdb(1, trustdb_name ); break;
2732     }
2733     if( rc )
2734         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
2735
2736
2737     switch (cmd)
2738       {
2739       case aStore: 
2740       case aSym:  
2741       case aSign: 
2742       case aSignSym: 
2743       case aClearsign: 
2744         if (!opt.quiet && any_explicit_recipient)
2745           log_info (_("WARNING: recipients (-r) given "
2746                       "without using public key encryption\n"));
2747         break;
2748       default:
2749         break;
2750       }
2751
2752     switch( cmd )
2753       {
2754       case aStore: /* only store the file */
2755         if( argc > 1 )
2756             wrong_args(_("--store [filename]"));
2757         if( (rc = encode_store(fname)) )
2758             log_error_f( print_fname_stdin(fname),
2759                         "store failed: %s\n", g10_errstr(rc) );
2760         break;
2761       case aSym: /* encrypt the given file only with the symmetric cipher */
2762         if( argc > 1 )
2763             wrong_args(_("--symmetric [filename]"));
2764         if( (rc = encode_symmetric(fname)) )
2765             log_error_f(print_fname_stdin(fname),
2766                         "symmetric encryption failed: %s\n",g10_errstr(rc) );
2767         break;
2768
2769       case aEncr: /* encrypt the given file */
2770         if(multifile)
2771           encode_crypt_files(argc, argv, remusr);
2772         else
2773           {
2774             if( argc > 1 )
2775               wrong_args(_("--encrypt [filename]"));
2776             if( (rc = encode_crypt(fname,remusr,0)) )
2777               log_error("%s: encryption failed: %s\n",
2778                         print_fname_stdin(fname), g10_errstr(rc) );
2779           }
2780         break;
2781
2782       case aEncrSym:
2783         /* This works with PGP 8 in the sense that it acts just like a
2784            symmetric message.  It doesn't work at all with 2 or 6.  It
2785            might work with 7, but alas, I don't have a copy to test
2786            with right now. */
2787         if( argc > 1 )
2788           wrong_args(_("--symmetric --encrypt [filename]"));
2789         else if(opt.s2k_mode==0)
2790           log_error(_("you cannot use --symmetric --encrypt"
2791                       " with --s2k-mode 0\n"));
2792         else if(PGP2 || PGP6 || PGP7 || RFC1991)
2793           log_error(_("you cannot use --symmetric --encrypt"
2794                       " while in %s mode\n"),compliance_option_string());
2795         else
2796           {
2797             if( (rc = encode_crypt(fname,remusr,1)) )
2798               log_error("%s: encryption failed: %s\n",
2799                         print_fname_stdin(fname), g10_errstr(rc) );
2800           }
2801         break;
2802
2803       case aSign: /* sign the given file */
2804         sl = NULL;
2805         if( detached_sig ) { /* sign all files */
2806             for( ; argc; argc--, argv++ )
2807                 add_to_strlist( &sl, *argv );
2808         }
2809         else {
2810             if( argc > 1 )
2811                 wrong_args(_("--sign [filename]"));
2812             if( argc ) {
2813                 sl = m_alloc_clear( sizeof *sl + strlen(fname));
2814                 strcpy(sl->d, fname);
2815             }
2816         }
2817         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
2818             log_error("signing failed: %s\n", g10_errstr(rc) );
2819         free_strlist(sl);
2820         break;
2821
2822       case aSignEncr: /* sign and encrypt the given file */
2823         if( argc > 1 )
2824             wrong_args(_("--sign --encrypt [filename]"));
2825         if( argc ) {
2826             sl = m_alloc_clear( sizeof *sl + strlen(fname));
2827             strcpy(sl->d, fname);
2828         }
2829         else
2830             sl = NULL;
2831         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
2832             log_error("%s: sign+encrypt failed: %s\n",
2833                       print_fname_stdin(fname), g10_errstr(rc) );
2834         free_strlist(sl);
2835         break;
2836
2837       case aSignEncrSym: /* sign and encrypt the given file */
2838         if( argc > 1 )
2839             wrong_args(_("--symmetric --sign --encrypt [filename]"));
2840         else if(opt.s2k_mode==0)
2841           log_error(_("you cannot use --symmetric --sign --encrypt"
2842                       " with --s2k-mode 0\n"));
2843         else if(PGP2 || PGP6 || PGP7 || RFC1991)
2844           log_error(_("you cannot use --symmetric --sign --encrypt"
2845                       " while in %s mode\n"),compliance_option_string());
2846         else
2847           {
2848             if( argc )
2849               {
2850                 sl = m_alloc_clear( sizeof *sl + strlen(fname));
2851                 strcpy(sl->d, fname);
2852               }
2853             else
2854               sl = NULL;
2855             if( (rc = sign_file(sl, detached_sig, locusr, 2, remusr, NULL)) )
2856               log_error("%s: symmetric+sign+encrypt failed: %s\n",
2857                         print_fname_stdin(fname), g10_errstr(rc) );
2858             free_strlist(sl);
2859           }
2860         break;
2861
2862       case aSignSym: /* sign and conventionally encrypt the given file */
2863         if (argc > 1)
2864             wrong_args(_("--sign --symmetric [filename]"));
2865         rc = sign_symencrypt_file (fname, locusr);
2866         if (rc)
2867             log_error("%s: sign+symmetric failed: %s\n",
2868                       print_fname_stdin(fname), g10_errstr(rc) );
2869         break;
2870
2871       case aClearsign: /* make a clearsig */
2872         if( argc > 1 )
2873             wrong_args(_("--clearsign [filename]"));
2874         if( (rc = clearsign_file(fname, locusr, NULL)) )
2875             log_error("%s: clearsign failed: %s\n",
2876                       print_fname_stdin(fname), g10_errstr(rc) );
2877         break;
2878
2879       case aVerify:
2880         if(multifile)
2881           {
2882             if( (rc = verify_files( argc, argv ) ))
2883               log_error("verify files failed: %s\n", g10_errstr(rc) );
2884           }
2885         else
2886           {
2887             if( (rc = verify_signatures( argc, argv ) ))
2888               log_error("verify signatures failed: %s\n", g10_errstr(rc) );
2889           }
2890         break;
2891
2892       case aDecrypt:
2893         if(multifile)
2894           decrypt_messages(argc, argv);
2895         else
2896           {
2897             if( argc > 1 )
2898               wrong_args(_("--decrypt [filename]"));
2899             if( (rc = decrypt_message( fname ) ))
2900               log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
2901           }
2902         break;
2903             
2904       case aSignKey:
2905         if( argc != 1 )
2906           wrong_args(_("--sign-key user-id"));
2907         /* fall through */
2908       case aLSignKey:
2909         if( argc != 1 )
2910           wrong_args(_("--lsign-key user-id"));
2911         /* fall through */
2912       case aNRSignKey:
2913         if( argc != 1 )
2914           wrong_args(_("--nrsign-key user-id"));
2915         /* fall through */
2916       case aNRLSignKey:
2917         if( argc != 1 )
2918           wrong_args(_("--nrlsign-key user-id"));
2919
2920         sl=NULL;
2921
2922         if(cmd==aSignKey)
2923           append_to_strlist(&sl,"sign");
2924         else if(cmd==aLSignKey)
2925           append_to_strlist(&sl,"lsign");
2926         else if(cmd==aNRSignKey)
2927           append_to_strlist(&sl,"nrsign");
2928         else if(cmd==aNRLSignKey)
2929           append_to_strlist(&sl,"nrlsign");
2930         else
2931           BUG();
2932
2933         append_to_strlist( &sl, "save" );
2934         username = make_username( fname );
2935         keyedit_menu(fname, locusr, sl, 0, 0 );
2936         m_free(username);
2937         free_strlist(sl);
2938         break;
2939
2940       case aEditKey: /* Edit a key signature */
2941         if( !argc )
2942             wrong_args(_("--edit-key user-id [commands]"));
2943         username = make_username( fname );
2944         if( argc > 1 ) {
2945             sl = NULL;
2946             for( argc--, argv++ ; argc; argc--, argv++ )
2947                 append_to_strlist( &sl, *argv );
2948             keyedit_menu( username, locusr, sl, 0, 1 );
2949             free_strlist(sl);
2950         }
2951         else
2952             keyedit_menu(username, locusr, NULL, 0, 1 );
2953         m_free(username);
2954         break;
2955
2956       case aDeleteKeys:
2957       case aDeleteSecretKeys:
2958       case aDeleteSecretAndPublicKeys:
2959         sl = NULL;
2960         /* I'm adding these in reverse order as add_to_strlist2
2961            reverses them again, and it's easier to understand in the
2962            proper order :) */
2963         for( ; argc; argc-- )
2964           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
2965         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
2966         free_strlist(sl);
2967         break;
2968
2969       case aCheckKeys:
2970         opt.check_sigs = 1;
2971       case aListSigs:
2972         opt.list_sigs = 1;
2973       case aListKeys:
2974         sl = NULL;
2975         for( ; argc; argc--, argv++ )
2976             add_to_strlist2( &sl, *argv, utf8_strings );
2977         public_key_list( sl );
2978         free_strlist(sl);
2979         break;
2980       case aListSecretKeys:
2981         sl = NULL;
2982         for( ; argc; argc--, argv++ )
2983             add_to_strlist2( &sl, *argv, utf8_strings );
2984         secret_key_list( sl );
2985         free_strlist(sl);
2986         break;
2987
2988       case aKMode: /* list keyring -- NOTE: This will be removed soon */
2989         if( argc < 2 ) { /* -kv [userid] */
2990             sl = NULL;
2991             if (argc && **argv)
2992                 add_to_strlist2( &sl, *argv, utf8_strings );
2993             public_key_list( sl );
2994             free_strlist(sl);
2995         }
2996         else if( argc == 2 ) { /* -kv userid keyring */
2997             if( access( argv[1], R_OK ) ) {
2998                 log_error(_("can't open %s: %s\n"),
2999                                print_fname_stdin(argv[1]), strerror(errno));
3000             }
3001             else {
3002                 /* add keyring (default keyrings are not registered in this
3003                  * special case */
3004                 keydb_add_resource( argv[1], 0, 0 );
3005                 sl = NULL;
3006                 if (**argv)
3007                     add_to_strlist2( &sl, *argv, utf8_strings );
3008                 public_key_list( sl );
3009                 free_strlist(sl);
3010             }
3011         }
3012         else
3013             wrong_args(_("-k[v][v][v][c] [user-id] [keyring]") );
3014         break;
3015
3016       case aKeygen: /* generate a key */
3017         if( opt.batch ) {
3018             if( argc > 1 )
3019                 wrong_args("--gen-key [parameterfile]");
3020             generate_keypair( argc? *argv : NULL, NULL );
3021         }
3022         else {
3023             if( argc )
3024                 wrong_args("--gen-key");
3025             generate_keypair(NULL, NULL);
3026         }
3027         break;
3028
3029       case aFastImport:
3030         opt.import_options |= IMPORT_FAST_IMPORT;
3031       case aImport:
3032         import_keys( argc? argv:NULL, argc, NULL, opt.import_options );
3033         break;
3034
3035       case aExport:
3036       case aSendKeys:
3037       case aRecvKeys:
3038         sl = NULL;
3039         for( ; argc; argc--, argv++ )
3040             add_to_strlist2( &sl, *argv, utf8_strings );
3041         if( cmd == aSendKeys )
3042             rc=keyserver_export( sl );
3043         else if( cmd == aRecvKeys )
3044             rc=keyserver_import( sl );
3045         else
3046             rc=export_pubkeys( sl, opt.export_options );
3047         if(rc)
3048           {
3049             if(cmd==aSendKeys)
3050               log_error(_("keyserver send failed: %s\n"),g10_errstr(rc));
3051             else if(cmd==aRecvKeys)
3052               log_error(_("keyserver receive failed: %s\n"),g10_errstr(rc));
3053             else
3054               log_error(_("key export failed: %s\n"),g10_errstr(rc));
3055           }
3056         free_strlist(sl);
3057         break;
3058
3059      case aSearchKeys:
3060         sl = NULL;
3061         for( ; argc; argc--, argv++ )
3062           append_to_strlist2( &sl, *argv, utf8_strings );
3063         rc=keyserver_search( sl );
3064         if(rc)
3065           log_error(_("keyserver search failed: %s\n"),g10_errstr(rc));
3066         free_strlist(sl);
3067         break;
3068
3069       case aRefreshKeys:
3070         sl = NULL;
3071         for( ; argc; argc--, argv++ )
3072             add_to_strlist2( &sl, *argv, utf8_strings );
3073         rc=keyserver_refresh(sl);
3074         if(rc)
3075           log_error(_("keyserver refresh failed: %s\n"),g10_errstr(rc));
3076         free_strlist(sl);
3077         break;
3078
3079       case aExportSecret:
3080         sl = NULL;
3081         for( ; argc; argc--, argv++ )
3082             add_to_strlist2( &sl, *argv, utf8_strings );
3083         export_seckeys( sl );
3084         free_strlist(sl);
3085         break;
3086
3087       case aExportSecretSub:
3088         sl = NULL;
3089         for( ; argc; argc--, argv++ )
3090             add_to_strlist2( &sl, *argv, utf8_strings );
3091         export_secsubkeys( sl );
3092         free_strlist(sl);
3093         break;
3094
3095       case aGenRevoke:
3096         if( argc != 1 )
3097             wrong_args("--gen-revoke user-id");
3098         username =  make_username(*argv);
3099         gen_revoke( username );
3100         m_free( username );
3101         break;
3102
3103       case aDesigRevoke:
3104         if( argc != 1 )
3105             wrong_args("--desig-revoke user-id");
3106         username =  make_username(*argv);
3107         gen_desig_revoke( username );
3108         m_free( username );
3109         break;
3110
3111       case aDeArmor:
3112         if( argc > 1 )
3113             wrong_args("--dearmor [file]");
3114         rc = dearmor_file( argc? *argv: NULL );
3115         if( rc )
3116             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
3117         break;
3118
3119       case aEnArmor:
3120         if( argc > 1 )
3121             wrong_args("--enarmor [file]");
3122         rc = enarmor_file( argc? *argv: NULL );
3123         if( rc )
3124             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
3125         break;
3126
3127
3128       case aPrimegen:
3129         {   int mode = argc < 2 ? 0 : atoi(*argv);
3130
3131             if( mode == 1 && argc == 2 ) {
3132                 mpi_print( stdout, generate_public_prime( atoi(argv[1]) ), 1);
3133             }
3134             else if( mode == 2 && argc == 3 ) {
3135                 mpi_print( stdout, generate_elg_prime(
3136                                              0, atoi(argv[1]),
3137                                              atoi(argv[2]), NULL,NULL ), 1);
3138             }
3139             else if( mode == 3 && argc == 3 ) {
3140                 MPI *factors;
3141                 mpi_print( stdout, generate_elg_prime(
3142                                              1, atoi(argv[1]),
3143                                              atoi(argv[2]), NULL,&factors ), 1);
3144                 putchar('\n');
3145                 mpi_print( stdout, factors[0], 1 ); /* print q */
3146             }
3147             else if( mode == 4 && argc == 3 ) {
3148                 MPI g = mpi_alloc(1);
3149                 mpi_print( stdout, generate_elg_prime(
3150                                                  0, atoi(argv[1]),
3151                                                  atoi(argv[2]), g, NULL ), 1);
3152                 putchar('\n');
3153                 mpi_print( stdout, g, 1 );
3154                 mpi_free(g);
3155             }
3156             else
3157                 wrong_args("--gen-prime mode bits [qbits] ");
3158             putchar('\n');
3159         }
3160         break;
3161
3162       case aGenRandom:
3163         {
3164             int level = argc ? atoi(*argv):0;
3165             int count = argc > 1 ? atoi(argv[1]): 0;
3166             int endless = !count;
3167
3168             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
3169                 wrong_args("--gen-random 0|1|2 [count]");
3170
3171             while( endless || count ) {
3172                 byte *p;
3173                 /* Wee need a multiple of 3, so that in case of
3174                    armored output we get a correct string.  No
3175                    linefolding is done, as it is best to levae this to
3176                    other tools */
3177                 size_t n = !endless && count < 99? count : 99;
3178
3179                 p = get_random_bits( n*8, level, 0);
3180 #ifdef HAVE_DOSISH_SYSTEM
3181                 setmode ( fileno(stdout), O_BINARY );
3182 #endif
3183                 if (opt.armor) {
3184                     char *tmp = make_radix64_string (p, n);
3185                     fputs (tmp, stdout);
3186                     m_free (tmp);
3187                     if (n%3 == 1)
3188                       putchar ('=');
3189                     if (n%3)
3190                       putchar ('=');
3191                 } else {
3192                     fwrite( p, n, 1, stdout );
3193                 }
3194                 m_free(p);
3195                 if( !endless )
3196                     count -= n;
3197             }
3198             if (opt.armor)
3199                 putchar ('\n');
3200         }
3201         break;
3202
3203       case aPrintMD:
3204         if( argc < 1)
3205             wrong_args("--print-md algo [files]");
3206         {
3207             int all_algos = (**argv=='*' && !(*argv)[1]);
3208             int algo = all_algos? 0 : string_to_digest_algo(*argv);
3209
3210             if( !algo && !all_algos )
3211                 log_error(_("invalid hash algorithm `%s'\n"), *argv );
3212             else {
3213                 argc--; argv++;
3214                 if( !argc )
3215                     print_mds(NULL, algo);
3216                 else {
3217                     for(; argc; argc--, argv++ )
3218                         print_mds(*argv, algo);
3219                 }
3220             }
3221         }
3222         break;
3223
3224       case aPrintMDs: /* old option */
3225         if( !argc )
3226             print_mds(NULL,0);
3227         else {
3228             for(; argc; argc--, argv++ )
3229                 print_mds(*argv,0);
3230         }
3231         break;
3232
3233       case aListTrustDB:
3234         if( !argc )
3235             list_trustdb(NULL);
3236         else {
3237             for( ; argc; argc--, argv++ )
3238                 list_trustdb( *argv );
3239         }
3240         break;
3241
3242       case aUpdateTrustDB:
3243         if( argc )
3244             wrong_args("--update-trustdb");
3245         update_trustdb();
3246         break;
3247
3248       case aCheckTrustDB:
3249         /* Old versions allowed for arguments - ignore them */
3250         check_trustdb();
3251         break;
3252
3253       case aFixTrustDB:
3254         log_error("this command is not yet implemented.\n");
3255         log_error("A workaround is to use \"--export-ownertrust\", remove\n");
3256         log_error("the trustdb file and do an \"--import-ownertrust\".\n" );
3257         break;
3258
3259       case aListTrustPath:
3260         if( !argc )
3261             wrong_args("--list-trust-path <user-ids>");
3262         for( ; argc; argc--, argv++ ) {
3263             username = make_username( *argv );
3264             list_trust_path( username );
3265             m_free(username);
3266         }
3267         break;
3268
3269       case aExportOwnerTrust:
3270         if( argc )
3271             wrong_args("--export-ownertrust");
3272         export_ownertrust();
3273         break;
3274
3275       case aImportOwnerTrust:
3276         if( argc > 1 )
3277             wrong_args("--import-ownertrust [file]");
3278         import_ownertrust( argc? *argv:NULL );
3279         break;
3280       
3281       case aPipeMode:
3282         if ( argc )
3283             wrong_args ("--pipemode");
3284         run_in_pipemode ();
3285         break;
3286
3287       case aRebuildKeydbCaches:
3288         if (argc)
3289             wrong_args ("--rebuild-keydb-caches");
3290         keydb_rebuild_caches (1);
3291         break;
3292
3293 #ifdef ENABLE_CARD_SUPPORT
3294       case aCardStatus:
3295         if (argc)
3296             wrong_args ("--card-status");
3297         card_status (stdout, NULL, 0);
3298         break;
3299
3300       case aCardEdit:
3301         if (argc) {
3302             sl = NULL;
3303             for (argc--, argv++ ; argc; argc--, argv++)
3304                 append_to_strlist (&sl, *argv);
3305             card_edit (sl);
3306             free_strlist (sl);
3307         }
3308         else
3309             card_edit (NULL);
3310         break;
3311
3312       case aChangePIN:
3313         if (!argc)
3314             change_pin (0);
3315         else if (argc == 1)
3316             change_pin ( atoi (*argv));
3317         else
3318         wrong_args ("--change-pin [no]");
3319         break;
3320 #endif /* ENABLE_CARD_SUPPORT*/
3321
3322       case aListConfig:
3323         {
3324           char *str=collapse_args(argc,argv);
3325           list_config(str);
3326           m_free(str);
3327         }
3328         break;
3329
3330       case aListPackets:
3331         opt.list_packets=2;
3332       default:
3333         if( argc > 1 )
3334             wrong_args(_("[filename]"));
3335         /* Issue some output for the unix newbie */
3336         if( !fname && !opt.outfile && isatty( fileno(stdin) )
3337                 && isatty( fileno(stdout) ) && isatty( fileno(stderr) ) )
3338             log_info(_("Go ahead and type your message ...\n"));
3339
3340         if( !(a = iobuf_open(fname)) )
3341             log_error(_("can't open `%s'\n"), print_fname_stdin(fname));
3342         else {
3343
3344             if( !opt.no_armor ) {
3345                 if( use_armor_filter( a ) ) {
3346                     memset( &afx, 0, sizeof afx);
3347                     iobuf_push_filter( a, armor_filter, &afx );
3348                 }
3349             }
3350             if( cmd == aListPackets ) {
3351                 set_packet_list_mode(1);
3352                 opt.list_packets=1;
3353             }
3354             rc = proc_packets(NULL, a );
3355             if( rc )
3356                 log_error("processing message failed: %s\n", g10_errstr(rc) );
3357             iobuf_close(a);
3358         }
3359         break;
3360       }
3361
3362     /* cleanup */
3363     FREE_STRLIST(remusr);
3364     FREE_STRLIST(locusr);
3365     g10_exit(0);
3366     return 8; /*NEVER REACHED*/
3367 }
3368
3369
3370 void
3371 g10_exit( int rc )
3372 {
3373 #ifdef ENABLE_CARD_SUPPORT
3374     card_close ();
3375 #endif
3376     update_random_seed_file();
3377     if( opt.debug & DBG_MEMSTAT_VALUE ) {
3378         m_print_stats("on exit");
3379         random_dump_stats();
3380     }
3381     if( opt.debug )
3382         secmem_dump_stats();
3383     secmem_term();
3384     rc = rc? rc : log_get_errorcount(0)? 2 :
3385                         g10_errors_seen? 1 : 0;
3386     exit(rc );
3387 }
3388
3389
3390 /* Pretty-print hex hashes.  This assumes at least an 80-character
3391    display, but there are a few other similar assumptions in the
3392    display code. */
3393 static void
3394 print_hex( MD_HANDLE md, int algo, const char *fname )
3395 {
3396   int i,n,count,indent=0;
3397   const byte *p;
3398
3399   if(fname)
3400     indent=printf("%s: ",fname);
3401
3402   if(indent>40)
3403     {
3404       printf("\n");
3405       indent=0;
3406     }
3407
3408   if(algo==DIGEST_ALGO_RMD160)
3409     indent+=printf("RMD160 = ");
3410   else if(algo>0)
3411     indent+=printf("%6s = ",digest_algo_to_string(algo));
3412   else
3413     algo=abs(algo);
3414
3415   count=indent;
3416
3417   p = md_read( md, algo );
3418   n = md_digest_length(algo);
3419
3420   count+=printf("%02X",*p++);
3421
3422   for(i=1;i<n;i++,p++)
3423     {
3424       if(n==16)
3425         {
3426           if(count+2>79)
3427             {
3428               printf("\n%*s",indent," ");
3429               count=indent;
3430             }
3431           else
3432             count+=printf(" ");
3433
3434           if(!(i%8))
3435             count+=printf(" ");
3436         }
3437       else if (n==20)
3438         {
3439           if(!(i%2))
3440             {
3441               if(count+4>79)
3442                 {
3443                   printf("\n%*s",indent," ");
3444                   count=indent;
3445                 }
3446               else
3447                 count+=printf(" ");
3448             }
3449
3450           if(!(i%10))
3451             count+=printf(" ");
3452         }
3453       else
3454         {
3455           if(!(i%4))
3456             {
3457               if(count+8>79)
3458                 {
3459                   printf("\n%*s",indent," ");
3460                   count=indent;
3461                 }
3462               else
3463                 count+=printf(" ");
3464             }
3465         }
3466
3467       count+=printf("%02X",*p);
3468     }
3469
3470   printf("\n");
3471 }
3472
3473 static void
3474 print_hashline( MD_HANDLE md, int algo, const char *fname )
3475 {
3476     int i, n;
3477     const byte *p;
3478     
3479     if ( fname ) {
3480         for (p = fname; *p; p++ ) {
3481             if ( *p <= 32 || *p > 127 || *p == ':' || *p == '%' )
3482                 printf("%%%02X", *p );
3483             else 
3484                 putchar( *p );
3485         }
3486     }
3487     putchar(':');
3488     printf("%d:", algo );
3489     p = md_read( md, algo );
3490     n = md_digest_length(algo);
3491     for(i=0; i < n ; i++, p++ ) 
3492         printf("%02X", *p );
3493     putchar(':');
3494     putchar('\n');
3495 }
3496
3497 static void
3498 print_mds( const char *fname, int algo )
3499 {
3500     FILE *fp;
3501     char buf[1024];
3502     size_t n;
3503     MD_HANDLE md;
3504
3505     if( !fname ) {
3506         fp = stdin;
3507 #ifdef HAVE_DOSISH_SYSTEM
3508         setmode ( fileno(fp) , O_BINARY );
3509 #endif
3510     }
3511     else {
3512         fp = fopen( fname, "rb" );
3513     }
3514     if( !fp ) {
3515         log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
3516         return;
3517     }
3518
3519     md = md_open( 0, 0 );
3520     if( algo )
3521         md_enable( md, algo );
3522     else {
3523         md_enable( md, DIGEST_ALGO_MD5 );
3524         md_enable( md, DIGEST_ALGO_SHA1 );
3525         md_enable( md, DIGEST_ALGO_RMD160 );
3526 #ifdef USE_SHA256
3527         md_enable( md, DIGEST_ALGO_SHA256 );
3528 #endif
3529 #ifdef USE_SHA512
3530         md_enable( md, DIGEST_ALGO_SHA384 );
3531         md_enable( md, DIGEST_ALGO_SHA512 );
3532 #endif
3533     }
3534
3535     while( (n=fread( buf, 1, DIM(buf), fp )) )
3536         md_write( md, buf, n );
3537     if( ferror(fp) )
3538         log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
3539     else {
3540         md_final(md);
3541         if ( opt.with_colons ) {
3542             if ( algo ) 
3543                 print_hashline( md, algo, fname );
3544             else {
3545                 print_hashline( md, DIGEST_ALGO_MD5, fname );
3546                 print_hashline( md, DIGEST_ALGO_SHA1, fname );
3547                 print_hashline( md, DIGEST_ALGO_RMD160, fname );
3548 #ifdef USE_SHA256
3549                 print_hashline( md, DIGEST_ALGO_SHA256, fname );
3550 #endif
3551 #ifdef USE_SHA512
3552                 print_hashline( md, DIGEST_ALGO_SHA384, fname );
3553                 print_hashline( md, DIGEST_ALGO_SHA512, fname );
3554 #endif
3555             }
3556         }
3557         else {
3558             if( algo )
3559                print_hex(md,-algo,fname);
3560             else {
3561                 print_hex( md, DIGEST_ALGO_MD5, fname );
3562                 print_hex( md, DIGEST_ALGO_SHA1, fname );
3563                 print_hex( md, DIGEST_ALGO_RMD160, fname );
3564 #ifdef USE_SHA256
3565                 print_hex( md, DIGEST_ALGO_SHA256, fname );
3566 #endif
3567 #ifdef USE_SHA512
3568                 print_hex( md, DIGEST_ALGO_SHA384, fname );
3569                 print_hex( md, DIGEST_ALGO_SHA512, fname );
3570 #endif
3571             }
3572         }
3573     }
3574     md_close(md);
3575
3576     if( fp != stdin )
3577         fclose(fp);
3578 }
3579
3580
3581 /****************
3582  * Check the supplied name,value string and add it to the notation
3583  * data to be used for signatures.  which==0 for sig notations, and 1
3584  * for cert notations.
3585 */
3586 static void
3587 add_notation_data( const char *string, int which )
3588 {
3589     const char *s;
3590     STRLIST sl,*notation_data;
3591     int critical=0;
3592     int highbit=0;
3593     int saw_at=0;
3594
3595     if(which)
3596       notation_data=&opt.cert_notation_data;
3597     else
3598       notation_data=&opt.sig_notation_data;
3599
3600     if( *string == '!' ) {
3601         critical = 1;
3602         string++;
3603     }
3604
3605     /* If and when the IETF assigns some official name tags, we'll
3606        have to add them here. */
3607
3608     for( s=string ; *s != '='; s++ )
3609       {
3610         if( *s=='@')
3611           saw_at=1;
3612
3613         if( !*s || (*s & 0x80) || (!isgraph(*s) && !isspace(*s)) )
3614           {
3615             log_error(_("a notation name must have only printable characters "
3616                         "or spaces, and end with an '='\n") );
3617             return;
3618           }
3619       }
3620
3621     if(!saw_at && !opt.expert)
3622       {
3623         log_error(
3624                 _("a user notation name must contain the '@' character\n"));
3625         return;
3626       }
3627
3628     /* we only support printable text - therefore we enforce the use
3629      * of only printable characters (an empty value is valid) */
3630     for( s++; *s ; s++ ) {
3631         if ((*s & 0x80))
3632           highbit = 1;
3633         else if (iscntrl(*s)) {
3634             log_error(_("a notation value must not use "
3635                         "any control characters\n") );
3636             return;
3637         }
3638     }
3639
3640     if( highbit )   /* must use UTF8 encoding */
3641         sl = add_to_strlist2( notation_data, string, utf8_strings );
3642     else
3643         sl = add_to_strlist( notation_data, string );
3644
3645     if( critical )
3646         sl->flags |= 1;
3647 }
3648
3649 static void
3650 add_policy_url( const char *string, int which )
3651 {
3652   int i,critical=0;
3653   STRLIST sl;
3654
3655   if(*string=='!')
3656     {
3657       string++;
3658       critical=1;
3659     }
3660
3661   for(i=0;i<strlen(string);i++)
3662     if(string[i]&0x80 || iscntrl(string[i]))
3663       break;
3664
3665   if(i==0 || i<strlen(string))
3666     {
3667       if(which)
3668         log_error(_("the given certification policy URL is invalid\n"));
3669       else
3670         log_error(_("the given signature policy URL is invalid\n"));
3671     }
3672
3673   if(which)
3674     sl=add_to_strlist( &opt.cert_policy_url, string );
3675   else
3676     sl=add_to_strlist( &opt.sig_policy_url, string );
3677
3678   if(critical)
3679     sl->flags |= 1;    
3680 }
3681
3682 static void
3683 add_keyserver_url( const char *string, int which )
3684 {
3685   int i,critical=0;
3686   STRLIST sl;
3687
3688   if(*string=='!')
3689     {
3690       string++;
3691       critical=1;
3692     }
3693
3694   for(i=0;i<strlen(string);i++)
3695     if(string[i]&0x80 || iscntrl(string[i]))
3696       break;
3697
3698   if(i==0 || i<strlen(string))
3699     {
3700       if(which)
3701         BUG();
3702       else
3703         log_error(_("the given signature preferred"
3704                     " keyserver URL is invalid\n"));
3705     }
3706
3707   if(which)
3708     BUG();
3709   else
3710     sl=add_to_strlist( &opt.sig_keyserver_url, string );
3711
3712   if(critical)
3713     sl->flags |= 1;    
3714 }