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