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