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