a26aa740d2686ed6aa9a9cb929c7746e5d0c118a
[gnupg.git] / g10 / misc.c
1 /* misc.c - miscellaneous functions
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3  *               2005, 2006 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
42 #ifdef HAVE_W32_SYSTEM
43 #include <time.h>
44 #include <process.h>
45 #include <windows.h> 
46 #include <shlobj.h>
47 #ifndef CSIDL_APPDATA
48 #define CSIDL_APPDATA 0x001a
49 #endif
50 #ifndef CSIDL_LOCAL_APPDATA
51 #define CSIDL_LOCAL_APPDATA 0x001c
52 #endif
53 #ifndef CSIDL_FLAG_CREATE
54 #define CSIDL_FLAG_CREATE 0x8000
55 #endif
56 #endif /*HAVE_W32_SYSTEM*/
57
58 #include "gpg.h"
59 #ifdef HAVE_W32_SYSTEM
60 # include "errors.h"
61 # include "dynload.h"
62 #endif /*HAVE_W32_SYSTEM*/
63 #include "util.h"
64 #include "main.h"
65 #include "photoid.h"
66 #include "options.h"
67 #include "i18n.h"
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 #ifdef HAVE_DOSISH_SYSTEM
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 registered 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 (gcry_mpi_t a)
284 {
285   u16 csum;
286   byte *buffer;
287   unsigned int nbytes;
288   unsigned int nbits;
289
290   if ( gcry_mpi_print (GCRYMPI_FMT_PGP, NULL, 0, &nbytes, a) )
291     BUG ();
292   /* Fixme: For numbers not in secure memory we should use a stack
293    * based buffer and only allocate a larger one if mpi_print returns
294    * an error. */
295   buffer = (gcry_is_secure(a)?
296             gcry_xmalloc_secure (nbytes) : gcry_xmalloc (nbytes));
297   if ( gcry_mpi_print (GCRYMPI_FMT_PGP, buffer, nbytes, NULL, a) )
298     BUG ();
299   nbits = gcry_mpi_get_nbits (a);
300   csum = checksum_u16 (nbits);
301   csum += checksum (buffer, nbytes);
302   xfree (buffer);
303   return csum;
304 }
305
306 u32
307 buffer_to_u32( const byte *buffer )
308 {
309     unsigned long a;
310     a =  *buffer << 24;
311     a |= buffer[1] << 16;
312     a |= buffer[2] << 8;
313     a |= buffer[3];
314     return a;
315 }
316
317 void
318 print_pubkey_algo_note( int algo )
319 {
320   if(algo >= 100 && algo <= 110)
321     {
322       static int warn=0;
323       if(!warn)
324         {
325           warn=1;
326           log_info (_("WARNING: using experimental public key algorithm %s\n"),
327                     gcry_pk_algo_name (algo));
328         }
329     }
330 }
331
332 void
333 print_cipher_algo_note( int algo )
334 {
335   if(algo >= 100 && algo <= 110)
336     {
337       static int warn=0;
338       if(!warn)
339         {
340           warn=1;
341           log_info (_("WARNING: using experimental cipher algorithm %s\n"),
342                     gcry_cipher_algo_name (algo));
343         }
344     }
345 }
346
347 void
348 print_digest_algo_note( int algo )
349 {
350   if(algo >= 100 && algo <= 110)
351     {
352       static int warn=0;
353       if(!warn)
354         {
355           warn=1;
356           log_info (_("WARNING: using experimental digest algorithm %s\n"),
357                     gcry_md_algo_name (algo));
358         }
359     }
360   else if(algo==DIGEST_ALGO_MD5)
361     log_info (_("WARNING: digest algorithm %s is deprecated\n"),
362               gcry_md_algo_name (algo));
363 }
364
365 /* Return a string which is used as a kind of process ID */
366 const byte *
367 get_session_marker( size_t *rlen )
368 {
369   static byte marker[SIZEOF_UNSIGNED_LONG*2];
370   static int initialized;
371   
372   if ( !initialized )
373     {
374       volatile ulong aa, bb; /* We really want the uninitialized value. */
375       ulong a, b;
376       
377       initialized = 1;
378       /* Although this marker is guessable it is not easy to use this
379        * for a faked control packet because an attacker does not have
380        * enough control about the time the verification takes place.
381        * Of course, we could add just more random but than we need the
382        * random generator even for verification tasks - which does not
383        * make sense. */
384       a = aa ^ (ulong)getpid();
385       b = bb ^ (ulong)time(NULL);
386       memcpy ( marker, &a, SIZEOF_UNSIGNED_LONG );
387       memcpy ( marker+SIZEOF_UNSIGNED_LONG, &b, SIZEOF_UNSIGNED_LONG );
388     }
389   *rlen = sizeof(marker);
390   return marker;
391 }
392
393 /****************
394  * Wrapper around the libgcrypt function with additonal checks on
395  * the OpenPGP contraints for the algo ID.
396  */
397 int
398 openpgp_cipher_test_algo( int algo )
399 {
400   if ( algo < 0 || algo > 110 )
401     return gpg_error (GPG_ERR_CIPHER_ALGO);
402   return gcry_cipher_test_algo (algo);
403 }
404
405 int
406 openpgp_pk_test_algo( int algo )
407 {
408   if (algo == GCRY_PK_ELG_E)
409     algo = GCRY_PK_ELG;
410
411   if (algo < 0 || algo > 110)
412     return gpg_error (GPG_ERR_PUBKEY_ALGO);
413   return gcry_pk_test_algo (algo);
414 }
415
416 int
417 openpgp_pk_test_algo2( int algo, unsigned int use )
418 {
419   if (algo == GCRY_PK_ELG_E)
420     algo = GCRY_PK_ELG;
421
422   if (algo < 0 || algo > 110)
423     return gpg_error (GPG_ERR_PUBKEY_ALGO);
424   return gcry_pk_test_algo2 (algo, use);
425 }
426
427 int 
428 openpgp_pk_algo_usage ( int algo )
429 {
430     int use = 0; 
431     
432     /* They are hardwired in gpg 1.0. */
433     switch ( algo ) {    
434       case PUBKEY_ALGO_RSA:
435           use = (PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG
436                  | PUBKEY_USAGE_ENC | PUBKEY_USAGE_AUTH);
437           break;
438       case PUBKEY_ALGO_RSA_E:
439           use = PUBKEY_USAGE_ENC;
440           break;
441       case PUBKEY_ALGO_RSA_S:
442           use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG;
443           break;
444       case PUBKEY_ALGO_ELGAMAL_E:
445           use = PUBKEY_USAGE_ENC;
446           break;
447       case PUBKEY_ALGO_DSA:  
448           use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG | PUBKEY_USAGE_AUTH;
449           break;
450       default:
451           break;
452     }
453     return use;
454 }
455
456 int
457 openpgp_md_test_algo( int algo )
458 {
459   if (algo < 0 || algo > 110)
460     return gpg_error (GPG_ERR_DIGEST_ALGO);
461   return gcry_md_test_algo (algo);
462 }
463
464 #ifdef USE_IDEA
465 /* Special warning for the IDEA cipher */
466 void
467 idea_cipher_warn(int show)
468 {
469   static int warned=0;
470
471   if(!warned || show)
472     {
473       log_info(_("the IDEA cipher plugin is not present\n"));
474       log_info(_("please see %s for more information\n"),
475                "http://www.gnupg.org/faq/why-not-idea.html");
476       warned=1;
477     }
478 }
479 #endif
480
481 static unsigned long get_signature_count(PKT_secret_key *sk)
482 {
483 #ifdef ENABLE_CARD_SUPPORT
484   if(sk && sk->is_protected && sk->protect.s2k.mode==1002)
485     {
486       struct agent_card_info_s info;
487       if(agent_scd_getattr("SIG-COUNTER",&info)==0)
488         return info.sig_counter;
489     }  
490 #endif
491
492   /* How to do this without a card? */
493
494   return 0;
495 }
496
497 /* Expand %-strings.  Returns a string which must be xfreed.  Returns
498    NULL if the string cannot be expanded (too large). */
499 char *
500 pct_expando(const char *string,struct expando_args *args)
501 {
502   const char *ch=string;
503   int idx=0,maxlen=0,done=0;
504   u32 pk_keyid[2]={0,0},sk_keyid[2]={0,0};
505   char *ret=NULL;
506
507   if(args->pk)
508     keyid_from_pk(args->pk,pk_keyid);
509
510   if(args->sk)
511     keyid_from_sk(args->sk,sk_keyid);
512
513   /* This is used so that %k works in photoid command strings in
514      --list-secret-keys (which of course has a sk, but no pk). */
515   if(!args->pk && args->sk)
516     keyid_from_sk(args->sk,pk_keyid);
517
518   while(*ch!='\0')
519     {
520       char *str=NULL;
521
522       if(!done)
523         {
524           /* 8192 is way bigger than we'll need here */
525           if(maxlen>=8192)
526             goto fail;
527
528           maxlen+=1024;
529           ret=xrealloc(ret,maxlen);
530         }
531
532       done=0;
533
534       if(*ch=='%')
535         {
536           switch(*(ch+1))
537             {
538             case 's': /* short key id */
539               if(idx+8<maxlen)
540                 {
541                   sprintf(&ret[idx],"%08lX",(ulong)sk_keyid[1]);
542                   idx+=8;
543                   done=1;
544                 }
545               break;
546
547             case 'S': /* long key id */
548               if(idx+16<maxlen)
549                 {
550                   sprintf(&ret[idx],"%08lX%08lX",
551                           (ulong)sk_keyid[0],(ulong)sk_keyid[1]);
552                   idx+=16;
553                   done=1;
554                 }
555               break;
556
557             case 'k': /* short key id */
558               if(idx+8<maxlen)
559                 {
560                   sprintf(&ret[idx],"%08lX",(ulong)pk_keyid[1]);
561                   idx+=8;
562                   done=1;
563                 }
564               break;
565
566             case 'K': /* long key id */
567               if(idx+16<maxlen)
568                 {
569                   sprintf(&ret[idx],"%08lX%08lX",
570                           (ulong)pk_keyid[0],(ulong)pk_keyid[1]);
571                   idx+=16;
572                   done=1;
573                 }
574               break;
575
576             case 'c': /* signature count from card, if any. */
577               if(idx+10<maxlen)
578                 {
579                   sprintf(&ret[idx],"%lu",get_signature_count(args->sk));
580                   idx+=strlen(&ret[idx]);
581                   done=1;
582                 }             
583               break;
584
585             case 'p': /* primary pk fingerprint of a sk */
586             case 'f': /* pk fingerprint */
587             case 'g': /* sk fingerprint */
588               {
589                 byte array[MAX_FINGERPRINT_LEN];
590                 size_t len;
591                 int i;
592
593                 if((*(ch+1))=='p' && args->sk)
594                   {
595                     if(args->sk->is_primary)
596                       fingerprint_from_sk(args->sk,array,&len);
597                     else if(args->sk->main_keyid[0] || args->sk->main_keyid[1])
598                       {
599                         PKT_public_key *pk=
600                           xmalloc_clear(sizeof(PKT_public_key));
601
602                         if(get_pubkey_fast(pk,args->sk->main_keyid)==0)
603                           fingerprint_from_pk(pk,array,&len);
604                         else
605                           memset(array,0,(len=MAX_FINGERPRINT_LEN));
606                         free_public_key(pk);
607                       }
608                     else
609                       memset(array,0,(len=MAX_FINGERPRINT_LEN));
610                   }
611                 else if((*(ch+1))=='f' && args->pk)
612                   fingerprint_from_pk(args->pk,array,&len);
613                 else if((*(ch+1))=='g' && args->sk)
614                   fingerprint_from_sk(args->sk,array,&len);
615                 else
616                   memset(array,0,(len=MAX_FINGERPRINT_LEN));
617
618                 if(idx+(len*2)<maxlen)
619                   {
620                     for(i=0;i<len;i++)
621                       {
622                         sprintf(&ret[idx],"%02X",array[i]);
623                         idx+=2;
624                       }
625                     done=1;
626                   }
627               }
628               break;
629
630             case 't': /* e.g. "jpg" */
631               str=image_type_to_string(args->imagetype,0);
632               /* fall through */
633
634             case 'T': /* e.g. "image/jpeg" */
635               if(str==NULL)
636                 str=image_type_to_string(args->imagetype,2);
637
638               if(idx+strlen(str)<maxlen)
639                 {
640                   strcpy(&ret[idx],str);
641                   idx+=strlen(str);
642                   done=1;
643                 }
644               break;
645
646             case '%':
647               if(idx+1<maxlen)
648                 {
649                   ret[idx++]='%';
650                   ret[idx]='\0';
651                   done=1;
652                 }
653               break;
654
655               /* Any unknown %-keys (like %i, %o, %I, and %O) are
656                  passed through for later expansion.  Note this also
657                  handles the case where the last character in the
658                  string is a '%' - the terminating \0 will end up here
659                  and properly terminate the string. */
660             default:
661               if(idx+2<maxlen)
662                 {
663                   ret[idx++]='%';
664                   ret[idx++]=*(ch+1);
665                   ret[idx]='\0';
666                   done=1;
667                 }
668               break;
669               }
670
671           if(done)
672             ch++;
673         }
674       else
675         {
676           if(idx+1<maxlen)
677             {
678               ret[idx++]=*ch;
679               ret[idx]='\0';
680               done=1;
681             }
682         }
683
684       if(done)
685         ch++;
686     }
687
688   return ret;
689
690  fail:
691   xfree(ret);
692   return NULL;
693 }
694
695 void
696 deprecated_warning(const char *configname,unsigned int configlineno,
697                    const char *option,const char *repl1,const char *repl2)
698 {
699   if(configname)
700     {
701       if(strncmp("--",option,2)==0)
702         option+=2;
703
704       if(strncmp("--",repl1,2)==0)
705         repl1+=2;
706
707       log_info(_("%s:%d: deprecated option \"%s\"\n"),
708                configname,configlineno,option);
709     }
710   else
711     log_info(_("WARNING: \"%s\" is a deprecated option\n"),option);
712
713   log_info(_("please use \"%s%s\" instead\n"),repl1,repl2);
714 }
715
716
717 void
718 deprecated_command (const char *name)
719 {
720   log_info(_("WARNING: \"%s\" is a deprecated command - do not use it\n"),
721            name);
722 }
723
724
725 const char *
726 compress_algo_to_string(int algo)
727 {
728   const char *s=NULL;
729
730   switch(algo)
731     {
732     case COMPRESS_ALGO_NONE:
733       s=_("Uncompressed");
734       break;
735
736     case COMPRESS_ALGO_ZIP:
737       s="ZIP";
738       break;
739
740     case COMPRESS_ALGO_ZLIB:
741       s="ZLIB";
742       break;
743
744 #ifdef HAVE_BZIP2
745     case COMPRESS_ALGO_BZIP2:
746       s="BZIP2";
747       break;
748 #endif
749     }
750
751   return s;
752 }
753
754 int
755 string_to_compress_algo(const char *string)
756 {
757   /* NOTE TO TRANSLATOR: See doc/TRANSLATE about this string. */
758   if(match_multistr(_("uncompressed|none"),string))
759     return 0;
760   else if(ascii_strcasecmp(string,"uncompressed")==0)
761     return 0;
762   else if(ascii_strcasecmp(string,"none")==0)
763     return 0;
764   else if(ascii_strcasecmp(string,"zip")==0)
765     return 1;
766   else if(ascii_strcasecmp(string,"zlib")==0)
767     return 2;
768 #ifdef HAVE_BZIP2
769   else if(ascii_strcasecmp(string,"bzip2")==0)
770     return 3;
771 #endif
772   else if(ascii_strcasecmp(string,"z0")==0)
773     return 0;
774   else if(ascii_strcasecmp(string,"z1")==0)
775     return 1;
776   else if(ascii_strcasecmp(string,"z2")==0)
777     return 2;
778 #ifdef HAVE_BZIP2
779   else if(ascii_strcasecmp(string,"z3")==0)
780     return 3;
781 #endif
782   else
783     return -1;
784 }
785
786 int
787 check_compress_algo(int algo)
788 {
789 #ifdef HAVE_BZIP2
790   if(algo>=0 && algo<=3)
791     return 0;
792 #else
793   if(algo>=0 && algo<=2)
794     return 0;
795 #endif
796
797   return G10ERR_COMPR_ALGO;
798 }
799
800 int
801 default_cipher_algo(void)
802 {
803   if(opt.def_cipher_algo)
804     return opt.def_cipher_algo;
805   else if(opt.personal_cipher_prefs)
806     return opt.personal_cipher_prefs[0].value;
807   else
808     return opt.s2k_cipher_algo;
809 }
810
811 /* There is no default_digest_algo function, but see
812    sign.c:hash_for() */
813
814 int
815 default_compress_algo(void)
816 {
817   if(opt.compress_algo!=-1)
818     return opt.compress_algo;
819   else if(opt.personal_compress_prefs)
820     return opt.personal_compress_prefs[0].value;
821   else
822     return DEFAULT_COMPRESS_ALGO;
823 }
824
825 const char *
826 compliance_option_string(void)
827 {
828   switch(opt.compliance)
829     {
830     case CO_RFC2440:
831       return "--openpgp";
832     case CO_PGP2:
833       return "--pgp2";
834     case CO_PGP6:
835       return "--pgp6";
836     case CO_PGP7:
837       return "--pgp7";
838     case CO_PGP8:
839       return "--pgp8";
840     default:
841       return "???";
842     }
843 }
844
845 static const char *
846 compliance_string(void)
847 {
848   switch(opt.compliance)
849     {
850     case CO_RFC2440:
851       return "OpenPGP";
852     case CO_PGP2:
853       return "PGP 2.x";
854     case CO_PGP6:
855       return "PGP 6.x";
856     case CO_PGP7:
857       return "PGP 7.x";
858     case CO_PGP8:
859       return "PGP 8.x";
860     default:
861       return "???";
862     }
863 }
864
865 void
866 compliance_failure(void)
867 {
868   log_info(_("this message may not be usable by %s\n"),compliance_string());
869   opt.compliance=CO_GNUPG;
870 }
871
872 /* Break a string into successive option pieces.  Accepts single word
873    options and key=value argument options. */
874 char *
875 optsep(char **stringp)
876 {
877   char *tok,*end;
878
879   tok=*stringp;
880   if(tok)
881     {
882       end=strpbrk(tok," ,=");
883       if(end)
884         {
885           int sawequals=0;
886           char *ptr=end;
887
888           /* what we need to do now is scan along starting with *end,
889              If the next character we see (ignoring spaces) is an =
890              sign, then there is an argument. */
891
892           while(*ptr)
893             {
894               if(*ptr=='=')
895                 sawequals=1;
896               else if(*ptr!=' ')
897                 break;
898               ptr++;
899             }
900
901           /* There is an argument, so grab that too.  At this point,
902              ptr points to the first character of the argument. */
903           if(sawequals)
904             {
905               /* Is it a quoted argument? */
906               if(*ptr=='"')
907                 {
908                   ptr++;
909                   end=strchr(ptr,'"');
910                   if(end)
911                     end++;
912                 }
913               else
914                 end=strpbrk(ptr," ,");
915             }
916
917           if(end && *end)
918             {
919               *end='\0';
920               *stringp=end+1;
921             }
922           else
923             *stringp=NULL;
924         }
925       else
926         *stringp=NULL;
927     }
928
929   return tok;
930 }
931
932 /* Breaks an option value into key and value.  Returns NULL if there
933    is no value.  Note that "string" is modified to remove the =value
934    part. */
935 char *
936 argsplit(char *string)
937 {
938   char *equals,*arg=NULL;
939
940   equals=strchr(string,'=');
941   if(equals)
942     {
943       char *quote,*space;
944
945       *equals='\0';
946       arg=equals+1;
947
948       /* Quoted arg? */
949       quote=strchr(arg,'"');
950       if(quote)
951         {
952           arg=quote+1;
953
954           quote=strchr(arg,'"');
955           if(quote)
956             *quote='\0';
957         }
958       else
959         {
960           size_t spaces;
961
962           /* Trim leading spaces off of the arg */
963           spaces=strspn(arg," ");
964           arg+=spaces;
965         }
966
967       /* Trim tailing spaces off of the tag */
968       space=strchr(string,' ');
969       if(space)
970         *space='\0';
971     }
972
973   return arg;
974 }
975
976 /* Return the length of the initial token, leaving off any
977    argument. */
978 static size_t
979 optlen(const char *s)
980 {
981   char *end=strpbrk(s," =");
982
983   if(end)
984     return end-s;
985   else
986     return strlen(s);
987 }
988
989 int
990 parse_options(char *str,unsigned int *options,
991               struct parse_options *opts,int noisy)
992 {
993   char *tok;
994
995   if (str && !strcmp (str, "help"))
996     {
997       int i,maxlen=0;
998
999       /* Figure out the longest option name so we can line these up
1000          neatly. */
1001       for(i=0;opts[i].name;i++)
1002         if(opts[i].help && maxlen<strlen(opts[i].name))
1003           maxlen=strlen(opts[i].name);
1004
1005       for(i=0;opts[i].name;i++)
1006         if(opts[i].help)
1007           printf("%s%*s%s\n",opts[i].name,
1008                  maxlen+2-(int)strlen(opts[i].name),"",_(opts[i].help));
1009
1010       g10_exit(0);
1011     }
1012
1013   while((tok=optsep(&str)))
1014     {
1015       int i,rev=0;
1016       char *otok=tok;
1017
1018       if(tok[0]=='\0')
1019         continue;
1020
1021       if(ascii_strncasecmp("no-",tok,3)==0)
1022         {
1023           rev=1;
1024           tok+=3;
1025         }
1026
1027       for(i=0;opts[i].name;i++)
1028         {
1029           size_t toklen=optlen(tok);
1030
1031           if(ascii_strncasecmp(opts[i].name,tok,toklen)==0)
1032             {
1033               /* We have a match, but it might be incomplete */
1034               if(toklen!=strlen(opts[i].name))
1035                 {
1036                   int j;
1037
1038                   for(j=i+1;opts[j].name;j++)
1039                     {
1040                       if(ascii_strncasecmp(opts[j].name,tok,toklen)==0)
1041                         {
1042                           if(noisy)
1043                             log_info(_("ambiguous option `%s'\n"),otok);
1044                           return 0;
1045                         }
1046                     }
1047                 }
1048
1049               if(rev)
1050                 {
1051                   *options&=~opts[i].bit;
1052                   if(opts[i].value)
1053                     *opts[i].value=NULL;
1054                 }
1055               else
1056                 {
1057                   *options|=opts[i].bit;
1058                   if(opts[i].value)
1059                     *opts[i].value=argsplit(tok);
1060                 }
1061               break;
1062             }
1063         }
1064
1065       if(!opts[i].name)
1066         {
1067           if(noisy)
1068             log_info(_("unknown option `%s'\n"),otok);
1069           return 0;
1070         }
1071     }
1072
1073   return 1;
1074 }
1075
1076
1077 /* Return a new malloced string by unescaping the string S.  Escaping
1078    is percent escaping and '+'/space mapping.  A binary nul will
1079    silently be replaced by a 0xFF. */
1080 char *
1081 unescape_percent_string (const unsigned char *s)
1082 {
1083   char *buffer, *d;
1084
1085   buffer = d = xmalloc (strlen (s)+1);
1086   while (*s)
1087     {
1088       if (*s == '%' && s[1] && s[2])
1089         { 
1090           s++;
1091           *d = xtoi_2 (s);
1092           if (!*d)
1093             *d = '\xff';
1094           d++;
1095           s += 2;
1096         }
1097       else if (*s == '+')
1098         {
1099           *d++ = ' ';
1100           s++;
1101         }
1102       else
1103         *d++ = *s++;
1104     }
1105   *d = 0; 
1106   return buffer;
1107 }
1108
1109
1110 int
1111 has_invalid_email_chars (const char *s)
1112 {
1113   int at_seen=0;
1114   const char *valid_chars=
1115     "01234567890_-.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
1116
1117   for ( ; *s; s++ ) 
1118     {
1119       if ( *s & 0x80 )
1120         return 1;
1121       if ( *s == '@' )
1122         at_seen=1;
1123       else if ( !at_seen && !( !!strchr( valid_chars, *s ) || *s == '+' ) )
1124         return 1;
1125       else if ( at_seen && !strchr( valid_chars, *s ) )
1126         return 1;
1127     }
1128   return 0;
1129 }
1130
1131
1132 /* Check whether NAME represents a valid mailbox according to
1133    RFC822. Returns true if so. */
1134 int
1135 is_valid_mailbox (const char *name)
1136 {
1137   return !( !name
1138             || !*name
1139             || has_invalid_email_chars (name)
1140             || string_count_chr (name,'@') != 1
1141             || *name == '@'
1142             || name[strlen(name)-1] == '@'
1143             || name[strlen(name)-1] == '.'
1144             || strstr (name, "..") );
1145 }
1146
1147
1148 /* This is a helper function to load a Windows function from either of
1149    one DLLs. */
1150 #ifdef HAVE_W32_SYSTEM
1151 static HRESULT
1152 w32_shgetfolderpath (HWND a, int b, HANDLE c, DWORD d, LPSTR e)
1153 {
1154   static int initialized;
1155   static HRESULT (WINAPI * func)(HWND,int,HANDLE,DWORD,LPSTR);
1156
1157   if (!initialized)
1158     {
1159       static char *dllnames[] = { "shell32.dll", "shfolder.dll", NULL };
1160       void *handle;
1161       int i;
1162
1163       initialized = 1;
1164
1165       for (i=0, handle = NULL; !handle && dllnames[i]; i++)
1166         {
1167           handle = dlopen (dllnames[i], RTLD_LAZY);
1168           if (handle)
1169             {
1170               func = dlsym (handle, "SHGetFolderPathA");
1171               if (!func)
1172                 {
1173                   dlclose (handle);
1174                   handle = NULL;
1175                 }
1176             }
1177         }
1178     }
1179
1180   if (func)
1181     return func (a,b,c,d,e);
1182   else
1183     return -1;
1184 }
1185 #endif /*HAVE_W32_SYSTEM*/
1186
1187
1188 /* Return the name of the libexec directory.  The name is allocated in
1189    a static area on the first use.  This function won't fail. */
1190 const char *
1191 get_libexecdir (void)
1192 {
1193 #ifdef HAVE_W32_SYSTEM
1194   static int got_dir;
1195   static char dir[MAX_PATH+5];
1196
1197   if (!got_dir)
1198     {
1199       char *p;
1200
1201       if ( !GetModuleFileName ( NULL, dir, MAX_PATH) )
1202         {
1203           log_debug ("GetModuleFileName failed: %s\n", w32_strerror (0));
1204           *dir = 0;
1205         }
1206       got_dir = 1;
1207       p = strrchr (dir, DIRSEP_C);
1208       if (p)
1209         *p = 0;
1210       else
1211         {
1212           log_debug ("bad filename `%s' returned for this process\n", dir);
1213           *dir = 0; 
1214         }
1215     }
1216
1217   if (*dir)
1218     return dir;
1219   /* Fallback to the hardwired value. */
1220 #endif /*HAVE_W32_SYSTEM*/
1221
1222   return GNUPG_LIBEXECDIR;
1223 }
1224
1225 /* Similar to access(2), but uses PATH to find the file. */
1226 int
1227 path_access(const char *file,int mode)
1228 {
1229   char *envpath;
1230   int ret=-1;
1231
1232   envpath=getenv("PATH");
1233
1234   if(!envpath
1235 #ifdef HAVE_DRIVE_LETTERS
1236      || (((file[0]>='A' && file[0]<='Z')
1237           || (file[0]>='a' && file[0]<='z'))
1238          && file[1]==':')
1239 #else
1240      || file[0]=='/'
1241 #endif
1242      )
1243     return access(file,mode);
1244   else
1245     {
1246       /* At least as large as, but most often larger than we need. */
1247       char *buffer=xmalloc(strlen(envpath)+1+strlen(file)+1);
1248       char *split,*item,*path=xstrdup(envpath);
1249
1250       split=path;
1251
1252       while((item=strsep(&split,PATHSEP_S)))
1253         {
1254           strcpy(buffer,item);
1255           strcat(buffer,"/");
1256           strcat(buffer,file);
1257           ret=access(buffer,mode);
1258           if(ret==0)
1259             break;
1260         }
1261
1262       xfree(path);
1263       xfree(buffer);
1264     }
1265
1266   return ret;
1267 }
1268
1269
1270 \f
1271 /* Temporary helper. */
1272 int
1273 pubkey_get_npkey( int algo )
1274 {
1275   size_t n;
1276
1277   if (algo == GCRY_PK_ELG_E)
1278     algo = GCRY_PK_ELG;
1279   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NPKEY, NULL, &n))
1280     n = 0;
1281   return n;
1282 }
1283
1284 /* Temporary helper. */
1285 int
1286 pubkey_get_nskey( int algo )
1287 {
1288   size_t n;
1289
1290   if (algo == GCRY_PK_ELG_E)
1291     algo = GCRY_PK_ELG;
1292   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NSKEY, NULL, &n ))
1293     n = 0;
1294   return n;
1295 }
1296
1297 /* Temporary helper. */
1298 int
1299 pubkey_get_nsig( int algo )
1300 {
1301   size_t n;
1302
1303   if (algo == GCRY_PK_ELG_E)
1304     algo = GCRY_PK_ELG;
1305   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NSIGN, NULL, &n))
1306     n = 0;
1307   return n;
1308 }
1309
1310 /* Temporary helper. */
1311 int
1312 pubkey_get_nenc( int algo )
1313 {
1314   size_t n;
1315   
1316   if (algo == GCRY_PK_ELG_E)
1317     algo = GCRY_PK_ELG;
1318   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NENCR, NULL, &n ))
1319     n = 0;
1320   return n;
1321 }
1322
1323
1324 /* Temporary helper. */
1325 unsigned int
1326 pubkey_nbits( int algo, gcry_mpi_t *key )
1327 {
1328     int rc, nbits;
1329     gcry_sexp_t sexp;
1330
1331     if( algo == GCRY_PK_DSA ) {
1332         rc = gcry_sexp_build ( &sexp, NULL,
1333                               "(public-key(dsa(p%m)(q%m)(g%m)(y%m)))",
1334                                   key[0], key[1], key[2], key[3] );
1335     }
1336     else if( algo == GCRY_PK_ELG || algo == GCRY_PK_ELG_E ) {
1337         rc = gcry_sexp_build ( &sexp, NULL,
1338                               "(public-key(elg(p%m)(g%m)(y%m)))",
1339                                   key[0], key[1], key[2] );
1340     }
1341     else if( algo == GCRY_PK_RSA ) {
1342         rc = gcry_sexp_build ( &sexp, NULL,
1343                               "(public-key(rsa(n%m)(e%m)))",
1344                                   key[0], key[1] );
1345     }
1346     else
1347         return 0;
1348
1349     if ( rc )
1350         BUG ();
1351
1352     nbits = gcry_pk_get_nbits( sexp );
1353     gcry_sexp_release( sexp );
1354     return nbits;
1355 }
1356
1357
1358
1359 /* FIXME: Use gcry_mpi_print directly. */
1360 int
1361 mpi_print( FILE *fp, gcry_mpi_t a, int mode )
1362 {
1363     int n=0;
1364
1365     if( !a )
1366         return fprintf(fp, "[MPI_NULL]");
1367     if( !mode ) {
1368         unsigned int n1;
1369         n1 = gcry_mpi_get_nbits(a);
1370         n += fprintf(fp, "[%u bits]", n1);
1371     }
1372     else {
1373         unsigned char *buffer;
1374
1375         if (gcry_mpi_aprint (GCRYMPI_FMT_HEX, &buffer, NULL, a))
1376           BUG ();
1377         fputs( buffer, fp );
1378         n += strlen(buffer);
1379         gcry_free( buffer );
1380     }
1381     return n;
1382 }
1383