* passphrase.c (ask_passphrase): Unescape the description string.
[gnupg.git] / g10 / misc.c
1 /* misc.c -  miscellaneous functions
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
3  *               2004, 2005 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <unistd.h>
27 #include <errno.h>
28 #if defined(__linux__) && defined(__alpha__) && __GLIBC__ < 2
29 #include <asm/sysinfo.h>
30 #include <asm/unistd.h>
31 #endif
32 #ifdef HAVE_SETRLIMIT
33 #include <time.h>
34 #include <sys/time.h>
35 #include <sys/resource.h>
36 #endif
37 #ifdef ENABLE_SELINUX_HACKS
38 #include <sys/stat.h>
39 #endif
40 #ifdef _WIN32
41 #include <time.h>
42 #include <process.h>
43 #include <windows.h> 
44 #include <shlobj.h>
45 #ifndef CSIDL_APPDATA
46 #define CSIDL_APPDATA 0x001a
47 #endif
48 #ifndef CSIDL_LOCAL_APPDATA
49 #define CSIDL_LOCAL_APPDATA 0x001c
50 #endif
51 #ifndef CSIDL_FLAG_CREATE
52 #define CSIDL_FLAG_CREATE 0x8000
53 #endif
54 #include "errors.h"
55 #include "dynload.h"
56 #endif /*_WIN32*/
57
58 #include "util.h"
59 #include "main.h"
60 #include "photoid.h"
61 #include "options.h"
62 #include "i18n.h"
63 #include "cardglue.h"
64
65
66
67
68 #ifdef ENABLE_SELINUX_HACKS
69 /* A object and a global variable to keep track of files marked as
70    secured. */
71 struct secured_file_item 
72 {
73   struct secured_file_item *next;
74   ino_t ino;
75   dev_t dev;
76 };
77 static struct secured_file_item *secured_files;
78 #endif /*ENABLE_SELINUX_HACKS*/
79
80
81
82 #if defined(__linux__) && defined(__alpha__) && __GLIBC__ < 2
83 static int
84 setsysinfo(unsigned long op, void *buffer, unsigned long size,
85                      int *start, void *arg, unsigned long flag)
86 {
87     return syscall(__NR_osf_setsysinfo, op, buffer, size, start, arg, flag);
88 }
89
90 void
91 trap_unaligned(void)
92 {
93     unsigned int buf[2];
94
95     buf[0] = SSIN_UACPROC;
96     buf[1] = UAC_SIGBUS | UAC_NOPRINT;
97     setsysinfo(SSI_NVPAIRS, buf, 1, 0, 0, 0);
98 }
99 #else
100 void
101 trap_unaligned(void)
102 {  /* dummy */
103 }
104 #endif
105
106
107 int
108 disable_core_dumps()
109 {
110 #ifdef HAVE_DOSISH_SYSTEM
111     return 0;
112 #else
113 #ifdef HAVE_SETRLIMIT
114     struct rlimit limit;
115
116     limit.rlim_cur = 0;
117     limit.rlim_max = 0;
118     if( !setrlimit( RLIMIT_CORE, &limit ) )
119         return 0;
120     if( errno != EINVAL && errno != ENOSYS )
121         log_fatal(_("can't disable core dumps: %s\n"), strerror(errno) );
122 #endif
123     return 1;
124 #endif
125 }
126
127
128 /* For the sake of SELinux we want to restrict access through gpg to
129    certain files we keep under our own control.  This function
130    registers such a file and is_secured_file may then be used to
131    check whether a file has ben registered as secured. */
132 void
133 register_secured_file (const char *fname)
134 {
135 #ifdef ENABLE_SELINUX_HACKS
136   struct stat buf;
137   struct secured_file_item *sf;
138
139   /* Note that we stop immediatley if something goes wrong here. */
140   if (stat (fname, &buf))
141     log_fatal (_("fstat of `%s' failed in %s: %s\n"), fname, 
142                "register_secured_file", strerror (errno));
143 /*   log_debug ("registering `%s' i=%lu.%lu\n", fname, */
144 /*              (unsigned long)buf.st_dev, (unsigned long)buf.st_ino); */
145   for (sf=secured_files; sf; sf = sf->next)
146     {
147       if (sf->ino == buf.st_ino && sf->dev == buf.st_dev)
148         return; /* Already registered.  */
149     }
150
151   sf = xmalloc (sizeof *sf);
152   sf->ino = buf.st_ino;
153   sf->dev = buf.st_dev;
154   sf->next = secured_files;
155   secured_files = sf;
156 #endif /*ENABLE_SELINUX_HACKS*/
157 }
158
159 /* Remove a file registerd as secure. */
160 void
161 unregister_secured_file (const char *fname)
162 {
163 #ifdef ENABLE_SELINUX_HACKS
164   struct stat buf;
165   struct secured_file_item *sf, *sfprev;
166
167   if (stat (fname, &buf))
168     {
169       log_error (_("fstat of `%s' failed in %s: %s\n"), fname,
170                  "unregister_secured_file", strerror (errno));
171       return;
172     }
173 /*   log_debug ("unregistering `%s' i=%lu.%lu\n", fname,  */
174 /*              (unsigned long)buf.st_dev, (unsigned long)buf.st_ino); */
175   for (sfprev=NULL,sf=secured_files; sf; sfprev=sf, sf = sf->next)
176     {
177       if (sf->ino == buf.st_ino && sf->dev == buf.st_dev)
178         {
179           if (sfprev)
180             sfprev->next = sf->next;
181           else
182             secured_files = sf->next;
183           xfree (sf);
184           return;
185         }
186     }
187 #endif /*ENABLE_SELINUX_HACKS*/
188 }
189
190 /* Return true if FD is corresponds to a secured file.  Using -1 for
191    FS is allowed and will return false. */ 
192 int 
193 is_secured_file (int fd)
194 {
195 #ifdef ENABLE_SELINUX_HACKS
196   struct stat buf;
197   struct secured_file_item *sf;
198
199   if (fd == -1)
200     return 0; /* No file descriptor so it can't be secured either.  */
201
202   /* Note that we print out a error here and claim that a file is
203      secure if something went wrong. */
204   if (fstat (fd, &buf))
205     {
206       log_error (_("fstat(%d) failed in %s: %s\n"), fd, 
207                  "is_secured_file", strerror (errno));
208       return 1;
209     }
210 /*   log_debug ("is_secured_file (%d) i=%lu.%lu\n", fd, */
211 /*              (unsigned long)buf.st_dev, (unsigned long)buf.st_ino); */
212   for (sf=secured_files; sf; sf = sf->next)
213     {
214       if (sf->ino == buf.st_ino && sf->dev == buf.st_dev)
215         return 1; /* Yes.  */
216     }
217 #endif /*ENABLE_SELINUX_HACKS*/
218   return 0; /* No. */
219 }
220
221 /* Return true if FNAME is corresponds to a secured file.  Using NULL,
222    "" or "-" for FS is allowed and will return false. This function is
223    used before creating a file, thus it won't fail if the file does
224    not exist. */ 
225 int 
226 is_secured_filename (const char *fname)
227 {
228 #ifdef ENABLE_SELINUX_HACKS
229   struct stat buf;
230   struct secured_file_item *sf;
231
232   if (iobuf_is_pipe_filename (fname) || !*fname)
233     return 0; 
234
235   /* Note that we print out a error here and claim that a file is
236      secure if something went wrong. */
237   if (stat (fname, &buf))
238     {
239       if (errno == ENOENT || errno == EPERM || errno == EACCES)
240         return 0;
241       log_error (_("fstat of `%s' failed in %s: %s\n"), fname,
242                  "is_secured_filename", strerror (errno));
243       return 1;
244     }
245 /*   log_debug ("is_secured_filename (%s) i=%lu.%lu\n", fname, */
246 /*              (unsigned long)buf.st_dev, (unsigned long)buf.st_ino); */
247   for (sf=secured_files; sf; sf = sf->next)
248     {
249       if (sf->ino == buf.st_ino && sf->dev == buf.st_dev)
250         return 1; /* Yes.  */
251     }
252 #endif /*ENABLE_SELINUX_HACKS*/
253   return 0; /* No. */
254 }
255
256
257
258 u16
259 checksum_u16( unsigned n )
260 {
261     u16 a;
262
263     a  = (n >> 8) & 0xff;
264     a += n & 0xff;
265     return a;
266 }
267
268
269 u16
270 checksum( byte *p, unsigned n )
271 {
272     u16 a;
273
274     for(a=0; n; n-- )
275         a += *p++;
276     return a;
277 }
278
279 u16
280 checksum_mpi( MPI a )
281 {
282     u16 csum;
283     byte *buffer;
284     unsigned nbytes;
285     unsigned nbits;
286
287     buffer = mpi_get_buffer( a, &nbytes, NULL );
288     nbits = mpi_get_nbits(a);
289     csum = checksum_u16( nbits );
290     csum += checksum( buffer, nbytes );
291     m_free( buffer );
292     return csum;
293 }
294
295 u32
296 buffer_to_u32( const byte *buffer )
297 {
298     unsigned long a;
299     a =  *buffer << 24;
300     a |= buffer[1] << 16;
301     a |= buffer[2] << 8;
302     a |= buffer[3];
303     return a;
304 }
305
306 void
307 print_pubkey_algo_note( int algo )
308 {
309   if(algo >= 100 && algo <= 110)
310     {
311       static int warn=0;
312       if(!warn)
313         {
314           warn=1;
315           log_info(_("WARNING: using experimental public key algorithm %s\n"),
316                    pubkey_algo_to_string(algo));
317         }
318     }
319 }
320
321 void
322 print_cipher_algo_note( int algo )
323 {
324   if(algo >= 100 && algo <= 110)
325     {
326       static int warn=0;
327       if(!warn)
328         {
329           warn=1;
330           log_info(_("WARNING: using experimental cipher algorithm %s\n"),
331                    cipher_algo_to_string(algo));
332         }
333     }
334 }
335
336 void
337 print_digest_algo_note( int algo )
338 {
339   if(algo >= 100 && algo <= 110)
340     {
341       static int warn=0;
342       if(!warn)
343         {
344           warn=1;
345           log_info(_("WARNING: using experimental digest algorithm %s\n"),
346                    digest_algo_to_string(algo));
347         }
348     }
349   else if(algo==DIGEST_ALGO_MD5)
350     log_info(_("WARNING: digest algorithm %s is deprecated\n"),
351              digest_algo_to_string(algo));
352 }
353
354 /* Return a string which is used as a kind of process ID */
355 const byte *
356 get_session_marker( size_t *rlen )
357 {
358     static byte marker[SIZEOF_UNSIGNED_LONG*2];
359     static int initialized;
360
361     if ( !initialized ) {
362         volatile ulong aa, bb; /* we really want the uninitialized value */
363         ulong a, b;
364
365         initialized = 1;
366         /* also this marker is guessable it is not easy to use this 
367          * for a faked control packet because an attacker does not
368          * have enough control about the time the verification does 
369          * take place.  Of course, we can add just more random but 
370          * than we need the random generator even for verification
371          * tasks - which does not make sense. */
372         a = aa ^ (ulong)getpid();
373         b = bb ^ (ulong)time(NULL);
374         memcpy( marker, &a, SIZEOF_UNSIGNED_LONG );
375         memcpy( marker+SIZEOF_UNSIGNED_LONG, &b, SIZEOF_UNSIGNED_LONG );
376     }
377     *rlen = sizeof(marker);
378     return marker;
379 }
380
381 /****************
382  * Wrapper around the libgcrypt function with addional checks on
383  * openPGP contraints for the algo ID.
384  */
385 int
386 openpgp_cipher_test_algo( int algo )
387 {
388     if( algo < 0 || algo > 110 )
389         return G10ERR_CIPHER_ALGO;
390     return check_cipher_algo(algo);
391 }
392
393 int
394 openpgp_pk_test_algo( int algo, unsigned int usage_flags )
395 {
396     if( algo < 0 || algo > 110 )
397         return G10ERR_PUBKEY_ALGO;
398     return check_pubkey_algo2( algo, usage_flags );
399 }
400
401 int 
402 openpgp_pk_algo_usage ( int algo )
403 {
404     int use = 0; 
405     
406     /* they are hardwired in gpg 1.0 */
407     switch ( algo ) {    
408       case PUBKEY_ALGO_RSA:
409           use = PUBKEY_USAGE_SIG | PUBKEY_USAGE_ENC | PUBKEY_USAGE_AUTH;
410           break;
411       case PUBKEY_ALGO_RSA_E:
412           use = PUBKEY_USAGE_ENC;
413           break;
414       case PUBKEY_ALGO_RSA_S:
415           use = PUBKEY_USAGE_SIG;
416           break;
417       case PUBKEY_ALGO_ELGAMAL_E:
418           use = PUBKEY_USAGE_ENC;
419           break;
420       case PUBKEY_ALGO_DSA:  
421           use = PUBKEY_USAGE_SIG | PUBKEY_USAGE_AUTH;
422           break;
423       default:
424           break;
425     }
426     return use;
427 }
428
429 int
430 openpgp_md_test_algo( int algo )
431 {
432     if( algo < 0 || algo > 110 )
433         return G10ERR_DIGEST_ALGO;
434     return check_digest_algo(algo);
435 }
436
437 #ifdef USE_IDEA
438 /* Special warning for the IDEA cipher */
439 void
440 idea_cipher_warn(int show)
441 {
442   static int warned=0;
443
444   if(!warned || show)
445     {
446       log_info(_("the IDEA cipher plugin is not present\n"));
447       log_info(_("please see http://www.gnupg.org/why-not-idea.html "
448                  "for more information\n"));
449       warned=1;
450     }
451 }
452 #endif
453
454 static unsigned long get_signature_count(PKT_secret_key *sk)
455 {
456 #ifdef ENABLE_CARD_SUPPORT
457   if(sk && sk->is_protected && sk->protect.s2k.mode==1002)
458     {
459       struct agent_card_info_s info;
460       if(agent_scd_getattr("SIG-COUNTER",&info)==0)
461         return info.sig_counter;
462     }  
463 #endif
464
465   /* How to do this without a card? */
466
467   return 0;
468 }
469
470 /* Expand %-strings.  Returns a string which must be m_freed.  Returns
471    NULL if the string cannot be expanded (too large). */
472 char *
473 pct_expando(const char *string,struct expando_args *args)
474 {
475   const char *ch=string;
476   int idx=0,maxlen=0,done=0;
477   u32 pk_keyid[2]={0,0},sk_keyid[2]={0,0};
478   char *ret=NULL;
479
480   if(args->pk)
481     keyid_from_pk(args->pk,pk_keyid);
482
483   if(args->sk)
484     keyid_from_sk(args->sk,sk_keyid);
485
486   /* This is used so that %k works in photoid command strings in
487      --list-secret-keys (which of course has a sk, but no pk). */
488   if(!args->pk && args->sk)
489     keyid_from_sk(args->sk,pk_keyid);
490
491   while(*ch!='\0')
492     {
493       char *str=NULL;
494
495       if(!done)
496         {
497           /* 8192 is way bigger than we'll need here */
498           if(maxlen>=8192)
499             goto fail;
500
501           maxlen+=1024;
502           ret=m_realloc(ret,maxlen);
503         }
504
505       done=0;
506
507       if(*ch=='%')
508         {
509           switch(*(ch+1))
510             {
511             case 's': /* short key id */
512               if(idx+8<maxlen)
513                 {
514                   sprintf(&ret[idx],"%08lX",(ulong)sk_keyid[1]);
515                   idx+=8;
516                   done=1;
517                 }
518               break;
519
520             case 'S': /* long key id */
521               if(idx+16<maxlen)
522                 {
523                   sprintf(&ret[idx],"%08lX%08lX",
524                           (ulong)sk_keyid[0],(ulong)sk_keyid[1]);
525                   idx+=16;
526                   done=1;
527                 }
528               break;
529
530             case 'k': /* short key id */
531               if(idx+8<maxlen)
532                 {
533                   sprintf(&ret[idx],"%08lX",(ulong)pk_keyid[1]);
534                   idx+=8;
535                   done=1;
536                 }
537               break;
538
539             case 'K': /* long key id */
540               if(idx+16<maxlen)
541                 {
542                   sprintf(&ret[idx],"%08lX%08lX",
543                           (ulong)pk_keyid[0],(ulong)pk_keyid[1]);
544                   idx+=16;
545                   done=1;
546                 }
547               break;
548
549             case 'c': /* signature count from card, if any. */
550               if(idx+10<maxlen)
551                 {
552                   sprintf(&ret[idx],"%lu",get_signature_count(args->sk));
553                   idx+=strlen(&ret[idx]);
554                   done=1;
555                 }             
556               break;
557
558             case 'p': /* primary pk fingerprint of a sk */
559             case 'f': /* pk fingerprint */
560             case 'g': /* sk fingerprint */
561               {
562                 byte array[MAX_FINGERPRINT_LEN];
563                 size_t len;
564                 int i;
565
566                 if((*(ch+1))=='p' && args->sk)
567                   {
568                     if(args->sk->is_primary)
569                       fingerprint_from_sk(args->sk,array,&len);
570                     else if(args->sk->main_keyid[0] || args->sk->main_keyid[1])
571                       {
572                         PKT_public_key *pk=
573                           m_alloc_clear(sizeof(PKT_public_key));
574
575                         if(get_pubkey_fast(pk,args->sk->main_keyid)==0)
576                           fingerprint_from_pk(pk,array,&len);
577                         else
578                           memset(array,0,(len=MAX_FINGERPRINT_LEN));
579                         free_public_key(pk);
580                       }
581                     else
582                       memset(array,0,(len=MAX_FINGERPRINT_LEN));
583                   }
584                 else if((*(ch+1))=='f' && args->pk)
585                   fingerprint_from_pk(args->pk,array,&len);
586                 else if((*(ch+1))=='g' && args->sk)
587                   fingerprint_from_sk(args->sk,array,&len);
588                 else
589                   memset(array,0,(len=MAX_FINGERPRINT_LEN));
590
591                 if(idx+(len*2)<maxlen)
592                   {
593                     for(i=0;i<len;i++)
594                       {
595                         sprintf(&ret[idx],"%02X",array[i]);
596                         idx+=2;
597                       }
598                     done=1;
599                   }
600               }
601               break;
602
603             case 't': /* e.g. "jpg" */
604               str=image_type_to_string(args->imagetype,0);
605               /* fall through */
606
607             case 'T': /* e.g. "image/jpeg" */
608               if(str==NULL)
609                 str=image_type_to_string(args->imagetype,2);
610
611               if(idx+strlen(str)<maxlen)
612                 {
613                   strcpy(&ret[idx],str);
614                   idx+=strlen(str);
615                   done=1;
616                 }
617               break;
618
619             case '%':
620               if(idx+1<maxlen)
621                 {
622                   ret[idx++]='%';
623                   ret[idx]='\0';
624                   done=1;
625                 }
626               break;
627
628               /* Any unknown %-keys (like %i, %o, %I, and %O) are
629                  passed through for later expansion.  Note this also
630                  handles the case where the last character in the
631                  string is a '%' - the terminating \0 will end up here
632                  and properly terminate the string. */
633             default:
634               if(idx+2<maxlen)
635                 {
636                   ret[idx++]='%';
637                   ret[idx++]=*(ch+1);
638                   ret[idx]='\0';
639                   done=1;
640                 }
641               break;
642               }
643
644           if(done)
645             ch++;
646         }
647       else
648         {
649           if(idx+1<maxlen)
650             {
651               ret[idx++]=*ch;
652               ret[idx]='\0';
653               done=1;
654             }
655         }
656
657       if(done)
658         ch++;
659     }
660
661   return ret;
662
663  fail:
664   m_free(ret);
665   return NULL;
666 }
667
668 void
669 deprecated_warning(const char *configname,unsigned int configlineno,
670                    const char *option,const char *repl1,const char *repl2)
671 {
672   if(configname)
673     {
674       if(strncmp("--",option,2)==0)
675         option+=2;
676
677       if(strncmp("--",repl1,2)==0)
678         repl1+=2;
679
680       log_info(_("%s:%d: deprecated option \"%s\"\n"),
681                configname,configlineno,option);
682     }
683   else
684     log_info(_("WARNING: \"%s\" is a deprecated option\n"),option);
685
686   log_info(_("please use \"%s%s\" instead\n"),repl1,repl2);
687 }
688
689
690 void
691 deprecated_command (const char *name)
692 {
693   log_info(_("WARNING: \"%s\" is a deprecated command - do not use it\n"),
694            name);
695 }
696
697
698 const char *
699 compress_algo_to_string(int algo)
700 {
701   const char *s=NULL;
702
703   switch(algo)
704     {
705     case COMPRESS_ALGO_NONE:
706       s=_("Uncompressed");
707       break;
708
709     case COMPRESS_ALGO_ZIP:
710       s="ZIP";
711       break;
712
713     case COMPRESS_ALGO_ZLIB:
714       s="ZLIB";
715       break;
716
717 #ifdef HAVE_BZIP2
718     case COMPRESS_ALGO_BZIP2:
719       s="BZIP2";
720       break;
721 #endif
722     }
723
724   return s;
725 }
726
727 int
728 string_to_compress_algo(const char *string)
729 {
730   /* NOTE TO TRANSLATOR: See doc/TRANSLATE about this string. */
731   if(match_multistr(_("uncompressed|none"),string))
732     return 0;
733   else if(ascii_strcasecmp(string,"uncompressed")==0)
734     return 0;
735   else if(ascii_strcasecmp(string,"none")==0)
736     return 0;
737   else if(ascii_strcasecmp(string,"zip")==0)
738     return 1;
739   else if(ascii_strcasecmp(string,"zlib")==0)
740     return 2;
741 #ifdef HAVE_BZIP2
742   else if(ascii_strcasecmp(string,"bzip2")==0)
743     return 3;
744 #endif
745   else if(ascii_strcasecmp(string,"z0")==0)
746     return 0;
747   else if(ascii_strcasecmp(string,"z1")==0)
748     return 1;
749   else if(ascii_strcasecmp(string,"z2")==0)
750     return 2;
751 #ifdef HAVE_BZIP2
752   else if(ascii_strcasecmp(string,"z3")==0)
753     return 3;
754 #endif
755   else
756     return -1;
757 }
758
759 int
760 check_compress_algo(int algo)
761 {
762 #ifdef HAVE_BZIP2
763   if(algo>=0 && algo<=3)
764     return 0;
765 #else
766   if(algo>=0 && algo<=2)
767     return 0;
768 #endif
769
770   return G10ERR_COMPR_ALGO;
771 }
772
773 int
774 default_cipher_algo(void)
775 {
776   if(opt.def_cipher_algo)
777     return opt.def_cipher_algo;
778   else if(opt.personal_cipher_prefs)
779     return opt.personal_cipher_prefs[0].value;
780   else
781     return opt.s2k_cipher_algo;
782 }
783
784 /* There is no default_digest_algo function, but see
785    sign.c:hash_for() */
786
787 int
788 default_compress_algo(void)
789 {
790   if(opt.compress_algo!=-1)
791     return opt.compress_algo;
792   else if(opt.personal_compress_prefs)
793     return opt.personal_compress_prefs[0].value;
794   else
795     return DEFAULT_COMPRESS_ALGO;
796 }
797
798 const char *
799 compliance_option_string(void)
800 {
801   switch(opt.compliance)
802     {
803     case CO_RFC2440:
804       return "--openpgp";
805     case CO_PGP2:
806       return "--pgp2";
807     case CO_PGP6:
808       return "--pgp6";
809     case CO_PGP7:
810       return "--pgp7";
811     case CO_PGP8:
812       return "--pgp8";
813     default:
814       return "???";
815     }
816 }
817
818 static const char *
819 compliance_string(void)
820 {
821   switch(opt.compliance)
822     {
823     case CO_RFC2440:
824       return "OpenPGP";
825     case CO_PGP2:
826       return "PGP 2.x";
827     case CO_PGP6:
828       return "PGP 6.x";
829     case CO_PGP7:
830       return "PGP 7.x";
831     case CO_PGP8:
832       return "PGP 8.x";
833     default:
834       return "???";
835     }
836 }
837
838 void
839 compliance_failure(void)
840 {
841   log_info(_("this message may not be usable by %s\n"),compliance_string());
842   opt.compliance=CO_GNUPG;
843 }
844
845 /* Break a string into successive option pieces.  Accepts single word
846    options and key=value argument options. */
847 char *
848 optsep(char **stringp)
849 {
850   char *tok,*end;
851
852   tok=*stringp;
853   if(tok)
854     {
855       end=strpbrk(tok," ,=");
856       if(end)
857         {
858           int sawequals=0;
859           char *ptr=end;
860
861           /* what we need to do now is scan along starting with *end,
862              If the next character we see (ignoring spaces) is an =
863              sign, then there is an argument. */
864
865           while(*ptr)
866             {
867               if(*ptr=='=')
868                 sawequals=1;
869               else if(*ptr!=' ')
870                 break;
871               ptr++;
872             }
873
874           /* There is an argument, so grab that too.  At this point,
875              ptr points to the first character of the argument. */
876           if(sawequals)
877             {
878               /* Is it a quoted argument? */
879               if(*ptr=='"')
880                 {
881                   ptr++;
882                   end=strchr(ptr,'"');
883                   if(end)
884                     end++;
885                 }
886               else
887                 end=strpbrk(ptr," ,");
888             }
889
890           if(end && *end)
891             {
892               *end='\0';
893               *stringp=end+1;
894             }
895           else
896             *stringp=NULL;
897         }
898       else
899         *stringp=NULL;
900     }
901
902   return tok;
903 }
904
905 /* Breaks an option value into key and value.  Returns NULL if there
906    is no value.  Note that "string" is modified to remove the =value
907    part. */
908 char *
909 argsplit(char *string)
910 {
911   char *equals,*arg=NULL;
912
913   equals=strchr(string,'=');
914   if(equals)
915     {
916       char *quote,*space;
917
918       *equals='\0';
919       arg=equals+1;
920
921       /* Quoted arg? */
922       quote=strchr(arg,'"');
923       if(quote)
924         {
925           arg=quote+1;
926
927           quote=strchr(arg,'"');
928           if(quote)
929             *quote='\0';
930         }
931       else
932         {
933           size_t spaces;
934
935           /* Trim leading spaces off of the arg */
936           spaces=strspn(arg," ");
937           arg+=spaces;
938         }
939
940       /* Trim tailing spaces off of the tag */
941       space=strchr(string,' ');
942       if(space)
943         *space='\0';
944     }
945
946   return arg;
947 }
948
949 /* Return the length of the initial token, leaving off any
950    argument. */
951 static size_t
952 optlen(const char *s)
953 {
954   char *end=strpbrk(s," =");
955
956   if(end)
957     return end-s;
958   else
959     return strlen(s);
960 }
961
962 int
963 parse_options(char *str,unsigned int *options,
964               struct parse_options *opts,int noisy)
965 {
966   char *tok;
967
968   while((tok=optsep(&str)))
969     {
970       int i,rev=0;
971       char *otok=tok;
972
973       if(tok[0]=='\0')
974         continue;
975
976       if(ascii_strncasecmp("no-",tok,3)==0)
977         {
978           rev=1;
979           tok+=3;
980         }
981
982       for(i=0;opts[i].name;i++)
983         {
984           size_t toklen=optlen(tok);
985
986           if(ascii_strncasecmp(opts[i].name,tok,toklen)==0)
987             {
988               /* We have a match, but it might be incomplete */
989               if(toklen!=strlen(opts[i].name))
990                 {
991                   int j;
992
993                   for(j=i+1;opts[j].name;j++)
994                     {
995                       if(ascii_strncasecmp(opts[j].name,tok,toklen)==0)
996                         {
997                           if(noisy)
998                             log_info(_("ambiguous option `%s'\n"),otok);
999                           return 0;
1000                         }
1001                     }
1002                 }
1003
1004               if(rev)
1005                 {
1006                   *options&=~opts[i].bit;
1007                   if(opts[i].value)
1008                     *opts[i].value=NULL;
1009                 }
1010               else
1011                 {
1012                   *options|=opts[i].bit;
1013                   if(opts[i].value)
1014                     *opts[i].value=argsplit(tok);
1015                 }
1016               break;
1017             }
1018         }
1019
1020       if(!opts[i].name)
1021         {
1022           if(noisy)
1023             log_info(_("unknown option `%s'\n"),otok);
1024           return 0;
1025         }
1026     }
1027
1028   return 1;
1029 }
1030
1031
1032 /* Return a new malloced string by unescaping the string S.  Escaping
1033    is percent escaping and '+'/space mapping.  A binary nul will
1034    silently be replaced by a 0xFF. */
1035 char *
1036 unescape_percent_string (const unsigned char *s)
1037 {
1038   char *buffer, *d;
1039
1040   buffer = d = xmalloc (strlen (s)+1);
1041   while (*s)
1042     {
1043       if (*s == '%' && s[1] && s[2])
1044         { 
1045           s++;
1046           *d = xtoi_2 (s);
1047           if (!*d)
1048             *d = '\xff';
1049           d++;
1050           s += 2;
1051         }
1052       else if (*s == '+')
1053         {
1054           *d++ = ' ';
1055           s++;
1056         }
1057       else
1058         *d++ = *s++;
1059     }
1060   *d = 0; 
1061   return buffer;
1062 }
1063
1064
1065
1066
1067 /* This is a helper function to load a Windows function from either of
1068    one DLLs. */
1069 #ifdef HAVE_W32_SYSTEM
1070 static HRESULT
1071 w32_shgetfolderpath (HWND a, int b, HANDLE c, DWORD d, LPSTR e)
1072 {
1073   static int initialized;
1074   static HRESULT (WINAPI * func)(HWND,int,HANDLE,DWORD,LPSTR);
1075
1076   if (!initialized)
1077     {
1078       static char *dllnames[] = { "shell32.dll", "shfolder.dll", NULL };
1079       void *handle;
1080       int i;
1081
1082       initialized = 1;
1083
1084       for (i=0, handle = NULL; !handle && dllnames[i]; i++)
1085         {
1086           handle = dlopen (dllnames[i], RTLD_LAZY);
1087           if (handle)
1088             {
1089               func = dlsym (handle, "SHGetFolderPathA");
1090               if (!func)
1091                 {
1092                   dlclose (handle);
1093                   handle = NULL;
1094                 }
1095             }
1096         }
1097     }
1098
1099   if (func)
1100     return func (a,b,c,d,e);
1101   else
1102     return -1;
1103 }
1104 #endif /*HAVE_W32_SYSTEM*/
1105
1106
1107 /* Set up the default home directory.  The usual --homedir option
1108    should be parsed later. */
1109 char *
1110 default_homedir (void)
1111 {
1112   char *dir;
1113
1114   dir = getenv("GNUPGHOME");
1115 #ifdef HAVE_W32_SYSTEM
1116   if (!dir || !*dir)
1117     dir = read_w32_registry_string (NULL, "Software\\GNU\\GnuPG", "HomeDir");
1118   if (!dir || !*dir)
1119     {
1120       char path[MAX_PATH];
1121       
1122       /* It might be better to use LOCAL_APPDATA because this is
1123          defined as "non roaming" and thus more likely to be kept
1124          locally.  For private keys this is desired.  However, given
1125          that many users copy private keys anyway forth and back,
1126          using a system roaming serives might be better than to let
1127          them do it manually.  A security conscious user will anyway
1128          use the registry entry to have better control.  */
1129       if (w32_shgetfolderpath (NULL, CSIDL_APPDATA|CSIDL_FLAG_CREATE, 
1130                                NULL, 0, path) >= 0) 
1131         {
1132           char *tmp = xmalloc (strlen (path) + 6 +1);
1133           strcpy (stpcpy (tmp, path), "\\gnupg");
1134           dir = tmp;
1135           
1136           /* Try to create the directory if it does not yet
1137              exists.  */
1138           if (access (dir, F_OK))
1139             CreateDirectory (dir, NULL);
1140         }
1141     }
1142 #endif /*HAVE_W32_SYSTEM*/
1143   if (!dir || !*dir)
1144     dir = GNUPG_HOMEDIR;
1145
1146   return dir;
1147 }