Do not run the setuid test if running under as root proper.
[gnupg.git] / g10 / misc.c
1 /* misc.c - miscellaneous functions
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 
3  *               2005, 2006, 2007, 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
40 #ifdef HAVE_W32_SYSTEM
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 /*HAVE_W32_SYSTEM*/
55
56 #include "gpg.h"
57 #ifdef HAVE_W32_SYSTEM
58 # include "status.h"
59 #endif /*HAVE_W32_SYSTEM*/
60 #include "util.h"
61 #include "main.h"
62 #include "photoid.h"
63 #include "options.h"
64 #include "call-agent.h"
65 #include "i18n.h"
66
67
68 static int
69 string_count_chr (const char *string, int c)
70 {
71   int count;
72
73   for (count=0; *string; string++ )
74     if ( *string == c )
75       count++;
76   return count;
77 }
78
79
80
81 #ifdef ENABLE_SELINUX_HACKS
82 /* A object and a global variable to keep track of files marked as
83    secured. */
84 struct secured_file_item 
85 {
86   struct secured_file_item *next;
87   ino_t ino;
88   dev_t dev;
89 };
90 static struct secured_file_item *secured_files;
91 #endif /*ENABLE_SELINUX_HACKS*/
92
93
94
95
96 /* For the sake of SELinux we want to restrict access through gpg to
97    certain files we keep under our own control.  This function
98    registers such a file and is_secured_file may then be used to
99    check whether a file has ben registered as secured. */
100 void
101 register_secured_file (const char *fname)
102 {
103 #ifdef ENABLE_SELINUX_HACKS
104   struct stat buf;
105   struct secured_file_item *sf;
106
107   /* Note that we stop immediatley if something goes wrong here. */
108   if (stat (fname, &buf))
109     log_fatal (_("fstat of `%s' failed in %s: %s\n"), fname, 
110                "register_secured_file", strerror (errno));
111 /*   log_debug ("registering `%s' i=%lu.%lu\n", fname, */
112 /*              (unsigned long)buf.st_dev, (unsigned long)buf.st_ino); */
113   for (sf=secured_files; sf; sf = sf->next)
114     {
115       if (sf->ino == buf.st_ino && sf->dev == buf.st_dev)
116         return; /* Already registered.  */
117     }
118
119   sf = xmalloc (sizeof *sf);
120   sf->ino = buf.st_ino;
121   sf->dev = buf.st_dev;
122   sf->next = secured_files;
123   secured_files = sf;
124 #endif /*ENABLE_SELINUX_HACKS*/
125 }
126
127 /* Remove a file registered as secure. */
128 void
129 unregister_secured_file (const char *fname)
130 {
131 #ifdef ENABLE_SELINUX_HACKS
132   struct stat buf;
133   struct secured_file_item *sf, *sfprev;
134
135   if (stat (fname, &buf))
136     {
137       log_error (_("fstat of `%s' failed in %s: %s\n"), fname,
138                  "unregister_secured_file", strerror (errno));
139       return;
140     }
141 /*   log_debug ("unregistering `%s' i=%lu.%lu\n", fname,  */
142 /*              (unsigned long)buf.st_dev, (unsigned long)buf.st_ino); */
143   for (sfprev=NULL,sf=secured_files; sf; sfprev=sf, sf = sf->next)
144     {
145       if (sf->ino == buf.st_ino && sf->dev == buf.st_dev)
146         {
147           if (sfprev)
148             sfprev->next = sf->next;
149           else
150             secured_files = sf->next;
151           xfree (sf);
152           return;
153         }
154     }
155 #endif /*ENABLE_SELINUX_HACKS*/
156 }
157
158 /* Return true if FD is corresponds to a secured file.  Using -1 for
159    FS is allowed and will return false. */ 
160 int 
161 is_secured_file (int fd)
162 {
163 #ifdef ENABLE_SELINUX_HACKS
164   struct stat buf;
165   struct secured_file_item *sf;
166
167   if (fd == -1)
168     return 0; /* No file descriptor so it can't be secured either.  */
169
170   /* Note that we print out a error here and claim that a file is
171      secure if something went wrong. */
172   if (fstat (fd, &buf))
173     {
174       log_error (_("fstat(%d) failed in %s: %s\n"), fd, 
175                  "is_secured_file", strerror (errno));
176       return 1;
177     }
178 /*   log_debug ("is_secured_file (%d) i=%lu.%lu\n", fd, */
179 /*              (unsigned long)buf.st_dev, (unsigned long)buf.st_ino); */
180   for (sf=secured_files; sf; sf = sf->next)
181     {
182       if (sf->ino == buf.st_ino && sf->dev == buf.st_dev)
183         return 1; /* Yes.  */
184     }
185 #endif /*ENABLE_SELINUX_HACKS*/
186   return 0; /* No. */
187 }
188
189 /* Return true if FNAME is corresponds to a secured file.  Using NULL,
190    "" or "-" for FS is allowed and will return false. This function is
191    used before creating a file, thus it won't fail if the file does
192    not exist. */ 
193 int 
194 is_secured_filename (const char *fname)
195 {
196 #ifdef ENABLE_SELINUX_HACKS
197   struct stat buf;
198   struct secured_file_item *sf;
199
200   if (iobuf_is_pipe_filename (fname) || !*fname)
201     return 0; 
202
203   /* Note that we print out a error here and claim that a file is
204      secure if something went wrong. */
205   if (stat (fname, &buf))
206     {
207       if (errno == ENOENT || errno == EPERM || errno == EACCES)
208         return 0;
209       log_error (_("fstat of `%s' failed in %s: %s\n"), fname,
210                  "is_secured_filename", strerror (errno));
211       return 1;
212     }
213 /*   log_debug ("is_secured_filename (%s) i=%lu.%lu\n", fname, */
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
225
226 u16
227 checksum_u16( unsigned n )
228 {
229     u16 a;
230
231     a  = (n >> 8) & 0xff;
232     a += n & 0xff;
233     return a;
234 }
235
236
237 u16
238 checksum( byte *p, unsigned n )
239 {
240     u16 a;
241
242     for(a=0; n; n-- )
243         a += *p++;
244     return a;
245 }
246
247 u16
248 checksum_mpi (gcry_mpi_t a)
249 {
250   u16 csum;
251   byte *buffer;
252   size_t nbytes;
253
254   if ( gcry_mpi_print (GCRYMPI_FMT_PGP, NULL, 0, &nbytes, a) )
255     BUG ();
256   /* Fixme: For numbers not in secure memory we should use a stack
257    * based buffer and only allocate a larger one if mpi_print returns
258    * an error. */
259   buffer = (gcry_is_secure(a)?
260             gcry_xmalloc_secure (nbytes) : gcry_xmalloc (nbytes));
261   if ( gcry_mpi_print (GCRYMPI_FMT_PGP, buffer, nbytes, NULL, a) )
262     BUG ();
263   csum = checksum (buffer, nbytes);
264   xfree (buffer);
265   return csum;
266 }
267
268 u32
269 buffer_to_u32( const byte *buffer )
270 {
271     unsigned long a;
272     a =  *buffer << 24;
273     a |= buffer[1] << 16;
274     a |= buffer[2] << 8;
275     a |= buffer[3];
276     return a;
277 }
278
279 void
280 print_pubkey_algo_note( int algo )
281 {
282   if(algo >= 100 && algo <= 110)
283     {
284       static int warn=0;
285       if(!warn)
286         {
287           warn=1;
288           log_info (_("WARNING: using experimental public key algorithm %s\n"),
289                     gcry_pk_algo_name (algo));
290         }
291     }
292   else if (algo == 20)
293     {
294       log_info (_("WARNING: Elgamal sign+encrypt keys are deprecated\n"));
295     }
296 }
297
298 void
299 print_cipher_algo_note( int algo )
300 {
301   if(algo >= 100 && algo <= 110)
302     {
303       static int warn=0;
304       if(!warn)
305         {
306           warn=1;
307           log_info (_("WARNING: using experimental cipher algorithm %s\n"),
308                     openpgp_cipher_algo_name (algo));
309         }
310     }
311 }
312
313 void
314 print_digest_algo_note( int algo )
315 {
316   if(algo >= 100 && algo <= 110)
317     {
318       static int warn=0;
319       if(!warn)
320         {
321           warn=1;
322           log_info (_("WARNING: using experimental digest algorithm %s\n"),
323                     gcry_md_algo_name (algo));
324         }
325     }
326   else if(algo==DIGEST_ALGO_MD5)
327     log_info (_("WARNING: digest algorithm %s is deprecated\n"),
328               gcry_md_algo_name (algo));
329 }
330
331
332 /* Map OpenPGP algo numbers to those used by Libgcrypt.  We need to do
333    this for algorithms we implemented in Libgcrypt after they become
334    part of OpenPGP.  */
335 static int
336 map_cipher_openpgp_to_gcry (int algo)
337 {
338   switch (algo)
339     {
340     case CIPHER_ALGO_CAMELLIA128: return 310; 
341     case CIPHER_ALGO_CAMELLIA192: return 311; 
342     case CIPHER_ALGO_CAMELLIA256: return 312; 
343     default: return algo;
344     }
345 }
346
347 /* The inverse fucntion of above.  */
348 static int
349 map_cipher_gcry_to_openpgp (int algo)
350 {
351   switch (algo)
352     {
353     case 310: return CIPHER_ALGO_CAMELLIA128;
354     case 311: return CIPHER_ALGO_CAMELLIA192;
355     case 312: return CIPHER_ALGO_CAMELLIA256;
356     default: return algo;
357     }
358 }
359
360
361 /* Return the block length of an OpenPGP cipher algorithm.  */
362 int 
363 openpgp_cipher_blocklen (int algo)
364 {
365   /* We use the numbers from OpenPGP to be sure that we get the right
366      block length.  This is so that the packet parsing code works even
367      for unknown algorithms (for which we assume 8 due to tradition).
368
369      NOTE: If you change the the returned blocklen above 16, check
370      the callers because they may use a fixed size buffer of that
371      size. */
372   switch (algo)
373     {
374     case 7: case 8: case 9: /* AES */
375     case 10: /* Twofish */
376     case 11: case 12: case 13: /* Camellia */
377       return 16;
378
379     default:
380       return 8;
381     }
382 }
383
384 /****************
385  * Wrapper around the libgcrypt function with additonal checks on
386  * the OpenPGP contraints for the algo ID.
387  */
388 int
389 openpgp_cipher_test_algo( int algo )
390 {
391   /* (5 and 6 are marked reserved by rfc4880.)  */
392   if ( algo < 0 || algo > 110 || algo == 5 || algo == 6 )
393     return gpg_error (GPG_ERR_CIPHER_ALGO);
394
395   /* Camellia is not yet defined for OpenPGP thus only allow it if
396      requested.  */
397 #ifndef USE_CAMELLIA
398   if (algo == CIPHER_ALGO_CAMELLIA128 
399       || algo == CIPHER_ALGO_CAMELLIA192
400       || algo == CIPHER_ALGO_CAMELLIA256)
401     return gpg_error (GPG_ERR_CIPHER_ALGO);
402 #endif
403
404   return gcry_cipher_test_algo (map_cipher_openpgp_to_gcry (algo));
405 }
406
407 /* Map the OpenPGP cipher algorithm whose ID is contained in ALGORITHM to a
408    string representation of the algorithm name.  For unknown algorithm
409    IDs this function returns "?".  */
410 const char *
411 openpgp_cipher_algo_name (int algo) 
412 {
413   return gcry_cipher_algo_name (map_cipher_openpgp_to_gcry (algo));
414 }
415
416 int
417 openpgp_pk_test_algo( int algo )
418 {
419   /* Dont't allow type 20 keys unless in rfc2440 mode.  */
420   if (!RFC2440 && algo == 20)
421     return gpg_error (GPG_ERR_PUBKEY_ALGO);
422     
423   if (algo == GCRY_PK_ELG_E)
424     algo = GCRY_PK_ELG;
425
426   if (algo < 0 || algo > 110)
427     return gpg_error (GPG_ERR_PUBKEY_ALGO);
428   return gcry_pk_test_algo (algo);
429 }
430
431 int
432 openpgp_pk_test_algo2( int algo, unsigned int use )
433 {
434   size_t use_buf = use;
435
436   /* Dont't allow type 20 keys unless in rfc2440 mode.  */
437   if (!RFC2440 && algo == 20)
438     return gpg_error (GPG_ERR_PUBKEY_ALGO);
439
440   if (algo == GCRY_PK_ELG_E)
441     algo = GCRY_PK_ELG;
442
443   if (algo < 0 || algo > 110)
444     return gpg_error (GPG_ERR_PUBKEY_ALGO);
445
446   return gcry_pk_algo_info (algo, GCRYCTL_TEST_ALGO, NULL, &use_buf);
447 }
448
449 int 
450 openpgp_pk_algo_usage ( int algo )
451 {
452     int use = 0; 
453     
454     /* They are hardwired in gpg 1.0. */
455     switch ( algo ) {    
456       case PUBKEY_ALGO_RSA:
457           use = (PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG
458                  | PUBKEY_USAGE_ENC | PUBKEY_USAGE_AUTH);
459           break;
460       case PUBKEY_ALGO_RSA_E:
461           use = PUBKEY_USAGE_ENC;
462           break;
463       case PUBKEY_ALGO_RSA_S:
464           use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG;
465           break;
466       case PUBKEY_ALGO_ELGAMAL:
467           if (RFC2440)
468              use = PUBKEY_USAGE_ENC;
469           break;
470       case PUBKEY_ALGO_ELGAMAL_E:
471           use = PUBKEY_USAGE_ENC;
472           break;
473       case PUBKEY_ALGO_DSA:  
474           use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG | PUBKEY_USAGE_AUTH;
475           break;
476       default:
477           break;
478     }
479     return use;
480 }
481
482 int
483 openpgp_md_test_algo( int algo )
484 {
485   /* Note: If the list of actual supported OpenPGP algorithms changes,
486      make sure that our hard coded values at
487      print_status_begin_signing() gets updated. */
488   /* 4, 5, 6, 7 are defined by rfc2440 but will be removed from the
489      next revision of the standard.  */
490   if (algo < 0 || algo > 110 || (algo >= 4 && algo <= 7))
491     return gpg_error (GPG_ERR_DIGEST_ALGO);
492   return gcry_md_test_algo (algo);
493 }
494
495 #ifdef USE_IDEA
496 /* Special warning for the IDEA cipher */
497 void
498 idea_cipher_warn(int show)
499 {
500   static int warned=0;
501
502   if(!warned || show)
503     {
504       log_info(_("the IDEA cipher plugin is not present\n"));
505       log_info(_("please see %s for more information\n"),
506                "http://www.gnupg.org/faq/why-not-idea.html");
507       warned=1;
508     }
509 }
510 #endif
511
512
513 static unsigned long 
514 get_signature_count (PKT_secret_key *sk)
515 {
516 #ifdef ENABLE_CARD_SUPPORT
517   if(sk && sk->is_protected && sk->protect.s2k.mode==1002)
518     {
519       struct agent_card_info_s info;
520       if(agent_scd_getattr("SIG-COUNTER",&info)==0)
521         return info.sig_counter;
522     }  
523 #endif
524
525   /* How to do this without a card? */
526
527   return 0;
528 }
529
530 /* Expand %-strings.  Returns a string which must be xfreed.  Returns
531    NULL if the string cannot be expanded (too large). */
532 char *
533 pct_expando(const char *string,struct expando_args *args)
534 {
535   const char *ch=string;
536   int idx=0,maxlen=0,done=0;
537   u32 pk_keyid[2]={0,0},sk_keyid[2]={0,0};
538   char *ret=NULL;
539
540   if(args->pk)
541     keyid_from_pk(args->pk,pk_keyid);
542
543   if(args->sk)
544     keyid_from_sk(args->sk,sk_keyid);
545
546   /* This is used so that %k works in photoid command strings in
547      --list-secret-keys (which of course has a sk, but no pk). */
548   if(!args->pk && args->sk)
549     keyid_from_sk(args->sk,pk_keyid);
550
551   while(*ch!='\0')
552     {
553       char *str=NULL;
554
555       if(!done)
556         {
557           /* 8192 is way bigger than we'll need here */
558           if(maxlen>=8192)
559             goto fail;
560
561           maxlen+=1024;
562           ret=xrealloc(ret,maxlen);
563         }
564
565       done=0;
566
567       if(*ch=='%')
568         {
569           switch(*(ch+1))
570             {
571             case 's': /* short key id */
572               if(idx+8<maxlen)
573                 {
574                   sprintf(&ret[idx],"%08lX",(ulong)sk_keyid[1]);
575                   idx+=8;
576                   done=1;
577                 }
578               break;
579
580             case 'S': /* long key id */
581               if(idx+16<maxlen)
582                 {
583                   sprintf(&ret[idx],"%08lX%08lX",
584                           (ulong)sk_keyid[0],(ulong)sk_keyid[1]);
585                   idx+=16;
586                   done=1;
587                 }
588               break;
589
590             case 'k': /* short key id */
591               if(idx+8<maxlen)
592                 {
593                   sprintf(&ret[idx],"%08lX",(ulong)pk_keyid[1]);
594                   idx+=8;
595                   done=1;
596                 }
597               break;
598
599             case 'K': /* long key id */
600               if(idx+16<maxlen)
601                 {
602                   sprintf(&ret[idx],"%08lX%08lX",
603                           (ulong)pk_keyid[0],(ulong)pk_keyid[1]);
604                   idx+=16;
605                   done=1;
606                 }
607               break;
608
609             case 'c': /* signature count from card, if any. */
610               if(idx+10<maxlen)
611                 {
612                   sprintf(&ret[idx],"%lu",get_signature_count(args->sk));
613                   idx+=strlen(&ret[idx]);
614                   done=1;
615                 }             
616               break;
617
618             case 'p': /* primary pk fingerprint of a sk */
619             case 'f': /* pk fingerprint */
620             case 'g': /* sk fingerprint */
621               {
622                 byte array[MAX_FINGERPRINT_LEN];
623                 size_t len;
624                 int i;
625
626                 if((*(ch+1))=='p' && args->sk)
627                   {
628                     if(args->sk->is_primary)
629                       fingerprint_from_sk(args->sk,array,&len);
630                     else if(args->sk->main_keyid[0] || args->sk->main_keyid[1])
631                       {
632                         PKT_public_key *pk=
633                           xmalloc_clear(sizeof(PKT_public_key));
634
635                         if(get_pubkey_fast(pk,args->sk->main_keyid)==0)
636                           fingerprint_from_pk(pk,array,&len);
637                         else
638                           memset(array,0,(len=MAX_FINGERPRINT_LEN));
639                         free_public_key(pk);
640                       }
641                     else
642                       memset(array,0,(len=MAX_FINGERPRINT_LEN));
643                   }
644                 else if((*(ch+1))=='f' && args->pk)
645                   fingerprint_from_pk(args->pk,array,&len);
646                 else if((*(ch+1))=='g' && args->sk)
647                   fingerprint_from_sk(args->sk,array,&len);
648                 else
649                   memset(array,0,(len=MAX_FINGERPRINT_LEN));
650
651                 if(idx+(len*2)<maxlen)
652                   {
653                     for(i=0;i<len;i++)
654                       {
655                         sprintf(&ret[idx],"%02X",array[i]);
656                         idx+=2;
657                       }
658                     done=1;
659                   }
660               }
661               break;
662
663             case 't': /* e.g. "jpg" */
664               str=image_type_to_string(args->imagetype,0);
665               /* fall through */
666
667             case 'T': /* e.g. "image/jpeg" */
668               if(str==NULL)
669                 str=image_type_to_string(args->imagetype,2);
670
671               if(idx+strlen(str)<maxlen)
672                 {
673                   strcpy(&ret[idx],str);
674                   idx+=strlen(str);
675                   done=1;
676                 }
677               break;
678
679             case '%':
680               if(idx+1<maxlen)
681                 {
682                   ret[idx++]='%';
683                   ret[idx]='\0';
684                   done=1;
685                 }
686               break;
687
688               /* Any unknown %-keys (like %i, %o, %I, and %O) are
689                  passed through for later expansion.  Note this also
690                  handles the case where the last character in the
691                  string is a '%' - the terminating \0 will end up here
692                  and properly terminate the string. */
693             default:
694               if(idx+2<maxlen)
695                 {
696                   ret[idx++]='%';
697                   ret[idx++]=*(ch+1);
698                   ret[idx]='\0';
699                   done=1;
700                 }
701               break;
702               }
703
704           if(done)
705             ch++;
706         }
707       else
708         {
709           if(idx+1<maxlen)
710             {
711               ret[idx++]=*ch;
712               ret[idx]='\0';
713               done=1;
714             }
715         }
716
717       if(done)
718         ch++;
719     }
720
721   return ret;
722
723  fail:
724   xfree(ret);
725   return NULL;
726 }
727
728 void
729 deprecated_warning(const char *configname,unsigned int configlineno,
730                    const char *option,const char *repl1,const char *repl2)
731 {
732   if(configname)
733     {
734       if(strncmp("--",option,2)==0)
735         option+=2;
736
737       if(strncmp("--",repl1,2)==0)
738         repl1+=2;
739
740       log_info(_("%s:%d: deprecated option \"%s\"\n"),
741                configname,configlineno,option);
742     }
743   else
744     log_info(_("WARNING: \"%s\" is a deprecated option\n"),option);
745
746   log_info(_("please use \"%s%s\" instead\n"),repl1,repl2);
747 }
748
749
750 void
751 deprecated_command (const char *name)
752 {
753   log_info(_("WARNING: \"%s\" is a deprecated command - do not use it\n"),
754            name);
755 }
756
757
758 void
759 obsolete_option (const char *configname, unsigned int configlineno, 
760                  const char *name)
761 {
762   if(configname)
763     log_info (_("%s:%u: obsolete option \"%s\" - it has no effect\n"),
764               configname, configlineno, name);
765   else
766     log_info (_("WARNING: \"%s\" is an obsolete option - it has no effect\n"),
767               name);
768 }
769
770
771 /*
772  * Wrapper around gcry_cipher_map_name to provide a fallback using the
773  * "Sn" syntax as used by the preference strings.
774  */
775 int 
776 string_to_cipher_algo (const char *string) 
777
778   int val;
779
780   val = map_cipher_gcry_to_openpgp (gcry_cipher_map_name (string));
781   if (!val && string && (string[0]=='S' || string[0]=='s'))
782     {
783       char *endptr;
784
785       string++;
786       val = strtol (string, &endptr, 10);
787       if (!*string || *endptr || openpgp_cipher_test_algo (val))
788         val = 0;
789     }
790
791   return val;
792 }
793
794 /*
795  * Wrapper around gcry_md_map_name to provide a fallback using the
796  * "Hn" syntax as used by the preference strings.
797  */
798 int 
799 string_to_digest_algo (const char *string) 
800
801   int val;
802
803   val = gcry_md_map_name (string);
804   if (!val && string && (string[0]=='H' || string[0]=='h'))
805     {
806       char *endptr;
807
808       string++;
809       val = strtol (string, &endptr, 10);
810       if (!*string || *endptr || openpgp_md_test_algo (val))
811         val = 0;
812     }
813
814   return val;
815 }
816
817
818
819 const char *
820 compress_algo_to_string(int algo)
821 {
822   const char *s=NULL;
823
824   switch(algo)
825     {
826     case COMPRESS_ALGO_NONE:
827       s=_("Uncompressed");
828       break;
829
830     case COMPRESS_ALGO_ZIP:
831       s="ZIP";
832       break;
833
834     case COMPRESS_ALGO_ZLIB:
835       s="ZLIB";
836       break;
837
838 #ifdef HAVE_BZIP2
839     case COMPRESS_ALGO_BZIP2:
840       s="BZIP2";
841       break;
842 #endif
843     }
844
845   return s;
846 }
847
848 int
849 string_to_compress_algo(const char *string)
850 {
851   /* TRANSLATORS: See doc/TRANSLATE about this string. */
852   if(match_multistr(_("uncompressed|none"),string))
853     return 0;
854   else if(ascii_strcasecmp(string,"uncompressed")==0)
855     return 0;
856   else if(ascii_strcasecmp(string,"none")==0)
857     return 0;
858   else if(ascii_strcasecmp(string,"zip")==0)
859     return 1;
860   else if(ascii_strcasecmp(string,"zlib")==0)
861     return 2;
862 #ifdef HAVE_BZIP2
863   else if(ascii_strcasecmp(string,"bzip2")==0)
864     return 3;
865 #endif
866   else if(ascii_strcasecmp(string,"z0")==0)
867     return 0;
868   else if(ascii_strcasecmp(string,"z1")==0)
869     return 1;
870   else if(ascii_strcasecmp(string,"z2")==0)
871     return 2;
872 #ifdef HAVE_BZIP2
873   else if(ascii_strcasecmp(string,"z3")==0)
874     return 3;
875 #endif
876   else
877     return -1;
878 }
879
880 int
881 check_compress_algo(int algo)
882 {
883 #ifdef HAVE_BZIP2
884   if(algo>=0 && algo<=3)
885     return 0;
886 #else
887   if(algo>=0 && algo<=2)
888     return 0;
889 #endif
890
891   return G10ERR_COMPR_ALGO;
892 }
893
894 int
895 default_cipher_algo(void)
896 {
897   if(opt.def_cipher_algo)
898     return opt.def_cipher_algo;
899   else if(opt.personal_cipher_prefs)
900     return opt.personal_cipher_prefs[0].value;
901   else
902     return opt.s2k_cipher_algo;
903 }
904
905 /* There is no default_digest_algo function, but see
906    sign.c:hash_for() */
907
908 int
909 default_compress_algo(void)
910 {
911   if(opt.compress_algo!=-1)
912     return opt.compress_algo;
913   else if(opt.personal_compress_prefs)
914     return opt.personal_compress_prefs[0].value;
915   else
916     return DEFAULT_COMPRESS_ALGO;
917 }
918
919 const char *
920 compliance_option_string(void)
921 {
922   char *ver="???";
923
924   switch(opt.compliance)
925     {
926     case CO_GNUPG:   return "--gnupg";
927     case CO_RFC4880: return "--openpgp";
928     case CO_RFC2440: return "--rfc2440";
929     case CO_RFC1991: return "--rfc1991";
930     case CO_PGP2:    return "--pgp2";
931     case CO_PGP6:    return "--pgp6";
932     case CO_PGP7:    return "--pgp7";
933     case CO_PGP8:    return "--pgp8";
934     }
935
936   return ver;
937 }
938
939 void
940 compliance_failure(void)
941 {
942   char *ver="???";
943
944   switch(opt.compliance)
945     {
946     case CO_GNUPG:
947       ver="GnuPG";
948       break;
949
950     case CO_RFC4880:
951       ver="OpenPGP";
952       break;
953
954     case CO_RFC2440:
955       ver="OpenPGP (older)";
956       break;
957
958     case CO_RFC1991:
959       ver="old PGP";
960       break;
961
962     case CO_PGP2:
963       ver="PGP 2.x";
964       break;
965
966     case CO_PGP6:
967       ver="PGP 6.x";
968       break;
969
970     case CO_PGP7:
971       ver="PGP 7.x";
972       break;
973
974     case CO_PGP8:
975       ver="PGP 8.x";
976       break;
977     }
978
979   log_info(_("this message may not be usable by %s\n"),ver);
980   opt.compliance=CO_GNUPG;
981 }
982
983 /* Break a string into successive option pieces.  Accepts single word
984    options and key=value argument options. */
985 char *
986 optsep(char **stringp)
987 {
988   char *tok,*end;
989
990   tok=*stringp;
991   if(tok)
992     {
993       end=strpbrk(tok," ,=");
994       if(end)
995         {
996           int sawequals=0;
997           char *ptr=end;
998
999           /* what we need to do now is scan along starting with *end,
1000              If the next character we see (ignoring spaces) is an =
1001              sign, then there is an argument. */
1002
1003           while(*ptr)
1004             {
1005               if(*ptr=='=')
1006                 sawequals=1;
1007               else if(*ptr!=' ')
1008                 break;
1009               ptr++;
1010             }
1011
1012           /* There is an argument, so grab that too.  At this point,
1013              ptr points to the first character of the argument. */
1014           if(sawequals)
1015             {
1016               /* Is it a quoted argument? */
1017               if(*ptr=='"')
1018                 {
1019                   ptr++;
1020                   end=strchr(ptr,'"');
1021                   if(end)
1022                     end++;
1023                 }
1024               else
1025                 end=strpbrk(ptr," ,");
1026             }
1027
1028           if(end && *end)
1029             {
1030               *end='\0';
1031               *stringp=end+1;
1032             }
1033           else
1034             *stringp=NULL;
1035         }
1036       else
1037         *stringp=NULL;
1038     }
1039
1040   return tok;
1041 }
1042
1043 /* Breaks an option value into key and value.  Returns NULL if there
1044    is no value.  Note that "string" is modified to remove the =value
1045    part. */
1046 char *
1047 argsplit(char *string)
1048 {
1049   char *equals,*arg=NULL;
1050
1051   equals=strchr(string,'=');
1052   if(equals)
1053     {
1054       char *quote,*space;
1055
1056       *equals='\0';
1057       arg=equals+1;
1058
1059       /* Quoted arg? */
1060       quote=strchr(arg,'"');
1061       if(quote)
1062         {
1063           arg=quote+1;
1064
1065           quote=strchr(arg,'"');
1066           if(quote)
1067             *quote='\0';
1068         }
1069       else
1070         {
1071           size_t spaces;
1072
1073           /* Trim leading spaces off of the arg */
1074           spaces=strspn(arg," ");
1075           arg+=spaces;
1076         }
1077
1078       /* Trim tailing spaces off of the tag */
1079       space=strchr(string,' ');
1080       if(space)
1081         *space='\0';
1082     }
1083
1084   return arg;
1085 }
1086
1087 /* Return the length of the initial token, leaving off any
1088    argument. */
1089 static size_t
1090 optlen(const char *s)
1091 {
1092   char *end=strpbrk(s," =");
1093
1094   if(end)
1095     return end-s;
1096   else
1097     return strlen(s);
1098 }
1099
1100 int
1101 parse_options(char *str,unsigned int *options,
1102               struct parse_options *opts,int noisy)
1103 {
1104   char *tok;
1105
1106   if (str && !strcmp (str, "help"))
1107     {
1108       int i,maxlen=0;
1109
1110       /* Figure out the longest option name so we can line these up
1111          neatly. */
1112       for(i=0;opts[i].name;i++)
1113         if(opts[i].help && maxlen<strlen(opts[i].name))
1114           maxlen=strlen(opts[i].name);
1115
1116       for(i=0;opts[i].name;i++)
1117         if(opts[i].help)
1118           printf("%s%*s%s\n",opts[i].name,
1119                  maxlen+2-(int)strlen(opts[i].name),"",_(opts[i].help));
1120
1121       g10_exit(0);
1122     }
1123
1124   while((tok=optsep(&str)))
1125     {
1126       int i,rev=0;
1127       char *otok=tok;
1128
1129       if(tok[0]=='\0')
1130         continue;
1131
1132       if(ascii_strncasecmp("no-",tok,3)==0)
1133         {
1134           rev=1;
1135           tok+=3;
1136         }
1137
1138       for(i=0;opts[i].name;i++)
1139         {
1140           size_t toklen=optlen(tok);
1141
1142           if(ascii_strncasecmp(opts[i].name,tok,toklen)==0)
1143             {
1144               /* We have a match, but it might be incomplete */
1145               if(toklen!=strlen(opts[i].name))
1146                 {
1147                   int j;
1148
1149                   for(j=i+1;opts[j].name;j++)
1150                     {
1151                       if(ascii_strncasecmp(opts[j].name,tok,toklen)==0)
1152                         {
1153                           if(noisy)
1154                             log_info(_("ambiguous option `%s'\n"),otok);
1155                           return 0;
1156                         }
1157                     }
1158                 }
1159
1160               if(rev)
1161                 {
1162                   *options&=~opts[i].bit;
1163                   if(opts[i].value)
1164                     *opts[i].value=NULL;
1165                 }
1166               else
1167                 {
1168                   *options|=opts[i].bit;
1169                   if(opts[i].value)
1170                     *opts[i].value=argsplit(tok);
1171                 }
1172               break;
1173             }
1174         }
1175
1176       if(!opts[i].name)
1177         {
1178           if(noisy)
1179             log_info(_("unknown option `%s'\n"),otok);
1180           return 0;
1181         }
1182     }
1183
1184   return 1;
1185 }
1186
1187
1188 /* Return a new malloced string by unescaping the string S.  Escaping
1189    is percent escaping and '+'/space mapping.  A binary nul will
1190    silently be replaced by a 0xFF. */
1191 char *
1192 unescape_percent_string (const unsigned char *s)
1193 {
1194   char *buffer, *d;
1195
1196   buffer = d = xmalloc (strlen (s)+1);
1197   while (*s)
1198     {
1199       if (*s == '%' && s[1] && s[2])
1200         { 
1201           s++;
1202           *d = xtoi_2 (s);
1203           if (!*d)
1204             *d = '\xff';
1205           d++;
1206           s += 2;
1207         }
1208       else if (*s == '+')
1209         {
1210           *d++ = ' ';
1211           s++;
1212         }
1213       else
1214         *d++ = *s++;
1215     }
1216   *d = 0; 
1217   return buffer;
1218 }
1219
1220
1221 int
1222 has_invalid_email_chars (const char *s)
1223 {
1224   int at_seen=0;
1225   const char *valid_chars=
1226     "01234567890_-.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
1227
1228   for ( ; *s; s++ ) 
1229     {
1230       if ( *s & 0x80 )
1231         return 1;
1232       if ( *s == '@' )
1233         at_seen=1;
1234       else if ( !at_seen && !( !!strchr( valid_chars, *s ) || *s == '+' ) )
1235         return 1;
1236       else if ( at_seen && !strchr( valid_chars, *s ) )
1237         return 1;
1238     }
1239   return 0;
1240 }
1241
1242
1243 /* Check whether NAME represents a valid mailbox according to
1244    RFC822. Returns true if so. */
1245 int
1246 is_valid_mailbox (const char *name)
1247 {
1248   return !( !name
1249             || !*name
1250             || has_invalid_email_chars (name)
1251             || string_count_chr (name,'@') != 1
1252             || *name == '@'
1253             || name[strlen(name)-1] == '@'
1254             || name[strlen(name)-1] == '.'
1255             || strstr (name, "..") );
1256 }
1257
1258
1259 /* Similar to access(2), but uses PATH to find the file. */
1260 int
1261 path_access(const char *file,int mode)
1262 {
1263   char *envpath;
1264   int ret=-1;
1265
1266   envpath=getenv("PATH");
1267
1268   if(!envpath
1269 #ifdef HAVE_DRIVE_LETTERS
1270      || (((file[0]>='A' && file[0]<='Z')
1271           || (file[0]>='a' && file[0]<='z'))
1272          && file[1]==':')
1273 #else
1274      || file[0]=='/'
1275 #endif
1276      )
1277     return access(file,mode);
1278   else
1279     {
1280       /* At least as large as, but most often larger than we need. */
1281       char *buffer=xmalloc(strlen(envpath)+1+strlen(file)+1);
1282       char *split,*item,*path=xstrdup(envpath);
1283
1284       split=path;
1285
1286       while((item=strsep(&split,PATHSEP_S)))
1287         {
1288           strcpy(buffer,item);
1289           strcat(buffer,"/");
1290           strcat(buffer,file);
1291           ret=access(buffer,mode);
1292           if(ret==0)
1293             break;
1294         }
1295
1296       xfree(path);
1297       xfree(buffer);
1298     }
1299
1300   return ret;
1301 }
1302
1303
1304 \f
1305 /* Temporary helper. */
1306 int
1307 pubkey_get_npkey( int algo )
1308 {
1309   size_t n;
1310
1311   if (algo == GCRY_PK_ELG_E)
1312     algo = GCRY_PK_ELG;
1313   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NPKEY, NULL, &n))
1314     n = 0;
1315   return n;
1316 }
1317
1318 /* Temporary helper. */
1319 int
1320 pubkey_get_nskey( int algo )
1321 {
1322   size_t n;
1323
1324   if (algo == GCRY_PK_ELG_E)
1325     algo = GCRY_PK_ELG;
1326   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NSKEY, NULL, &n ))
1327     n = 0;
1328   return n;
1329 }
1330
1331 /* Temporary helper. */
1332 int
1333 pubkey_get_nsig( int algo )
1334 {
1335   size_t n;
1336
1337   if (algo == GCRY_PK_ELG_E)
1338     algo = GCRY_PK_ELG;
1339   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NSIGN, NULL, &n))
1340     n = 0;
1341   return n;
1342 }
1343
1344 /* Temporary helper. */
1345 int
1346 pubkey_get_nenc( int algo )
1347 {
1348   size_t n;
1349   
1350   if (algo == GCRY_PK_ELG_E)
1351     algo = GCRY_PK_ELG;
1352   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NENCR, NULL, &n ))
1353     n = 0;
1354   return n;
1355 }
1356
1357
1358 /* Temporary helper. */
1359 unsigned int
1360 pubkey_nbits( int algo, gcry_mpi_t *key )
1361 {
1362     int rc, nbits;
1363     gcry_sexp_t sexp;
1364
1365     if( algo == GCRY_PK_DSA ) {
1366         rc = gcry_sexp_build ( &sexp, NULL,
1367                               "(public-key(dsa(p%m)(q%m)(g%m)(y%m)))",
1368                                   key[0], key[1], key[2], key[3] );
1369     }
1370     else if( algo == GCRY_PK_ELG || algo == GCRY_PK_ELG_E ) {
1371         rc = gcry_sexp_build ( &sexp, NULL,
1372                               "(public-key(elg(p%m)(g%m)(y%m)))",
1373                                   key[0], key[1], key[2] );
1374     }
1375     else if( algo == GCRY_PK_RSA ) {
1376         rc = gcry_sexp_build ( &sexp, NULL,
1377                               "(public-key(rsa(n%m)(e%m)))",
1378                                   key[0], key[1] );
1379     }
1380     else
1381         return 0;
1382
1383     if ( rc )
1384         BUG ();
1385
1386     nbits = gcry_pk_get_nbits( sexp );
1387     gcry_sexp_release( sexp );
1388     return nbits;
1389 }
1390
1391
1392
1393 /* FIXME: Use gcry_mpi_print directly. */
1394 int
1395 mpi_print( FILE *fp, gcry_mpi_t a, int mode )
1396 {
1397     int n=0;
1398
1399     if( !a )
1400         return fprintf(fp, "[MPI_NULL]");
1401     if( !mode ) {
1402         unsigned int n1;
1403         n1 = gcry_mpi_get_nbits(a);
1404         n += fprintf(fp, "[%u bits]", n1);
1405     }
1406     else {
1407         unsigned char *buffer;
1408
1409         if (gcry_mpi_aprint (GCRYMPI_FMT_HEX, &buffer, NULL, a))
1410           BUG ();
1411         fputs( buffer, fp );
1412         n += strlen(buffer);
1413         gcry_free( buffer );
1414     }
1415     return n;
1416 }
1417