Update head to match stable 1.0
[gnupg.git] / g10 / gpg.c
1 /* gpg.c - The GnuPG utility (main for gpg)
2  *      Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
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 #ifdef HAVE_DOSISH_SYSTEM
29   #include <fcntl.h> /* for setmode() */
30 #endif
31
32
33 #include <gcrypt.h>
34 #include "packet.h"
35 #include "iobuf.h"
36 #include "util.h"
37 #include "main.h"
38 #include "options.h"
39 #include "keydb.h"
40 #include "trustdb.h"
41 #include "filter.h"
42 #include "ttyio.h"
43 #include "i18n.h"
44 #include "status.h"
45 #include "gnupg-defs.h"
46 #include "hkp.h"
47
48
49 enum cmd_and_opt_values { aNull = 0,
50     oArmor        = 'a',
51     aDetachedSign = 'b',
52     aSym          = 'c',
53     aDecrypt      = 'd',
54     aEncr         = 'e',
55     oInteractive  = 'i',
56     oKOption      = 'k',
57     oDryRun       = 'n',
58     oOutput       = 'o',
59     oQuiet        = 'q',
60     oRecipient    = 'r',
61     aSign         = 's',
62     oTextmodeShort= 't',
63     oUser         = 'u',
64     oVerbose      = 'v',
65     oCompress     = 'z',
66     oNotation     = 'N',
67     oBatch        = 500,
68     aClearsign,
69     aStore,
70     aKeygen,
71     aSignEncr,
72     aSignKey,
73     aLSignKey,
74     aListPackets,
75     aEditKey,
76     aDeleteKey,
77     aDeleteSecretKey,
78     aKMode,
79     aKModeC,
80     aImport,
81     aFastImport,
82     aVerify,
83     aVerifyFiles,
84     aListKeys,
85     aListSigs,
86     aListSecretKeys,
87     aSendKeys,
88     aRecvKeys,
89     aExport,
90     aExportAll,
91     aExportSecret,
92     aExportSecretSub,
93     aCheckKeys,
94     aGenRevoke,
95     aPrimegen,
96     aPrintMD,
97     aPrintMDs,
98     aPrintHMAC,
99     aCheckTrustDB,
100     aUpdateTrustDB,
101     aFixTrustDB,
102     aListTrustDB,
103     aListTrustPath,
104     aExportOwnerTrust,
105     aImportOwnerTrust,
106     aDeArmor,
107     aEnArmor,
108     aGenRandom,
109
110     oTextmode,
111     oFingerprint,
112     oWithFingerprint,
113     oAnswerYes,
114     oAnswerNo,
115     oKeyring,
116     oSecretKeyring,
117     oDefaultKey,
118     oDefRecipient,
119     oDefRecipientSelf,
120     oNoDefRecipient,
121     oOptions,
122     oDebug,
123     oDebugAll,
124     oStatusFD,
125     oNoComment,
126     oNoVersion,
127     oEmitVersion,
128     oCompletesNeeded,
129     oMarginalsNeeded,
130     oMaxCertDepth,
131     oLoadExtension,
132     oRFC1991,
133     oOpenPGP,
134     oCipherAlgo,
135     oDigestAlgo,
136     oCompressAlgo,
137     oPasswdFD,
138     oCommandFD,
139     oNoVerbose,
140     oTrustDBName,
141     oNoSecmemWarn,
142     oNoArmor,
143     oNoDefKeyring,
144     oNoGreeting,
145     oNoTTY,
146     oNoOptions,
147     oNoBatch,
148     oHomedir,
149     oWithColons,
150     oWithKeyData,
151     oSkipVerify,
152     oCompressKeys,
153     oCompressSigs,
154     oAlwaysTrust,
155     oRunAsShmCP,
156     oSetFilename,
157     oSetPolicyURL,
158     oUseEmbeddedFilename,
159     oComment,
160     oDefaultComment,
161     oThrowKeyid,
162     oForceV3Sigs,
163     oForceMDC,
164     oS2KMode,
165     oS2KDigest,
166     oS2KCipher,
167     oCharset,
168     oNotDashEscaped,
169     oEscapeFrom,
170     oLockOnce,
171     oLockMultiple,
172     oLockNever,
173     oKeyServer,
174     oEncryptTo,
175     oNoEncryptTo,
176     oLoggerFD,
177     oUtf8Strings,
178     oNoUtf8Strings,
179     oDisableCipherAlgo,
180     oDisablePubkeyAlgo,
181     oAllowNonSelfsignedUID,
182     oAllowFreeformUID,
183     oNoLiteral,
184     oSetFilesize,
185     oHonorHttpProxy,
186     oFastListMode,
187     oListOnly,
188     oIgnoreTimeConflict,
189     oNoRandomSeedFile,
190     oNoAutoKeyRetrieve,
191     oUseAgent,
192     oMergeOnly,
193     oTryAllSecrets,
194     oTrustedKey,
195     oEmuMDEncodeBug,
196 aTest };
197
198
199 static ARGPARSE_OPTS opts[] = {
200
201     { 300, NULL, 0, N_("@Commands:\n ") },
202
203     { aSign, "sign",      256, N_("|[file]|make a signature")},
204     { aClearsign, "clearsign", 256, N_("|[file]|make a clear text signature") },
205     { aDetachedSign, "detach-sign", 256, N_("make a detached signature")},
206     { aEncr, "encrypt",   256, N_("encrypt data")},
207     { aSym, "symmetric", 256, N_("encryption only with symmetric cipher")},
208     { aStore, "store",     256, N_("store only")},
209     { aDecrypt, "decrypt",   256, N_("decrypt data (default)")},
210     { aVerify, "verify"   , 256, N_("verify a signature")},
211     { aVerifyFiles, "verify-files" , 256, "@" },
212     { aListKeys, "list-keys", 256, N_("list keys")},
213     { aListKeys, "list-public-keys", 256, "@" },
214     { aListSigs, "list-sigs", 256, N_("list keys and signatures")},
215     { aCheckKeys, "check-sigs",256, N_("check key signatures")},
216     { oFingerprint, "fingerprint", 256, N_("list keys and fingerprints")},
217     { aListSecretKeys, "list-secret-keys", 256, N_("list secret keys")},
218     { aKeygen,     "gen-key",  256, N_("generate a new key pair")},
219     { aDeleteKey, "delete-key",256, N_("remove key from the public keyring")},
220     { aDeleteSecretKey, "delete-secret-key",256,
221                                     N_("remove key from the secret keyring")},
222     { aSignKey,  "sign-key"   ,256, N_("sign a key")},
223     { aLSignKey, "lsign-key"  ,256, N_("sign a key locally")},
224     { aEditKey,  "edit-key"   ,256, N_("sign or edit a key")},
225     { aGenRevoke, "gen-revoke",256, N_("generate a revocation certificate")},
226     { aExport, "export"           , 256, N_("export keys") },
227     { aSendKeys, "send-keys"     , 256, N_("export keys to a key server") },
228     { aRecvKeys, "recv-keys"     , 256, N_("import keys from a key server") },
229     { aExportAll, "export-all"    , 256, "@" },
230     { aExportSecret, "export-secret-keys" , 256, "@" },
231     { aExportSecretSub, "export-secret-subkeys" , 256, "@" },
232     { aImport, "import",      256     , N_("import/merge keys")},
233     { aFastImport, "fast-import",  256 , "@"},
234     { aListPackets, "list-packets",256,N_("list only the sequence of packets")},
235     { aExportOwnerTrust,
236               "export-ownertrust", 256, N_("export the ownertrust values")},
237     { aImportOwnerTrust,
238               "import-ownertrust", 256 , N_("import ownertrust values")},
239     { aUpdateTrustDB,
240               "update-trustdb",0 , N_("update the trust database")},
241     { aCheckTrustDB,
242               "check-trustdb",0 , N_("|[NAMES]|check the trust database")},
243     { aFixTrustDB, "fix-trustdb",0 , N_("fix a corrupted trust database")},
244     { aDeArmor, "dearmor", 256, N_("De-Armor a file or stdin") },
245     { aDeArmor, "dearmour", 256, "@" },
246     { aEnArmor, "enarmor", 256, N_("En-Armor a file or stdin") },
247     { aEnArmor, "enarmour", 256, "@" },
248     { aPrintMD,  "print-md" , 256, N_("|algo [files]|print message digests")},
249     { aPrintHMAC,  "print-hmac" , 256, "@"},
250     { aPrimegen, "gen-prime" , 256, "@" },
251     { aGenRandom, "gen-random" , 256, "@" },
252
253     { 301, NULL, 0, N_("@\nOptions:\n ") },
254
255     { oArmor, "armor",     0, N_("create ascii armored output")},
256     { oArmor, "armour",     0, "@" },
257     { oRecipient, "recipient", 2, N_("|NAME|encrypt for NAME")},
258     { oRecipient, "remote-user", 2, "@"},  /* old option name */
259     { oDefRecipient, "default-recipient" ,2,
260                                   N_("|NAME|use NAME as default recipient")},
261     { oDefRecipientSelf, "default-recipient-self" ,0,
262                                 N_("use the default key as default recipient")},
263     { oNoDefRecipient, "no-default-recipient", 0, "@" },
264     { oEncryptTo, "encrypt-to", 2, "@" },
265     { oNoEncryptTo, "no-encrypt-to", 0, "@" },
266     { oUser, "local-user",2, N_("use this user-id to sign or decrypt")},
267     { oCompress, NULL,        1, N_("|N|set compress level N (0 disables)") },
268     { oTextmodeShort, NULL,   0, "@"},
269     { oTextmode, "textmode",  0, N_("use canonical text mode")},
270     { oOutput, "output",    2, N_("use as output file")},
271     { oVerbose, "verbose",   0, N_("verbose") },
272     { oQuiet,   "quiet",   0, N_("be somewhat more quiet") },
273     { oNoTTY, "no-tty", 0, N_("don't use the terminal at all") },
274     { oForceV3Sigs, "force-v3-sigs", 0, N_("force v3 signatures") },
275     { oForceMDC, "force-mdc", 0, N_("always use a MDC for encryption") },
276     { oDryRun, "dry-run",   0, N_("do not make any changes") },
277   /*{ oInteractive, "interactive", 0, N_("prompt before overwriting") }, */
278     { oUseAgent, "use-agent",0, N_("use the gpg-agent")},
279     { oBatch, "batch",     0, N_("batch mode: never ask")},
280     { oAnswerYes, "yes",       0, N_("assume yes on most questions")},
281     { oAnswerNo,  "no",        0, N_("assume no on most questions")},
282     { oKeyring, "keyring"   ,2, N_("add this keyring to the list of keyrings")},
283     { oSecretKeyring, "secret-keyring" ,2, N_("add this secret keyring to the list")},
284     { oDefaultKey, "default-key" ,2, N_("|NAME|use NAME as default secret key")},
285     { oKeyServer, "keyserver",2, N_("|HOST|use this keyserver to lookup keys")},
286     { oCharset, "charset"   , 2, N_("|NAME|set terminal charset to NAME") },
287     { oOptions, "options"   , 2, N_("read options from file")},
288
289     { oDebug, "debug"     ,4|16, "@"},
290     { oDebugAll, "debug-all" ,0, "@"},
291     { oStatusFD, "status-fd" ,1, N_("|FD|write status info to this FD") },
292     { oNoComment, "no-comment", 0,   "@"},
293     { oCompletesNeeded, "completes-needed", 1, "@"},
294     { oMarginalsNeeded, "marginals-needed", 1, "@"},
295     { oMaxCertDepth,    "max-cert-depth", 1, "@" },
296     { oTrustedKey, "trusted-key", 2, N_("|KEYID|ulimately trust this key")},
297     { oLoadExtension, "load-extension" ,2, N_("|FILE|load extension module FILE")},
298     { oRFC1991, "rfc1991",   0, N_("emulate the mode described in RFC1991")},
299     { oOpenPGP, "openpgp", 0, N_("set all packet, cipher and digest options to OpenPGP behavior")},
300     { oS2KMode, "s2k-mode",  1, N_("|N|use passphrase mode N")},
301     { oS2KDigest, "s2k-digest-algo",2,
302                 N_("|NAME|use message digest algorithm NAME for passphrases")},
303     { oS2KCipher, "s2k-cipher-algo",2,
304                 N_("|NAME|use cipher algorithm NAME for passphrases")},
305     { oCipherAlgo, "cipher-algo", 2 , N_("|NAME|use cipher algorithm NAME")},
306     { oDigestAlgo, "digest-algo", 2 , N_("|NAME|use message digest algorithm NAME")},
307     { oCompressAlgo, "compress-algo", 1 , N_("|N|use compress algorithm N")},
308     { oThrowKeyid, "throw-keyid", 0, N_("throw keyid field of encrypted packets")},
309     { oNotation,   "notation-data", 2, N_("|NAME=VALUE|use this notation data")},
310
311     { 302, NULL, 0, N_(
312   "@\n(See the man page for a complete listing of all commands and options)\n"
313                       )},
314
315     { 303, NULL, 0, N_("@\nExamples:\n\n"
316     " -se -r Bob [file]          sign and encrypt for user Bob\n"
317     " --clearsign [file]         make a clear text signature\n"
318     " --detach-sign [file]       make a detached signature\n"
319     " --list-keys [names]        show keys\n"
320     " --fingerprint [names]      show fingerprints\n"  ) },
321
322   /* hidden options */
323     { aExportOwnerTrust, "list-ownertrust",0 , "@"},  /* alias */
324     { aPrintMDs, "print-mds" , 256, "@"}, /* old */
325     { aListTrustDB, "list-trustdb",0 , "@"},
326     { aListTrustPath, "list-trust-path",0, "@"},
327     { oKOption, NULL,    0, "@"},
328     { oPasswdFD, "passphrase-fd",1, "@" },
329     { oCommandFD, "command-fd",1, "@" },
330     { oNoVerbose, "no-verbose", 0, "@"},
331     { oTrustDBName, "trustdb-name", 2, "@" },
332     { oNoSecmemWarn, "no-secmem-warning", 0, "@" }, /* used only by regression tests */
333     { oNoArmor, "no-armor",   0, "@"},
334     { oNoArmor, "no-armour",   0, "@"},
335     { oNoDefKeyring, "no-default-keyring", 0, "@" },
336     { oNoGreeting, "no-greeting", 0, "@" },
337     { oNoOptions, "no-options", 0, "@" }, /* shortcut for --options /dev/null */
338     { oHomedir, "homedir", 2, "@" },   /* defaults to "~/.gnupg" */
339     { oNoBatch, "no-batch", 0, "@" },
340     { oWithColons, "with-colons", 0, "@"},
341     { oWithKeyData,"with-key-data", 0, "@"},
342     { aListKeys, "list-key", 0, "@" }, /* alias */
343     { aListSigs, "list-sig", 0, "@" }, /* alias */
344     { aCheckKeys, "check-sig",0, "@" }, /* alias */
345     { oSkipVerify, "skip-verify",0, "@" },
346     { oCompressKeys, "compress-keys",0, "@"},
347     { oCompressSigs, "compress-sigs",0, "@"},
348     { oAlwaysTrust, "always-trust", 0, "@"},
349     { oRunAsShmCP, "run-as-shm-coprocess", 4, "@" },
350     { oSetFilename, "set-filename", 2, "@" },
351     { oSetPolicyURL, "set-policy-url", 2, "@" },
352     { oComment, "comment", 2, "@" },
353     { oDefaultComment, "default-comment", 0, "@" },
354     { oNoVersion, "no-version", 0, "@"},
355     { oEmitVersion, "emit-version", 0, "@"},
356     { oNotDashEscaped, "not-dash-escaped", 0, "@" },
357     { oEscapeFrom, "escape-from-lines", 0, "@" },
358     { oLockOnce, "lock-once", 0, "@" },
359     { oLockMultiple, "lock-multiple", 0, "@" },
360     { oLockNever, "lock-never", 0, "@" },
361     { oLoggerFD, "logger-fd",1, "@" },
362     { oUseEmbeddedFilename, "use-embedded-filename", 0, "@" },
363     { oUtf8Strings, "utf8-strings", 0, "@" },
364     { oNoUtf8Strings, "no-utf8-strings", 0, "@" },
365     { oWithFingerprint, "with-fingerprint", 0, "@" },
366     { oDisableCipherAlgo,  "disable-cipher-algo", 2, "@" },
367     { oDisablePubkeyAlgo,  "disable-pubkey-algo", 2, "@" },
368     { oAllowNonSelfsignedUID, "allow-non-selfsigned-uid", 0, "@" },
369     { oAllowFreeformUID, "allow-freeform-uid", 0, "@" },
370     { oNoLiteral, "no-literal", 0, "@" },
371     { oSetFilesize, "set-filesize", 20, "@" },
372     { oHonorHttpProxy,"honor-http-proxy", 0, "@" },
373     { oFastListMode,"fast-list-mode", 0, "@" },
374     { oListOnly, "list-only", 0, "@"},
375     { oIgnoreTimeConflict, "ignore-time-conflict", 0, "@" },
376     { oNoRandomSeedFile,  "no-random-seed-file", 0, "@" },
377     { oNoAutoKeyRetrieve, "no-auto-key-retrieve", 0, "@" },
378     { oMergeOnly,         "merge-only", 0, "@" },
379     { oTryAllSecrets,  "try-all-secrets", 0, "@" },
380     { oEmuMDEncodeBug,  "emulate-md-encode-bug", 0, "@"},
381 {0} };
382
383
384
385 int gpg_errors_seen = 0;
386
387 static int utf8_strings = 0;
388 static int maybe_setuid = 1;
389
390 static char *build_list( const char *text,
391                          const char *(*mapf)(int), int (*chkf)(int) );
392 static void set_cmd( enum cmd_and_opt_values *ret_cmd,
393                         enum cmd_and_opt_values new_cmd );
394 static void print_hex( byte *p, size_t n );
395 static void print_mds( const char *fname, int algo, const char *key );
396 static void add_notation_data( const char *string );
397 static int  check_policy_url( const char *s );
398
399
400 static int
401 our_pk_test_algo( int algo )
402 {
403     return openpgp_pk_test_algo( algo, 0 );
404 }
405
406 static const char *
407 my_strusage( int level )
408 {
409   static char *digests, *pubkeys, *ciphers;
410     const char *p;
411     switch( level ) {
412       case 11: p = "gpg (GnuPG)";
413         break;
414       case 13: p = VERSION; break;
415       case 17: p = PRINTABLE_OS_NAME; break;
416       case 19: p =
417             _("Please report bugs to <gnupg-bugs@gnu.org>.\n");
418         break;
419       case 1:
420       case 40:  p =
421             _("Usage: gpg [options] [files] (-h for help)");
422         break;
423       case 41:  p =
424             _("Syntax: gpg [options] [files]\n"
425               "sign, check, encrypt or decrypt\n"
426               "default operation depends on the input data\n");
427         break;
428
429       case 31: p = "\nHome: "; break;
430       case 32: p = opt.homedir; break;
431       case 33: p = _("\nSupported algorithms:\n"); break;
432       case 34:
433         if( !ciphers )
434             ciphers = build_list("Cipher: ", gcry_cipher_algo_name,
435                                              openpgp_cipher_test_algo );
436         p = ciphers;
437         break;
438       case 35:
439         if( !pubkeys )
440             pubkeys = build_list("Pubkey: ", gcry_pk_algo_name,
441                                              our_pk_test_algo );
442         p = pubkeys;
443         break;
444       case 36:
445         if( !digests )
446             digests = build_list("Hash: ", gcry_md_algo_name,
447                                            openpgp_md_test_algo );
448         p = digests;
449         break;
450
451
452       default:  p = NULL;
453     }
454     return p;
455 }
456
457
458 static char *
459 build_list( const char *text, const char * (*mapf)(int), int (*chkf)(int) )
460 {
461     int i;
462     size_t n=strlen(text)+2;
463     char *list, *p;
464
465     if( maybe_setuid ) {
466         gcry_control( GCRYCTL_DROP_PRIVS ); /* drop setuid */
467     }
468
469     for(i=1; i < 110; i++ )
470         if( !chkf(i) )
471             n += strlen(mapf(i)) + 2;
472     list = gcry_xmalloc( 21 + n ); *list = 0;
473     for(p=NULL, i=1; i < 110; i++ ) {
474         if( !chkf(i) ) {
475             if( !p )
476                 p = stpcpy( list, text );
477             else
478                 p = stpcpy( p, ", ");
479             p = stpcpy(p, mapf(i) );
480         }
481     }
482     if( p )
483         p = stpcpy(p, "\n" );
484     return list;
485 }
486
487
488 static void
489 i18n_init(void)
490 {
491   #ifdef USE_SIMPLE_GETTEXT
492     set_gettext_file( PACKAGE );
493   #else
494   #ifdef ENABLE_NLS
495     #ifdef HAVE_LC_MESSAGES
496        setlocale( LC_TIME, "" );
497        setlocale( LC_MESSAGES, "" );
498     #else
499        setlocale( LC_ALL, "" );
500     #endif
501     bindtextdomain( PACKAGE, GNUPG_LOCALEDIR );
502     textdomain( PACKAGE );
503   #endif
504   #endif
505 }
506
507
508 static void
509 register_extension( const char *mainpgm, const char *fname )
510 {
511   #warning fixme add register cipher extension
512     /* Before we do so, we should design a beter API for this.
513      * I am currently thinking about using S-Exp to pass everything we 
514      * need from the module to gcrypt. I hope we are not going to 
515      * implement my-own-lisp-library-no-17000 */
516   #if 0
517     if( *fname != '/' ) { /* do tilde expansion etc */
518         char *tmp;
519
520         if( strchr(fname, '/') )
521             tmp = make_filename(fname, NULL);
522         else
523             tmp = make_filename(GNUPG_LIBDIR, fname, NULL);
524         register_cipher_extension( mainpgm, tmp );
525         gcry_free(tmp);
526     }
527     else
528         register_cipher_extension( mainpgm, fname );
529   #endif
530 }
531
532
533
534 static void
535 wrong_args( const char *text)
536 {
537     fputs(_("usage: gpg [options] "),stderr);
538     fputs(text,stderr);
539     putc('\n',stderr);
540     gpg_exit(2);
541 }
542
543
544 static char *
545 make_username( const char *string )
546 {
547     char *p;
548     if( utf8_strings )
549         p = gcry_xstrdup(string);
550     else
551         p = native_to_utf8( string );
552     return p;
553 }
554
555
556 static void
557 set_debug(void)
558 {
559   #if 0
560     #warning memory debugging not enabled
561     if( opt.debug & DBG_MEMORY_VALUE )
562         memory_debug_mode = 1;
563     if( opt.debug & DBG_MEMSTAT_VALUE )
564         memory_stat_debug_mode = 1;
565   #endif
566
567     if( opt.debug & DBG_MPI_VALUE )
568         gcry_control( GCRYCTL_SET_DEBUG_FLAGS, 2 );
569     if( opt.debug & DBG_CIPHER_VALUE )
570         gcry_control( GCRYCTL_SET_DEBUG_FLAGS, 1 );
571
572     if( opt.debug & DBG_IOBUF_VALUE )
573         iobuf_debug_mode = 1;
574
575 }
576
577
578 static void
579 set_cmd( enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd )
580 {
581     enum cmd_and_opt_values cmd = *ret_cmd;
582
583     if( !cmd || cmd == new_cmd )
584         cmd = new_cmd;
585     else if( cmd == aSign && new_cmd == aEncr )
586         cmd = aSignEncr;
587     else if( cmd == aEncr && new_cmd == aSign )
588         cmd = aSignEncr;
589     else if( cmd == aKMode && new_cmd == aSym )
590         cmd = aKModeC;
591     else if(    ( cmd == aSign     && new_cmd == aClearsign )
592              || ( cmd == aClearsign && new_cmd == aSign )  )
593         cmd = aClearsign;
594     else {
595         log_error(_("conflicting commands\n"));
596         gpg_exit(2);
597     }
598
599     *ret_cmd = cmd;
600 }
601
602
603
604 int
605 main( int argc, char **argv )
606 {
607     ARGPARSE_ARGS pargs;
608     IOBUF a;
609     int rc=0;
610     int orig_argc;
611     char **orig_argv;
612     const char *fname;
613     char *username;
614     int may_coredump;
615     STRLIST sl, remusr= NULL, locusr=NULL;
616     STRLIST nrings=NULL, sec_nrings=NULL;
617     armor_filter_context_t afx;
618     int detached_sig = 0;
619     FILE *configfp = NULL;
620     char *configname = NULL;
621     unsigned configlineno;
622     int parse_debug = 0;
623     int default_config =1;
624     int default_keyring = 1;
625     int greeting = 0;
626     int nogreeting = 0;
627     int use_random_seed = 1;
628     enum cmd_and_opt_values cmd = 0;
629     const char *trustdb_name = NULL;
630     char *def_cipher_string = NULL;
631     char *def_digest_string = NULL;
632     char *s2k_cipher_string = NULL;
633     char *s2k_digest_string = NULL;
634     int pwfd = -1;
635     int with_fpr = 0; /* make an option out of --fingerprint */
636   #ifdef USE_SHM_COPROCESSING
637     ulong requested_shm_size=0;
638   #endif
639
640     trap_unaligned();
641     set_strusage( my_strusage );
642     gcry_control( GCRYCTL_SUSPEND_SECMEM_WARN );
643     /* Please note that we may running SUID(ROOT), so be very CAREFUL
644      * when adding any stuff between here and the call to
645      * secmem_init()  somewhere after the option parsing
646      */
647     log_set_name("gpg");
648     /* check that the libraries are suitable.  Do it here because
649      * the option parse may need services of the library */
650     if ( !gcry_check_version ( "1.1.0a" ) ) {
651         log_fatal(_("libgcrypt is too old (need %s, have %s)\n"),
652                                 VERSION, gcry_check_version(NULL) );
653     }
654
655     gcry_control( GCRYCTL_USE_SECURE_RNDPOOL );
656     may_coredump = disable_core_dumps();
657     init_signals();
658     create_dotlock(NULL); /* register locking cleanup */
659     i18n_init();
660     opt.command_fd = -1; /* no command fd */
661     opt.compress = -1; /* defaults to standard compress level */
662     /* note: if you change these lines, look at oOpenPGP */
663     opt.def_cipher_algo = 0;
664     opt.def_digest_algo = 0;
665     opt.def_compress_algo = 2;
666     opt.s2k_mode = 3; /* iterated+salted */
667     opt.s2k_digest_algo = GCRY_MD_SHA1;
668     opt.s2k_cipher_algo = GCRY_CIPHER_CAST5;
669     opt.completes_needed = 1;
670     opt.marginals_needed = 3;
671     opt.max_cert_depth = 5;
672     opt.pgp2_workarounds = 1;
673     opt.auto_key_retrieve = 1;
674   #ifdef __MINGW32__
675     opt.homedir = read_w32_registry_string( NULL, "Software\\GNU\\GnuPG", "HomeDir" );
676   #else
677     opt.homedir = getenv("GNUPGHOME");
678   #endif
679     if( !opt.homedir || !*opt.homedir ) {
680         opt.homedir = GNUPG_HOMEDIR;
681     }
682
683     /* check whether we have a config file on the commandline */
684     orig_argc = argc;
685     orig_argv = argv;
686     pargs.argc = &argc;
687     pargs.argv = &argv;
688     pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
689     while( arg_parse( &pargs, opts) ) {
690         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
691             parse_debug++;
692         else if( pargs.r_opt == oOptions ) {
693             /* yes there is one, so we do not try the default one, but
694              * read the option file when it is encountered at the commandline
695              */
696             default_config = 0;
697         }
698         else if( pargs.r_opt == oNoOptions )
699             default_config = 0; /* --no-options */
700         else if( pargs.r_opt == oHomedir )
701             opt.homedir = pargs.r.ret_str;
702       #ifdef USE_SHM_COPROCESSING
703         else if( pargs.r_opt == oRunAsShmCP ) {
704             /* does not make sense in a options file, we do it here,
705              * so that we are the able to drop setuid as soon as possible */
706             opt.shm_coprocess = 1;
707             requested_shm_size = pargs.r.ret_ulong;
708         }
709         else if ( pargs.r_opt == oStatusFD ) {
710             /* this is needed to ensure that the status-fd filedescriptor is
711              * initialized when init_shm_coprocessing() is called */
712             set_status_fd( pargs.r.ret_int );
713         }
714       #endif
715     }
716
717
718   #ifdef USE_SHM_COPROCESSING
719     if( opt.shm_coprocess ) {
720         init_shm_coprocessing(requested_shm_size, 1 );
721     }
722   #endif
723     /* initialize the secure memory. */
724     gcry_control( GCRYCTL_INIT_SECMEM, 16384, 0 );
725     maybe_setuid = 0;
726     /* Okay, we are now working under our real uid */
727
728     if( default_config )
729         configname = make_filename(opt.homedir, "options", NULL );
730
731     argc = orig_argc;
732     argv = orig_argv;
733     pargs.argc = &argc;
734     pargs.argv = &argv;
735     pargs.flags=  1;  /* do not remove the args */
736   next_pass:
737     if( configname ) {
738         configlineno = 0;
739         configfp = fopen( configname, "r" );
740         if( !configfp ) {
741             if( default_config ) {
742                 if( parse_debug )
743                     log_info(_("NOTE: no default option file `%s'\n"),
744                                                             configname );
745             }
746             else {
747                 log_error(_("option file `%s': %s\n"),
748                                     configname, strerror(errno) );
749                 gpg_exit(2);
750             }
751             gcry_free(configname); configname = NULL;
752         }
753         if( parse_debug && configname )
754             log_info(_("reading options from `%s'\n"), configname );
755         default_config = 0;
756     }
757
758     while( optfile_parse( configfp, configname, &configlineno,
759                                                 &pargs, opts) ) {
760         switch( pargs.r_opt ) {
761           case aCheckKeys: set_cmd( &cmd, aCheckKeys); break;
762           case aListPackets: set_cmd( &cmd, aListPackets); break;
763           case aImport: set_cmd( &cmd, aImport); break;
764           case aFastImport: set_cmd( &cmd, aFastImport); break;
765           case aSendKeys: set_cmd( &cmd, aSendKeys); break;
766           case aRecvKeys: set_cmd( &cmd, aRecvKeys); break;
767           case aExport: set_cmd( &cmd, aExport); break;
768           case aExportAll: set_cmd( &cmd, aExportAll); break;
769           case aListKeys: set_cmd( &cmd, aListKeys); break;
770           case aListSigs: set_cmd( &cmd, aListSigs); break;
771           case aExportSecret: set_cmd( &cmd, aExportSecret); break;
772           case aExportSecretSub: set_cmd( &cmd, aExportSecretSub); break;
773           case aDeleteSecretKey: set_cmd( &cmd, aDeleteSecretKey);
774                                                         greeting=1; break;
775           case aDeleteKey: set_cmd( &cmd, aDeleteKey); greeting=1; break;
776
777           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
778           case aSym: set_cmd( &cmd, aSym); break;
779
780           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
781
782           case aEncr: set_cmd( &cmd, aEncr); break;
783           case aSign: set_cmd( &cmd, aSign );  break;
784           case aKeygen: set_cmd( &cmd, aKeygen); greeting=1; break;
785           case aSignKey: set_cmd( &cmd, aSignKey); break;
786           case aLSignKey: set_cmd( &cmd, aLSignKey); break;
787           case aStore: set_cmd( &cmd, aStore); break;
788           case aEditKey: set_cmd( &cmd, aEditKey); greeting=1; break;
789           case aClearsign: set_cmd( &cmd, aClearsign); break;
790           case aGenRevoke: set_cmd( &cmd, aGenRevoke); break;
791           case aVerify: set_cmd( &cmd, aVerify); break;
792           case aVerifyFiles: set_cmd( &cmd, aVerifyFiles); break;
793           case aPrimegen: set_cmd( &cmd, aPrimegen); break;
794           case aGenRandom: set_cmd( &cmd, aGenRandom); break;
795           case aPrintMD: set_cmd( &cmd, aPrintMD); break;
796           case aPrintMDs: set_cmd( &cmd, aPrintMDs); break;
797           case aPrintHMAC: set_cmd( &cmd, aPrintHMAC); break;
798           case aListTrustDB: set_cmd( &cmd, aListTrustDB); break;
799           case aCheckTrustDB: set_cmd( &cmd, aCheckTrustDB); break;
800           case aUpdateTrustDB: set_cmd( &cmd, aUpdateTrustDB); break;
801           case aFixTrustDB: set_cmd( &cmd, aFixTrustDB); break;
802           case aListTrustPath: set_cmd( &cmd, aListTrustPath); break;
803           case aDeArmor: set_cmd( &cmd, aDeArmor); break;
804           case aEnArmor: set_cmd( &cmd, aEnArmor); break;
805           case aExportOwnerTrust: set_cmd( &cmd, aExportOwnerTrust); break;
806           case aImportOwnerTrust: set_cmd( &cmd, aImportOwnerTrust); break;
807
808           case oArmor: opt.armor = 1; opt.no_armor=0; break;
809           case oOutput: opt.outfile = pargs.r.ret_str; break;
810           case oQuiet: opt.quiet = 1; break;
811           case oNoTTY: tty_no_terminal(1); break;
812           case oDryRun: opt.dry_run = 1; break;
813           case oInteractive: opt.interactive = 1; break;
814           case oVerbose:
815                 opt.verbose++; opt.list_sigs=1;
816                 gcry_control( GCRYCTL_SET_VERBOSITY, (int)opt.verbose );
817                 break;
818           case oKOption: set_cmd( &cmd, aKMode ); break;
819
820           case oBatch: opt.batch = 1; greeting = 0; break;
821           case oUseAgent: opt.use_agent = 1; break;
822           case oAnswerYes: opt.answer_yes = 1; break;
823           case oAnswerNo: opt.answer_no = 1; break;
824           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
825           case oDebug: opt.debug |= pargs.r.ret_ulong; break;
826           case oDebugAll: opt.debug = ~0; break;
827           case oStatusFD: set_status_fd( pargs.r.ret_int ); break;
828           case oLoggerFD: log_set_logfile( NULL, pargs.r.ret_int ); break;
829           case oWithFingerprint:
830                 with_fpr=1; /*fall thru*/
831           case oFingerprint: opt.fingerprint++; break;
832           case oSecretKeyring: append_to_strlist( &sec_nrings, pargs.r.ret_str); break;
833           case oOptions:
834             /* config files may not be nested (silently ignore them) */
835             if( !configfp ) {
836                 gcry_free(configname);
837                 configname = gcry_xstrdup(pargs.r.ret_str);
838                 goto next_pass;
839             }
840             break;
841           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
842           case oNoDefKeyring: default_keyring = 0; break;
843           case oNoGreeting: nogreeting = 1; break;
844           case oNoVerbose:
845                 opt.verbose = 0; opt.list_sigs=0;
846                 gcry_control( GCRYCTL_SET_VERBOSITY, (int)opt.verbose );
847                 break;
848           case oNoComment: opt.no_comment=1; break;
849           case oNoVersion: opt.no_version=1; break;
850           case oEmitVersion: opt.no_version=0; break;
851           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
852           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
853           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
854           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
855           case oDefaultKey: opt.def_secret_key = pargs.r.ret_str; break;
856           case oDefRecipient:
857                     if( *pargs.r.ret_str )
858                         opt.def_recipient = make_username(pargs.r.ret_str);
859                     break;
860           case oDefRecipientSelf:
861                     gcry_free(opt.def_recipient); opt.def_recipient = NULL;
862                     opt.def_recipient_self = 1;
863                     break;
864           case oNoDefRecipient:
865                     gcry_free(opt.def_recipient); opt.def_recipient = NULL;
866                     opt.def_recipient_self = 0;
867                     break;
868           case oNoOptions: break; /* no-options */
869           case oHomedir: opt.homedir = pargs.r.ret_str; break;
870           case oNoBatch: opt.batch = 0; break;
871           case oWithKeyData: opt.with_key_data=1; /* fall thru */
872           case oWithColons: opt.with_colons=':'; break;
873
874           case oSkipVerify: opt.skip_verify=1; break;
875           case oCompressAlgo: opt.def_compress_algo = pargs.r.ret_int; break;
876           case oCompressKeys: opt.compress_keys = 1; break;
877           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
878           case oAlwaysTrust: opt.always_trust = 1; break;
879           case oLoadExtension:
880             register_extension(orig_argc? *orig_argv:NULL, pargs.r.ret_str);
881             break;
882           case oRFC1991:
883             opt.rfc1991 = 1;
884             opt.rfc2440 = 0;
885             opt.no_comment = 1;
886             opt.escape_from = 1;
887             break;
888           case oOpenPGP:
889             opt.rfc1991 = 0;
890             opt.rfc2440 = 1;
891             opt.pgp2_workarounds = 0;
892             opt.escape_from = 0;
893             opt.force_v3_sigs = 0;
894             opt.compress_keys = 0;          /* not mandated  but we do it */
895             opt.compress_sigs = 0;          /* ditto. */
896             opt.not_dash_escaped = 0;
897             opt.def_cipher_algo = 0;
898             opt.def_digest_algo = 0;
899             opt.def_compress_algo = 1;
900             opt.s2k_mode = 3; /* iterated+salted */
901             opt.s2k_digest_algo = GCRY_MD_SHA1;
902             opt.s2k_cipher_algo = GCRY_CIPHER_CAST5;
903             break;
904           case oEmuMDEncodeBug: opt.emulate_bugs |= EMUBUG_MDENCODE; break;
905           case oCompressSigs: opt.compress_sigs = 1; break;
906           case oRunAsShmCP:
907           #ifndef USE_SHM_COPROCESSING
908             /* not possible in the option file,
909              * but we print the warning here anyway */
910             log_error("shared memory coprocessing is not available\n");
911           #endif
912             break;
913           case oSetFilename: opt.set_filename = pargs.r.ret_str; break;
914           case oSetPolicyURL: opt.set_policy_url = pargs.r.ret_str; break;
915           case oUseEmbeddedFilename: opt.use_embedded_filename = 1; break;
916           case oComment: opt.comment_string = pargs.r.ret_str; break;
917           case oDefaultComment: opt.comment_string = NULL; break;
918           case oThrowKeyid: opt.throw_keyid = 1; break;
919           case oForceV3Sigs: opt.force_v3_sigs = 1; break;
920           case oForceMDC: opt.force_mdc = 1; break;
921           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
922           case oS2KDigest: s2k_digest_string = gcry_xstrdup(pargs.r.ret_str); break;
923           case oS2KCipher: s2k_cipher_string = gcry_xstrdup(pargs.r.ret_str); break;
924
925           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
926           case oEncryptTo: /* store the recipient in the second list */
927             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
928             sl->flags = 1;
929             break;
930           case oRecipient: /* store the recipient */
931             add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
932             break;
933           case oTextmodeShort: opt.textmode = 2; break;
934           case oTextmode: opt.textmode=1;  break;
935           case oUser: /* store the local users */
936             add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
937             break;
938           case oCompress: opt.compress = pargs.r.ret_int; break;
939           case oPasswdFD: pwfd = pargs.r.ret_int; break;
940           case oCommandFD: opt.command_fd = pargs.r.ret_int; break;
941           case oCipherAlgo: def_cipher_string = gcry_xstrdup(pargs.r.ret_str); break;
942           case oDigestAlgo: def_digest_string = gcry_xstrdup(pargs.r.ret_str); break;
943           case oNoSecmemWarn: gcry_control( GCRYCTL_DISABLE_SECMEM_WARN ); break;
944           case oCharset:
945             if( set_native_charset( pargs.r.ret_str ) )
946                 log_error(_("%s is not a valid character set\n"),
947                                                     pargs.r.ret_str);
948             break;
949           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
950           case oEscapeFrom: opt.escape_from = 1; break;
951           case oLockOnce: opt.lock_once = 1; break;
952           #if 0
953           #warning no disable_dotlock() yet
954           case oLockNever: disable_dotlock(); break;
955           #endif
956           case oLockMultiple: opt.lock_once = 0; break;
957           case oKeyServer: opt.keyserver_name = pargs.r.ret_str; break;
958           case oNotation: add_notation_data( pargs.r.ret_str ); break;
959           case oUtf8Strings: utf8_strings = 1; break;
960           case oNoUtf8Strings: utf8_strings = 0; break;
961           case oDisableCipherAlgo: {
962                     int algo = gcry_cipher_map_name(pargs.r.ret_str);
963                     gcry_cipher_ctl( NULL, GCRYCTL_DISABLE_ALGO,
964                                              &algo, sizeof algo );
965                 }
966                 break;
967           case oDisablePubkeyAlgo: {
968                     int algo = gcry_pk_map_name(pargs.r.ret_str);
969                     gcry_pk_ctl( GCRYCTL_DISABLE_ALGO,
970                                        &algo, sizeof algo );
971                 }
972                 break;
973           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
974           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
975           case oNoLiteral: opt.no_literal = 1; break;
976           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
977           case oHonorHttpProxy: opt.honor_http_proxy = 1; break;
978           case oFastListMode: opt.fast_list_mode = 1; break;
979           case oListOnly: opt.list_only=1; break;
980           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
981           case oNoRandomSeedFile: use_random_seed = 0; break;
982           case oNoAutoKeyRetrieve: opt.auto_key_retrieve = 0; break;
983           case oMergeOnly: opt.merge_only = 1; break;
984           case oTryAllSecrets: opt.try_all_secrets = 1; break;
985           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
986
987           default : pargs.err = configfp? 1:2; break;
988         }
989     }
990     if( configfp ) {
991         fclose( configfp );
992         configfp = NULL;
993         gcry_free(configname); configname = NULL;
994         goto next_pass;
995     }
996     gcry_free( configname ); configname = NULL;
997     if( log_get_errorcount(0) )
998         gpg_exit(2);
999     if( nogreeting )
1000         greeting = 0;
1001
1002     if( greeting ) {
1003         fprintf(stderr, "%s %s; %s\n",
1004                         strusage(11), strusage(13), strusage(14) );
1005         fprintf(stderr, "%s\n", strusage(15) );
1006     }
1007   #ifdef IS_DEVELOPMENT_VERSION
1008     if( !opt.batch ) {
1009         log_info("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
1010         log_info("It is only intended for test purposes and should NOT be\n");
1011         log_info("used in a production environment or with production keys!\n");
1012     }
1013   #endif
1014
1015     if( may_coredump && !opt.quiet )
1016         log_info(_("WARNING: program may create a core file!\n"));
1017
1018     if (opt.no_literal) {
1019         log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
1020         if (opt.textmode)
1021             log_error(_("%s not allowed with %s!\n"),
1022                        "--textmode", "--no-literal" );
1023         if (opt.set_filename)
1024             log_error(_("%s makes no sense with %s!\n"),
1025                         "--set-filename", "--no-literal" );
1026     }
1027     if (opt.set_filesize)
1028         log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
1029     if( opt.batch )
1030         tty_batchmode( 1 );
1031
1032     gcry_control( GCRYCTL_RESUME_SECMEM_WARN );
1033
1034     set_debug();
1035     /* FIXME: should set filenames of libgcrypt explicitly
1036      * gpg_opt_homedir = opt.homedir; */
1037
1038     /* must do this after dropping setuid, because string_to...
1039      * may try to load an module */
1040     if( def_cipher_string ) {
1041         opt.def_cipher_algo = gcry_cipher_map_name(def_cipher_string);
1042         gcry_free(def_cipher_string); def_cipher_string = NULL;
1043         if( openpgp_cipher_test_algo(opt.def_cipher_algo) )
1044             log_error(_("selected cipher algorithm is invalid\n"));
1045     }
1046     if( def_digest_string ) {
1047         opt.def_digest_algo = gcry_md_map_name(def_digest_string);
1048         gcry_free(def_digest_string); def_digest_string = NULL;
1049         if( openpgp_md_test_algo(opt.def_digest_algo) )
1050             log_error(_("selected digest algorithm is invalid\n"));
1051     }
1052     if( s2k_cipher_string ) {
1053         opt.s2k_cipher_algo = gcry_cipher_map_name(s2k_cipher_string);
1054         gcry_free(s2k_cipher_string); s2k_cipher_string = NULL;
1055         if( openpgp_cipher_test_algo(opt.s2k_cipher_algo) )
1056             log_error(_("selected cipher algorithm is invalid\n"));
1057     }
1058     if( s2k_digest_string ) {
1059         opt.s2k_digest_algo = gcry_md_map_name(s2k_digest_string);
1060         gcry_free(s2k_digest_string); s2k_digest_string = NULL;
1061         if( openpgp_md_test_algo(opt.s2k_digest_algo) )
1062             log_error(_("selected digest algorithm is invalid\n"));
1063     }
1064     if( opt.set_policy_url ) {
1065         if( check_policy_url( opt.set_policy_url ) )
1066             log_error(_("the given policy URL is invalid\n"));
1067     }
1068     if( opt.def_compress_algo < 1 || opt.def_compress_algo > 2 )
1069         log_error(_("compress algorithm must be in range %d..%d\n"), 1, 2);
1070     if( opt.completes_needed < 1 )
1071         log_error(_("completes-needed must be greater than 0\n"));
1072     if( opt.marginals_needed < 2 )
1073         log_error(_("marginals-needed must be greater than 1\n"));
1074     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
1075         log_error(_("max-cert-depth must be in range 1 to 255\n"));
1076     switch( opt.s2k_mode ) {
1077       case 0:
1078         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
1079         break;
1080       case 1: case 3: break;
1081       default:
1082         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
1083     }
1084
1085
1086     if( log_get_errorcount(0) )
1087         gpg_exit(2);
1088
1089     /* set the random seed file */
1090     if( use_random_seed ) {
1091         char *p = make_filename(opt.homedir, "random_seed", NULL );
1092         #if 0
1093         #warning set_random_seed_file missing
1094         set_random_seed_file(p);
1095         #endif
1096         gcry_free(p);
1097     }
1098
1099     if( !cmd && opt.fingerprint && !with_fpr ) {
1100         set_cmd( &cmd, aListKeys);
1101     }
1102
1103     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
1104         if( cmd == aKModeC ) {
1105             opt.fingerprint = 1;
1106             cmd = aKMode;
1107         }
1108         opt.list_sigs = 0;
1109         if( opt.verbose > 2 )
1110             opt.check_sigs++;
1111         if( opt.verbose > 1 )
1112             opt.list_sigs++;
1113
1114         opt.verbose = opt.verbose > 1;
1115         gcry_control( GCRYCTL_SET_VERBOSITY, (int)opt.verbose );
1116     }
1117
1118
1119     /* kludge to let -sat generate a clear text signature */
1120     if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
1121         cmd = aClearsign;
1122
1123     if( opt.verbose > 1 )
1124         set_packet_list_mode(1);
1125
1126     /* add the keyrings, but not for some special commands and
1127      * not in case of "-kvv userid keyring" */
1128     if( cmd != aDeArmor && cmd != aEnArmor
1129         && !(cmd == aKMode && argc == 2 ) ) {
1130
1131         if( !sec_nrings && default_keyring )  /* add default secret rings */
1132             add_keyblock_resource("secring.gpg", 0, 1);
1133         for(sl = sec_nrings; sl; sl = sl->next )
1134             add_keyblock_resource( sl->d, 0, 1 );
1135         if( !nrings && default_keyring )  /* add default ring */
1136             add_keyblock_resource("pubring.gpg", 0, 0);
1137         for(sl = nrings; sl; sl = sl->next )
1138             add_keyblock_resource( sl->d, 0, 0 );
1139     }
1140     FREE_STRLIST(nrings);
1141     FREE_STRLIST(sec_nrings);
1142
1143
1144     if( pwfd != -1 )  /* read the passphrase now. */
1145         read_passphrase_from_fd( pwfd );
1146
1147     fname = argc? *argv : NULL;
1148
1149     switch( cmd ) {
1150       case aPrimegen:
1151       case aPrintMD:
1152       case aPrintMDs:
1153       case aPrintHMAC:
1154       case aGenRandom:
1155       case aDeArmor:
1156       case aEnArmor:
1157       case aFixTrustDB:
1158         break;
1159       case aKMode:
1160       case aListKeys:
1161       case aListSecretKeys:
1162       case aCheckKeys:
1163         if( opt.with_colons ) /* need this to list the trust */
1164             rc = setup_trustdb(1, trustdb_name );
1165         break;
1166       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
1167       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
1168       default: rc = setup_trustdb(1, trustdb_name ); break;
1169     }
1170     if( rc )
1171         log_error(_("failed to initialize the TrustDB: %s\n"), gpg_errstr(rc));
1172
1173
1174     switch( cmd ) {
1175       case aStore: /* only store the file */
1176         if( argc > 1 )
1177             wrong_args(_("--store [filename]"));
1178         if( (rc = encode_store(fname)) )
1179             log_error_f( print_fname_stdin(fname),
1180                         "store failed: %s\n", gpg_errstr(rc) );
1181         break;
1182       case aSym: /* encrypt the given file only with the symmetric cipher */
1183         if( argc > 1 )
1184             wrong_args(_("--symmetric [filename]"));
1185         if( (rc = encode_symmetric(fname)) )
1186             log_error_f(print_fname_stdin(fname),
1187                         "symmetric encryption failed: %s\n",gpg_errstr(rc) );
1188         break;
1189
1190       case aEncr: /* encrypt the given file */
1191         if( argc > 1 )
1192             wrong_args(_("--encrypt [filename]"));
1193         if( (rc = encode_crypt(fname,remusr)) )
1194             log_error("%s: encryption failed: %s\n", print_fname_stdin(fname), gpg_errstr(rc) );
1195         break;
1196
1197       case aSign: /* sign the given file */
1198         sl = NULL;
1199         if( detached_sig ) { /* sign all files */
1200             for( ; argc; argc--, argv++ )
1201                 add_to_strlist( &sl, *argv );
1202         }
1203         else {
1204             if( argc > 1 )
1205                 wrong_args(_("--sign [filename]"));
1206             if( argc ) {
1207                 sl = gcry_xcalloc( 1, sizeof *sl + strlen(fname));
1208                 strcpy(sl->d, fname);
1209             }
1210         }
1211         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
1212             log_error("signing failed: %s\n", gpg_errstr(rc) );
1213         free_strlist(sl);
1214         break;
1215
1216       case aSignEncr: /* sign and encrypt the given file */
1217         if( argc > 1 )
1218             wrong_args(_("--sign --encrypt [filename]"));
1219         if( argc ) {
1220             sl = gcry_xcalloc( 1, sizeof *sl + strlen(fname));
1221             strcpy(sl->d, fname);
1222         }
1223         else
1224             sl = NULL;
1225         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
1226             log_error("%s: sign+encrypt failed: %s\n", print_fname_stdin(fname), gpg_errstr(rc) );
1227         free_strlist(sl);
1228         break;
1229
1230       case aClearsign: /* make a clearsig */
1231         if( argc > 1 )
1232             wrong_args(_("--clearsign [filename]"));
1233         if( (rc = clearsign_file(fname, locusr, NULL)) )
1234             log_error("%s: clearsign failed: %s\n", print_fname_stdin(fname), gpg_errstr(rc) );
1235         break;
1236
1237       case aVerify:
1238         if( (rc = verify_signatures( argc, argv ) ))
1239             log_error("verify signatures failed: %s\n", gpg_errstr(rc) );
1240         break;
1241
1242       case aVerifyFiles:
1243         if( (rc = verify_files( argc, argv ) ))
1244             log_error("verify files failed: %s\n", gpg_errstr(rc) );
1245         break;
1246
1247       case aDecrypt:
1248         if( argc > 1 )
1249             wrong_args(_("--decrypt [filename]"));
1250         if( (rc = decrypt_message( fname ) ))
1251             log_error("decrypt_message failed: %s\n", gpg_errstr(rc) );
1252         break;
1253
1254
1255       case aSignKey: /* sign the key given as argument */
1256         if( argc != 1 )
1257             wrong_args(_("--sign-key user-id"));
1258         username = make_username( fname );
1259         keyedit_menu(fname, locusr, NULL, 1 );
1260         gcry_free(username);
1261         break;
1262
1263       case aLSignKey:
1264         if( argc != 1 )
1265             wrong_args(_("--lsign-key user-id"));
1266         username = make_username( fname );
1267         keyedit_menu(fname, locusr, NULL, 2 );
1268         gcry_free(username);
1269         break;
1270
1271       case aEditKey: /* Edit a key signature */
1272         if( !argc )
1273             wrong_args(_("--edit-key user-id [commands]"));
1274         username = make_username( fname );
1275         if( argc > 1 ) {
1276             sl = NULL;
1277             for( argc--, argv++ ; argc; argc--, argv++ )
1278                 append_to_strlist( &sl, *argv );
1279             keyedit_menu( username, locusr, sl, 0 );
1280             free_strlist(sl);
1281         }
1282         else
1283             keyedit_menu(username, locusr, NULL, 0 );
1284         gcry_free(username);
1285         break;
1286
1287       case aDeleteSecretKey:
1288         if( argc != 1 )
1289             wrong_args(_("--delete-secret-key user-id"));
1290       case aDeleteKey:
1291         if( argc != 1 )
1292             wrong_args(_("--delete-key user-id"));
1293         username = make_username( fname );
1294         if( (rc = delete_key(username, cmd==aDeleteSecretKey)) )
1295             log_error("%s: delete key failed: %s\n", username, gpg_errstr(rc) );
1296         gcry_free(username);
1297         break;
1298
1299
1300       case aCheckKeys:
1301         opt.check_sigs = 1;
1302       case aListSigs:
1303         opt.list_sigs = 1;
1304       case aListKeys:
1305         sl = NULL;
1306         for( ; argc; argc--, argv++ )
1307             add_to_strlist2( &sl, *argv, utf8_strings );
1308         public_key_list( sl );
1309         free_strlist(sl);
1310         break;
1311       case aListSecretKeys:
1312         sl = NULL;
1313         for( ; argc; argc--, argv++ )
1314             add_to_strlist2( &sl, *argv, utf8_strings );
1315         secret_key_list( sl );
1316         free_strlist(sl);
1317         break;
1318
1319       case aKMode: /* list keyring -- NOTE: This will be removed soon */
1320         if( argc < 2 ) { /* -kv [userid] */
1321             sl = NULL;
1322             if (argc && **argv)
1323                 add_to_strlist2( &sl, *argv, utf8_strings );
1324             public_key_list( sl );
1325             free_strlist(sl);
1326         }
1327         else if( argc == 2 ) { /* -kv userid keyring */
1328             if( access( argv[1], R_OK ) ) {
1329                 log_error(_("can't open %s: %s\n"),
1330                                print_fname_stdin(argv[1]), strerror(errno));
1331             }
1332             else {
1333                 /* add keyring (default keyrings are not registered in this
1334                  * special case */
1335                 add_keyblock_resource( argv[1], 0, 0 );
1336                 sl = NULL;
1337                 if (**argv)
1338                     add_to_strlist2( &sl, *argv, utf8_strings );
1339                 public_key_list( sl );
1340                 free_strlist(sl);
1341             }
1342         }
1343         else
1344             wrong_args(_("-k[v][v][v][c] [user-id] [keyring]") );
1345         break;
1346
1347       case aKeygen: /* generate a key */
1348         if( opt.batch ) {
1349             if( argc > 1 )
1350                 wrong_args("--gen-key [parameterfile]");
1351             generate_keypair( argc? *argv : NULL );
1352         }
1353         else {
1354             if( argc )
1355                 wrong_args("--gen-key");
1356             generate_keypair(NULL);
1357         }
1358         break;
1359
1360       case aFastImport:
1361       case aImport:
1362         import_keys( argc? argv:NULL, argc, (cmd == aFastImport) );
1363         break;
1364
1365       case aExport:
1366       case aExportAll:
1367       case aSendKeys:
1368       case aRecvKeys:
1369         sl = NULL;
1370         for( ; argc; argc--, argv++ )
1371             add_to_strlist2( &sl, *argv, utf8_strings );
1372         if( cmd == aSendKeys )
1373             hkp_export( sl );
1374         else if( cmd == aRecvKeys )
1375             hkp_import( sl );
1376         else
1377             export_pubkeys( sl, (cmd == aExport) );
1378         free_strlist(sl);
1379         break;
1380
1381       case aExportSecret:
1382         sl = NULL;
1383         for( ; argc; argc--, argv++ )
1384             add_to_strlist2( &sl, *argv, utf8_strings );
1385         export_seckeys( sl );
1386         free_strlist(sl);
1387         break;
1388
1389       case aExportSecretSub:
1390         sl = NULL;
1391         for( ; argc; argc--, argv++ )
1392             add_to_strlist2( &sl, *argv, utf8_strings );
1393         export_secsubkeys( sl );
1394         free_strlist(sl);
1395         break;
1396
1397       case aGenRevoke:
1398         if( argc != 1 )
1399             wrong_args("--gen-revoke user-id");
1400         username =  make_username(*argv);
1401         gen_revoke( username );
1402         gcry_free( username );
1403         break;
1404
1405       case aDeArmor:
1406         if( argc > 1 )
1407             wrong_args("--dearmor [file]");
1408         rc = dearmor_file( argc? *argv: NULL );
1409         if( rc )
1410             log_error(_("dearmoring failed: %s\n"), gpg_errstr(rc));
1411         break;
1412
1413       case aEnArmor:
1414         if( argc > 1 )
1415             wrong_args("--enarmor [file]");
1416         rc = enarmor_file( argc? *argv: NULL );
1417         if( rc )
1418             log_error(_("enarmoring failed: %s\n"), gpg_errstr(rc));
1419         break;
1420
1421
1422       case aPrimegen:
1423         { 
1424           #if 1
1425             log_error( "command is currently not implemented\n");
1426           #else
1427            /* FIXME: disabled until we have an API to create primes */
1428             int mode = argc < 2 ? 0 : atoi(*argv);
1429
1430             if( mode == 1 && argc == 2 ) {
1431                 mpi_print( stdout, generate_public_prime( atoi(argv[1]) ), 1);
1432             }
1433             else if( mode == 2 && argc == 3 ) {
1434                 mpi_print( stdout, generate_elg_prime(
1435                                              0, atoi(argv[1]),
1436                                              atoi(argv[2]), NULL,NULL ), 1);
1437             }
1438             else if( mode == 3 && argc == 3 ) {
1439                 MPI *factors;
1440                 mpi_print( stdout, generate_elg_prime(
1441                                              1, atoi(argv[1]),
1442                                              atoi(argv[2]), NULL,&factors ), 1);
1443                 putchar('\n');
1444                 mpi_print( stdout, factors[0], 1 ); /* print q */
1445             }
1446             else if( mode == 4 && argc == 3 ) {
1447                 MPI g = mpi_alloc(1);
1448                 mpi_print( stdout, generate_elg_prime(
1449                                                  0, atoi(argv[1]),
1450                                                  atoi(argv[2]), g, NULL ), 1);
1451                 putchar('\n');
1452                 mpi_print( stdout, g, 1 );
1453                 mpi_release(g);
1454             }
1455             else
1456                 wrong_args("--gen-prime mode bits [qbits] ");
1457             putchar('\n');
1458           #endif
1459         }
1460         break;
1461
1462       case aGenRandom:
1463         {
1464             int level = argc ? atoi(*argv):0;
1465             int count = argc > 1 ? atoi(argv[1]): 0;
1466             int endless = !count;
1467
1468             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
1469                 wrong_args("--gen-random 0|1|2 [count]");
1470
1471             while( endless || count ) {
1472                 byte *p;
1473                 size_t n = !endless && count < 100? count : 100;
1474
1475                 p = gcry_random_bytes( n, level );
1476               #ifdef HAVE_DOSISH_SYSTEM
1477                 setmode ( fileno(stdout), O_BINARY );
1478               #endif
1479                 fwrite( p, n, 1, stdout );
1480                 gcry_free(p);
1481                 if( !endless )
1482                     count -= n;
1483             }
1484         }
1485         break;
1486
1487       case aPrintMD:
1488         if( argc < 1)
1489             wrong_args("--print-md algo [files]");
1490         {
1491             int all_algos = (**argv=='*' && !(*argv)[1]);
1492             int algo = all_algos? 0 : gcry_md_map_name(*argv);
1493
1494             if( !algo && !all_algos )
1495                 log_error(_("invalid hash algorithm `%s'\n"), *argv );
1496             else {
1497                 argc--; argv++;
1498                 if( !argc )
1499                     print_mds(NULL, algo, NULL);
1500                 else {
1501                     for(; argc; argc--, argv++ )
1502                         print_mds(*argv, algo, NULL);
1503                 }
1504             }
1505         }
1506         break;
1507
1508       case aPrintHMAC:
1509         if( argc < 2 )
1510             wrong_args("--print-hmac hash-algo key [files]");
1511         {
1512             int all_algos = (**argv=='*' && !(*argv)[1]);
1513             int algo = all_algos? 0 : gcry_md_map_name(*argv);
1514
1515             if( !algo && !all_algos )
1516                 log_error(_("invalid hash algorithm `%s'\n"), *argv );
1517             else {
1518                 const char *key;
1519                 argc--; argv++;
1520                 key = *argv;
1521                 argc--; argv++;
1522                 if( !argc )
1523                     print_mds(NULL, algo, key );
1524                 else {
1525                     for(; argc; argc--, argv++ )
1526                         print_mds(*argv, algo, key );
1527                 }
1528             }
1529         }
1530         break;
1531
1532
1533       case aPrintMDs: /* old option */
1534         if( !argc )
1535             print_mds(NULL,0,NULL);
1536         else {
1537             for(; argc; argc--, argv++ )
1538                 print_mds(*argv,0,NULL);
1539         }
1540         break;
1541
1542       case aListTrustDB:
1543         if( !argc )
1544             list_trustdb(NULL);
1545         else {
1546             for( ; argc; argc--, argv++ )
1547                 list_trustdb( *argv );
1548         }
1549         break;
1550
1551       case aUpdateTrustDB:
1552         if( argc )
1553             wrong_args("--update-trustdb");
1554         update_trustdb();
1555         break;
1556
1557       case aCheckTrustDB:
1558         if( !argc )
1559             check_trustdb(NULL);
1560         else {
1561             for( ; argc; argc--, argv++ ) {
1562                 username = make_username( *argv );
1563                 check_trustdb( username );
1564                 gcry_free(username);
1565             }
1566         }
1567         break;
1568
1569       case aFixTrustDB:
1570         log_error("this command is not yet implemented.\n");
1571         log_error("A workaround is to use \"--export-ownertrust\", remove\n");
1572         log_error("the trustdb file and do an \"--import-ownertrust\".\n" );
1573         break;
1574
1575       case aListTrustPath:
1576         if( !argc )
1577             wrong_args("--list-trust-path <user-ids>");
1578         for( ; argc; argc--, argv++ ) {
1579             username = make_username( *argv );
1580             list_trust_path( username );
1581             gcry_free(username);
1582         }
1583         break;
1584
1585       case aExportOwnerTrust:
1586         if( argc )
1587             wrong_args("--export-ownertrust");
1588         export_ownertrust();
1589         break;
1590
1591       case aImportOwnerTrust:
1592         if( argc > 1 )
1593             wrong_args("--import-ownertrust [file]");
1594         import_ownertrust( argc? *argv:NULL );
1595         break;
1596
1597       case aListPackets:
1598         opt.list_packets=1;
1599       default:
1600         if( argc > 1 )
1601             wrong_args(_("[filename]"));
1602         /* Issue some output for the unix newbie */
1603         if( !fname && !opt.outfile && isatty( fileno(stdin) )
1604                 && isatty( fileno(stdout) ) && isatty( fileno(stderr) ) )
1605             log_info(_("Go ahead and type your message ...\n"));
1606
1607         if( !(a = iobuf_open(fname)) )
1608             log_error(_("can't open `%s'\n"), print_fname_stdin(fname));
1609         else {
1610
1611             if( !opt.no_armor ) {
1612                 if( use_armor_filter( a ) ) {
1613                     memset( &afx, 0, sizeof afx);
1614                     iobuf_push_filter( a, armor_filter, &afx );
1615                 }
1616             }
1617             if( cmd == aListPackets ) {
1618                 set_packet_list_mode(1);
1619                 opt.list_packets=1;
1620             }
1621             rc = proc_packets(NULL, a );
1622             if( rc )
1623                 log_error("processing message failed: %s\n", gpg_errstr(rc) );
1624             iobuf_close(a);
1625         }
1626         break;
1627     }
1628
1629     /* cleanup */
1630     FREE_STRLIST(remusr);
1631     FREE_STRLIST(locusr);
1632     gpg_exit(0);
1633     return 8; /*NEVER REACHED*/
1634 }
1635
1636
1637 void
1638 gpg_exit( int rc )
1639 {
1640   #if 0
1641     #warning no update_random_seed_file
1642     update_random_seed_file();
1643   #endif
1644     if( opt.debug & DBG_MEMSTAT_VALUE ) {
1645         gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1646         gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1647     }
1648     if( opt.debug )
1649         gcry_control( GCRYCTL_DUMP_SECMEM_STATS );
1650     gcry_control( GCRYCTL_TERM_SECMEM );
1651     rc = rc? rc : log_get_errorcount(0)? 2 :
1652                         gpg_errors_seen? 1 : 0;
1653     /*write_status( STATUS_LEAVE );*/
1654     exit(rc );
1655 }
1656
1657
1658
1659
1660 static void
1661 print_hex( byte *p, size_t n )
1662 {
1663     int i;
1664
1665     if( n == 20 ) {
1666         for(i=0; i < n ; i++, i++, p += 2 ) {
1667             if( i )
1668                 putchar(' ');
1669             if( i == 10 )
1670                 putchar(' ');
1671             printf("%02X%02X", *p, p[1] );
1672         }
1673     }
1674     else if( n == 24 ) {
1675         for(i=0; i < n ; i += 4, p += 4 ) {
1676             if( i )
1677                 putchar(' ');
1678             if( i == 12 )
1679                 putchar(' ');
1680             printf("%02X%02X%02X%02X", *p, p[1], p[2], p[3] );
1681         }
1682     }
1683     else {
1684         for(i=0; i < n ; i++, p++ ) {
1685             if( i )
1686                 putchar(' ');
1687             if( i && !(i%8) )
1688                 putchar(' ');
1689             printf("%02X", *p );
1690         }
1691     }
1692 }
1693
1694 static void
1695 print_mds( const char *fname, int algo, const char *key )
1696 {
1697     FILE *fp;
1698     char buf[1024];
1699     size_t n;
1700     GCRY_MD_HD md;
1701     char *pname;
1702     int have_tiger = 0;
1703
1704     if( !fname ) {
1705         fp = stdin;
1706       #ifdef HAVE_DOSISH_SYSTEM
1707         setmode ( fileno(fp) , O_BINARY );
1708       #endif
1709         pname = gcry_xstrdup("[stdin]: ");
1710     }
1711     else {
1712         pname = gcry_xmalloc(strlen(fname)+3);
1713         strcpy(stpcpy(pname,fname),": ");
1714         fp = fopen( fname, "rb" );
1715     }
1716     if( !fp ) {
1717         log_error("%s%s\n", pname, strerror(errno) );
1718         gcry_free(pname);
1719         return;
1720     }
1721
1722     md = gcry_md_open( 0, key? GCRY_MD_FLAG_HMAC : 0 );
1723     if( algo )
1724         gcry_md_enable( md, algo );
1725     else {
1726         /* Fixme: this does not work with hmac */
1727         gcry_md_enable( md, GCRY_MD_MD5 );
1728         gcry_md_enable( md, GCRY_MD_SHA1 );
1729         gcry_md_enable( md, GCRY_MD_RMD160 );
1730         have_tiger = !gcry_md_enable( md, GCRY_MD_TIGER );
1731     }
1732     if( key )
1733         gcry_md_setkey( md, key, strlen(key) );
1734
1735     while( (n=fread( buf, 1, DIM(buf), fp )) )
1736         gcry_md_write( md, buf, n );
1737     if( ferror(fp) )
1738         log_error("%s%s\n", pname, strerror(errno) );
1739     else {
1740         if( algo ) {
1741             if( fname )
1742                 fputs( pname, stdout );
1743             print_hex(gcry_md_read(md, algo), gcry_md_get_algo_dlen(algo) );
1744         }
1745         else {
1746             printf(  "%s   MD5 = ", fname?pname:"" );
1747                             print_hex(gcry_md_read(md, GCRY_MD_MD5), 16 );
1748             printf("\n%s  SHA1 = ", fname?pname:""  );
1749                             print_hex(gcry_md_read(md, GCRY_MD_SHA1), 20 );
1750             printf("\n%sRMD160 = ", fname?pname:""  );
1751                             print_hex(gcry_md_read(md, GCRY_MD_RMD160), 20 );
1752             if( have_tiger ) {
1753                 printf("\n%s TIGER = ", fname?pname:""  );
1754                             print_hex(gcry_md_read(md, GCRY_MD_TIGER), 24 );
1755             }
1756         }
1757         putchar('\n');
1758     }
1759     gcry_md_close(md);
1760
1761     if( fp != stdin )
1762         fclose(fp);
1763 }
1764
1765
1766 /****************
1767  * Check the supplied name,value string and add it to the notation
1768  * data to be used for signatures.
1769  */
1770 static void
1771 add_notation_data( const char *string )
1772 {
1773     const char *s;
1774     const char *s2;
1775     STRLIST sl;
1776     int critical=0;
1777     int highbit=0;
1778
1779     if( *string == '!' ) {
1780         critical = 1;
1781         string++;
1782     }
1783     s = string;
1784
1785     if( !*s || (*s & 0x80) || (!isalpha(*s) && *s != '_') ) {
1786         log_error(_("the first character of a notation name "
1787                     "must be a letter or an underscore\n") );
1788         return;
1789     }
1790     for(s++; *s != '='; s++ ) {
1791         if( !*s || (*s & 0x80) || (!isalnum(*s) && *s != '_' && *s != '.' ) ) {
1792             log_error(_("a notation name must have only letters, "
1793                         "digits, dots or underscores and end with an '='\n") );
1794             return;
1795         }
1796     }
1797     if( s[-1] == '.' || ((s2=strstr(string, "..")) && s2 < s ) ) {
1798         log_error(_("dots in a notation name must be surrounded "
1799                     "by other characters\n") );
1800         return;
1801     }
1802     /* we do only support printabe text - therefore we enforce the use
1803      * of only printable characters (an empty value is valid) */
1804     for( s++; *s ; s++ ) {
1805         if( iscntrl(*s) ) {
1806             log_error(_("a notation value must not use "
1807                         "any control characters\n") );
1808             return;
1809         }
1810         else if( *s & 0x80 )
1811             highbit = 1;
1812     }
1813
1814     if( highbit )   /* must use UTF8 encoding */
1815         sl = add_to_strlist2( &opt.notation_data, string, utf8_strings );
1816     else
1817         sl = add_to_strlist( &opt.notation_data, string );
1818
1819     if( critical )
1820         sl->flags |= 1;
1821 }
1822
1823
1824 static int
1825 check_policy_url( const char *s )
1826 {
1827     if( *s == '!' )
1828         s++;
1829     if( !*s )
1830         return -1;
1831     for(; *s ; s++ ) {
1832         if( (*s & 0x80) || iscntrl(*s) )
1833             return -1;
1834     }
1835     return 0;
1836 }
1837