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