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