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