Import OpenPGP keys into the agent.
[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 /* Map the OpenPGP pubkey algorithm whose ID is contained in ALGO to a
482    string representation of the algorithm name.  For unknown algorithm
483    IDs this function returns "?".  */
484 const char *
485 openpgp_pk_algo_name (int algo) 
486 {
487   switch (algo)
488     {    
489     case PUBKEY_ALGO_RSA:
490     case PUBKEY_ALGO_RSA_E:
491     case PUBKEY_ALGO_RSA_S: return "rsa";
492
493     case PUBKEY_ALGO_ELGAMAL:
494     case PUBKEY_ALGO_ELGAMAL_E: return "elg";
495
496     case PUBKEY_ALGO_DSA:  return "dsa";
497
498     default: return "?";
499     }
500 }
501
502
503 int
504 openpgp_md_test_algo( int algo )
505 {
506   /* Note: If the list of actual supported OpenPGP algorithms changes,
507      make sure that our hard coded values at
508      print_status_begin_signing() gets updated. */
509   /* 4, 5, 6, 7 are defined by rfc2440 but will be removed from the
510      next revision of the standard.  */
511   if (algo < 0 || algo > 110 || (algo >= 4 && algo <= 7))
512     return gpg_error (GPG_ERR_DIGEST_ALGO);
513   return gcry_md_test_algo (algo);
514 }
515
516
517 /* Map the OpenPGP digest algorithm whose ID is contained in ALGO to a
518    string representation of the algorithm name.  For unknown algorithm
519    IDs this function returns "?".  */
520 const char *
521 openpgp_md_algo_name (int algo) 
522 {
523   if (algo < 0 || algo > 110)
524     return "?";
525   return gcry_md_algo_name (algo);
526 }
527
528
529 #ifdef USE_IDEA
530 /* Special warning for the IDEA cipher */
531 void
532 idea_cipher_warn(int show)
533 {
534   static int warned=0;
535
536   if(!warned || show)
537     {
538       log_info(_("the IDEA cipher plugin is not present\n"));
539       log_info(_("please see %s for more information\n"),
540                "http://www.gnupg.org/faq/why-not-idea.html");
541       warned=1;
542     }
543 }
544 #endif
545
546
547 static unsigned long 
548 get_signature_count (PKT_public_key *pk)
549 {
550 #ifdef ENABLE_CARD_SUPPORT
551   /* FIXME: Need to call the agent.  */
552   /* if(sk && sk->is_protected && sk->protect.s2k.mode==1002) */
553   /*   { */
554   /*     struct agent_card_info_s info; */
555   /*     if(agent_scd_getattr("SIG-COUNTER",&info)==0) */
556   /*       return info.sig_counter; */
557   /*   }   */
558 #endif
559
560   /* How to do this without a card? */
561
562   return 0;
563 }
564
565 /* Expand %-strings.  Returns a string which must be xfreed.  Returns
566    NULL if the string cannot be expanded (too large). */
567 char *
568 pct_expando(const char *string,struct expando_args *args)
569 {
570   const char *ch=string;
571   int idx=0,maxlen=0,done=0;
572   u32 pk_keyid[2]={0,0},sk_keyid[2]={0,0};
573   char *ret=NULL;
574
575   if(args->pk)
576     keyid_from_pk(args->pk,pk_keyid);
577
578   if(args->pksk)
579     keyid_from_pk (args->pksk, sk_keyid);
580
581   /* This is used so that %k works in photoid command strings in
582      --list-secret-keys (which of course has a sk, but no pk). */
583   if(!args->pk && args->pksk)
584     keyid_from_pk (args->pksk, pk_keyid);
585
586   while(*ch!='\0')
587     {
588       if(!done)
589         {
590           /* 8192 is way bigger than we'll need here */
591           if(maxlen>=8192)
592             goto fail;
593
594           maxlen+=1024;
595           ret=xrealloc(ret,maxlen);
596         }
597
598       done=0;
599
600       if(*ch=='%')
601         {
602           switch(*(ch+1))
603             {
604             case 's': /* short key id */
605               if(idx+8<maxlen)
606                 {
607                   sprintf(&ret[idx],"%08lX",(ulong)sk_keyid[1]);
608                   idx+=8;
609                   done=1;
610                 }
611               break;
612
613             case 'S': /* long key id */
614               if(idx+16<maxlen)
615                 {
616                   sprintf(&ret[idx],"%08lX%08lX",
617                           (ulong)sk_keyid[0],(ulong)sk_keyid[1]);
618                   idx+=16;
619                   done=1;
620                 }
621               break;
622
623             case 'k': /* short key id */
624               if(idx+8<maxlen)
625                 {
626                   sprintf(&ret[idx],"%08lX",(ulong)pk_keyid[1]);
627                   idx+=8;
628                   done=1;
629                 }
630               break;
631
632             case 'K': /* long key id */
633               if(idx+16<maxlen)
634                 {
635                   sprintf(&ret[idx],"%08lX%08lX",
636                           (ulong)pk_keyid[0],(ulong)pk_keyid[1]);
637                   idx+=16;
638                   done=1;
639                 }
640               break;
641
642             case 'c': /* signature count from card, if any. */
643               if(idx+10<maxlen)
644                 {
645                   sprintf (&ret[idx],"%lu", get_signature_count (args->pksk));
646                   idx+=strlen(&ret[idx]);
647                   done=1;
648                 }             
649               break;
650
651             case 'p': /* primary pk fingerprint of a sk */
652             case 'f': /* pk fingerprint */
653             case 'g': /* sk fingerprint */
654               {
655                 byte array[MAX_FINGERPRINT_LEN];
656                 size_t len;
657                 int i;
658
659                 if((*(ch+1))=='p' && args->pksk)
660                   {
661                     if(args->pksk->is_primary)
662                       fingerprint_from_pk (args->pksk, array, &len);
663                     else if (args->pksk->main_keyid[0]
664                              || args->pksk->main_keyid[1])
665                       {
666                         /* FIXME: Document teh code and check whether
667                            it is still needed.  */
668                         PKT_public_key *pk=
669                           xmalloc_clear(sizeof(PKT_public_key));
670
671                         if (!get_pubkey_fast (pk,args->pksk->main_keyid))
672                           fingerprint_from_pk (pk, array, &len);
673                         else
674                           memset (array, 0, (len=MAX_FINGERPRINT_LEN));
675                         free_public_key (pk);
676                       }
677                     else
678                       memset(array,0,(len=MAX_FINGERPRINT_LEN));
679                   }
680                 else if((*(ch+1))=='f' && args->pk)
681                   fingerprint_from_pk (args->pk, array, &len);
682                 else if((*(ch+1))=='g' && args->pksk)
683                   fingerprint_from_pk (args->pksk, array, &len);
684                 else
685                   memset(array,0,(len=MAX_FINGERPRINT_LEN));
686
687                 if(idx+(len*2)<maxlen)
688                   {
689                     for(i=0;i<len;i++)
690                       {
691                         sprintf(&ret[idx],"%02X",array[i]);
692                         idx+=2;
693                       }
694                     done=1;
695                   }
696               }
697               break;
698
699             case 'v': /* validity letters */
700               if(args->validity_info && idx+1<maxlen)
701                 {
702                   ret[idx++]=args->validity_info;
703                   ret[idx]='\0';
704                   done=1;
705                 }
706               break;
707
708               /* The text string types */
709             case 't':
710             case 'T':
711             case 'V':
712               {
713                 const char *str=NULL;
714
715                 switch(*(ch+1))
716                   {
717                   case 't': /* e.g. "jpg" */
718                     str=image_type_to_string(args->imagetype,0);
719                     break;
720                   
721                   case 'T': /* e.g. "image/jpeg" */
722                     str=image_type_to_string(args->imagetype,2);
723                     break;
724
725                   case 'V': /* e.g. "full", "expired", etc. */
726                     str=args->validity_string;
727                     break;
728                   }
729
730                 if(str && idx+strlen(str)<maxlen)
731                   {
732                     strcpy(&ret[idx],str);
733                     idx+=strlen(str);
734                     done=1;
735                   }
736               }
737               break;
738
739             case '%':
740               if(idx+1<maxlen)
741                 {
742                   ret[idx++]='%';
743                   ret[idx]='\0';
744                   done=1;
745                 }
746               break;
747
748               /* Any unknown %-keys (like %i, %o, %I, and %O) are
749                  passed through for later expansion.  Note this also
750                  handles the case where the last character in the
751                  string is a '%' - the terminating \0 will end up here
752                  and properly terminate the string. */
753             default:
754               if(idx+2<maxlen)
755                 {
756                   ret[idx++]='%';
757                   ret[idx++]=*(ch+1);
758                   ret[idx]='\0';
759                   done=1;
760                 }
761               break;
762               }
763
764           if(done)
765             ch++;
766         }
767       else
768         {
769           if(idx+1<maxlen)
770             {
771               ret[idx++]=*ch;
772               ret[idx]='\0';
773               done=1;
774             }
775         }
776
777       if(done)
778         ch++;
779     }
780
781   return ret;
782
783  fail:
784   xfree(ret);
785   return NULL;
786 }
787
788 void
789 deprecated_warning(const char *configname,unsigned int configlineno,
790                    const char *option,const char *repl1,const char *repl2)
791 {
792   if(configname)
793     {
794       if(strncmp("--",option,2)==0)
795         option+=2;
796
797       if(strncmp("--",repl1,2)==0)
798         repl1+=2;
799
800       log_info(_("%s:%d: deprecated option \"%s\"\n"),
801                configname,configlineno,option);
802     }
803   else
804     log_info(_("WARNING: \"%s\" is a deprecated option\n"),option);
805
806   log_info(_("please use \"%s%s\" instead\n"),repl1,repl2);
807 }
808
809
810 void
811 deprecated_command (const char *name)
812 {
813   log_info(_("WARNING: \"%s\" is a deprecated command - do not use it\n"),
814            name);
815 }
816
817
818 void
819 obsolete_option (const char *configname, unsigned int configlineno, 
820                  const char *name)
821 {
822   if(configname)
823     log_info (_("%s:%u: obsolete option \"%s\" - it has no effect\n"),
824               configname, configlineno, name);
825   else
826     log_info (_("WARNING: \"%s\" is an obsolete option - it has no effect\n"),
827               name);
828 }
829
830
831 /*
832  * Wrapper around gcry_cipher_map_name to provide a fallback using the
833  * "Sn" syntax as used by the preference strings.
834  */
835 int 
836 string_to_cipher_algo (const char *string) 
837
838   int val;
839
840   val = map_cipher_gcry_to_openpgp (gcry_cipher_map_name (string));
841   if (!val && string && (string[0]=='S' || string[0]=='s'))
842     {
843       char *endptr;
844
845       string++;
846       val = strtol (string, &endptr, 10);
847       if (!*string || *endptr || openpgp_cipher_test_algo (val))
848         val = 0;
849     }
850
851   return val;
852 }
853
854 /*
855  * Wrapper around gcry_md_map_name to provide a fallback using the
856  * "Hn" syntax as used by the preference strings.
857  */
858 int 
859 string_to_digest_algo (const char *string) 
860
861   int val;
862
863   val = gcry_md_map_name (string);
864   if (!val && string && (string[0]=='H' || string[0]=='h'))
865     {
866       char *endptr;
867
868       string++;
869       val = strtol (string, &endptr, 10);
870       if (!*string || *endptr || openpgp_md_test_algo (val))
871         val = 0;
872     }
873
874   return val;
875 }
876
877
878
879 const char *
880 compress_algo_to_string(int algo)
881 {
882   const char *s=NULL;
883
884   switch(algo)
885     {
886     case COMPRESS_ALGO_NONE:
887       s=_("Uncompressed");
888       break;
889
890     case COMPRESS_ALGO_ZIP:
891       s="ZIP";
892       break;
893
894     case COMPRESS_ALGO_ZLIB:
895       s="ZLIB";
896       break;
897
898 #ifdef HAVE_BZIP2
899     case COMPRESS_ALGO_BZIP2:
900       s="BZIP2";
901       break;
902 #endif
903     }
904
905   return s;
906 }
907
908 int
909 string_to_compress_algo(const char *string)
910 {
911   /* TRANSLATORS: See doc/TRANSLATE about this string. */
912   if(match_multistr(_("uncompressed|none"),string))
913     return 0;
914   else if(ascii_strcasecmp(string,"uncompressed")==0)
915     return 0;
916   else if(ascii_strcasecmp(string,"none")==0)
917     return 0;
918   else if(ascii_strcasecmp(string,"zip")==0)
919     return 1;
920   else if(ascii_strcasecmp(string,"zlib")==0)
921     return 2;
922 #ifdef HAVE_BZIP2
923   else if(ascii_strcasecmp(string,"bzip2")==0)
924     return 3;
925 #endif
926   else if(ascii_strcasecmp(string,"z0")==0)
927     return 0;
928   else if(ascii_strcasecmp(string,"z1")==0)
929     return 1;
930   else if(ascii_strcasecmp(string,"z2")==0)
931     return 2;
932 #ifdef HAVE_BZIP2
933   else if(ascii_strcasecmp(string,"z3")==0)
934     return 3;
935 #endif
936   else
937     return -1;
938 }
939
940 int
941 check_compress_algo(int algo)
942 {
943   switch (algo)
944     {
945     case 0: return 0;
946 #ifdef HAVE_ZIP
947     case 1:  
948     case 2: return 0;
949 #endif
950 #ifdef HAVE_BZIP2
951     case 3: return 0;
952 #endif
953     default: return G10ERR_COMPR_ALGO;
954     }
955 }
956
957 int
958 default_cipher_algo(void)
959 {
960   if(opt.def_cipher_algo)
961     return opt.def_cipher_algo;
962   else if(opt.personal_cipher_prefs)
963     return opt.personal_cipher_prefs[0].value;
964   else
965     return opt.s2k_cipher_algo;
966 }
967
968 /* There is no default_digest_algo function, but see
969    sign.c:hash_for() */
970
971 int
972 default_compress_algo(void)
973 {
974   if(opt.compress_algo!=-1)
975     return opt.compress_algo;
976   else if(opt.personal_compress_prefs)
977     return opt.personal_compress_prefs[0].value;
978   else
979     return DEFAULT_COMPRESS_ALGO;
980 }
981
982 const char *
983 compliance_option_string(void)
984 {
985   char *ver="???";
986
987   switch(opt.compliance)
988     {
989     case CO_GNUPG:   return "--gnupg";
990     case CO_RFC4880: return "--openpgp";
991     case CO_RFC2440: return "--rfc2440";
992     case CO_RFC1991: return "--rfc1991";
993     case CO_PGP2:    return "--pgp2";
994     case CO_PGP6:    return "--pgp6";
995     case CO_PGP7:    return "--pgp7";
996     case CO_PGP8:    return "--pgp8";
997     }
998
999   return ver;
1000 }
1001
1002 void
1003 compliance_failure(void)
1004 {
1005   char *ver="???";
1006
1007   switch(opt.compliance)
1008     {
1009     case CO_GNUPG:
1010       ver="GnuPG";
1011       break;
1012
1013     case CO_RFC4880:
1014       ver="OpenPGP";
1015       break;
1016
1017     case CO_RFC2440:
1018       ver="OpenPGP (older)";
1019       break;
1020
1021     case CO_RFC1991:
1022       ver="old PGP";
1023       break;
1024
1025     case CO_PGP2:
1026       ver="PGP 2.x";
1027       break;
1028
1029     case CO_PGP6:
1030       ver="PGP 6.x";
1031       break;
1032
1033     case CO_PGP7:
1034       ver="PGP 7.x";
1035       break;
1036
1037     case CO_PGP8:
1038       ver="PGP 8.x";
1039       break;
1040     }
1041
1042   log_info(_("this message may not be usable by %s\n"),ver);
1043   opt.compliance=CO_GNUPG;
1044 }
1045
1046 /* Break a string into successive option pieces.  Accepts single word
1047    options and key=value argument options. */
1048 char *
1049 optsep(char **stringp)
1050 {
1051   char *tok,*end;
1052
1053   tok=*stringp;
1054   if(tok)
1055     {
1056       end=strpbrk(tok," ,=");
1057       if(end)
1058         {
1059           int sawequals=0;
1060           char *ptr=end;
1061
1062           /* what we need to do now is scan along starting with *end,
1063              If the next character we see (ignoring spaces) is an =
1064              sign, then there is an argument. */
1065
1066           while(*ptr)
1067             {
1068               if(*ptr=='=')
1069                 sawequals=1;
1070               else if(*ptr!=' ')
1071                 break;
1072               ptr++;
1073             }
1074
1075           /* There is an argument, so grab that too.  At this point,
1076              ptr points to the first character of the argument. */
1077           if(sawequals)
1078             {
1079               /* Is it a quoted argument? */
1080               if(*ptr=='"')
1081                 {
1082                   ptr++;
1083                   end=strchr(ptr,'"');
1084                   if(end)
1085                     end++;
1086                 }
1087               else
1088                 end=strpbrk(ptr," ,");
1089             }
1090
1091           if(end && *end)
1092             {
1093               *end='\0';
1094               *stringp=end+1;
1095             }
1096           else
1097             *stringp=NULL;
1098         }
1099       else
1100         *stringp=NULL;
1101     }
1102
1103   return tok;
1104 }
1105
1106 /* Breaks an option value into key and value.  Returns NULL if there
1107    is no value.  Note that "string" is modified to remove the =value
1108    part. */
1109 char *
1110 argsplit(char *string)
1111 {
1112   char *equals,*arg=NULL;
1113
1114   equals=strchr(string,'=');
1115   if(equals)
1116     {
1117       char *quote,*space;
1118
1119       *equals='\0';
1120       arg=equals+1;
1121
1122       /* Quoted arg? */
1123       quote=strchr(arg,'"');
1124       if(quote)
1125         {
1126           arg=quote+1;
1127
1128           quote=strchr(arg,'"');
1129           if(quote)
1130             *quote='\0';
1131         }
1132       else
1133         {
1134           size_t spaces;
1135
1136           /* Trim leading spaces off of the arg */
1137           spaces=strspn(arg," ");
1138           arg+=spaces;
1139         }
1140
1141       /* Trim tailing spaces off of the tag */
1142       space=strchr(string,' ');
1143       if(space)
1144         *space='\0';
1145     }
1146
1147   return arg;
1148 }
1149
1150 /* Return the length of the initial token, leaving off any
1151    argument. */
1152 static size_t
1153 optlen(const char *s)
1154 {
1155   char *end=strpbrk(s," =");
1156
1157   if(end)
1158     return end-s;
1159   else
1160     return strlen(s);
1161 }
1162
1163 int
1164 parse_options(char *str,unsigned int *options,
1165               struct parse_options *opts,int noisy)
1166 {
1167   char *tok;
1168
1169   if (str && !strcmp (str, "help"))
1170     {
1171       int i,maxlen=0;
1172
1173       /* Figure out the longest option name so we can line these up
1174          neatly. */
1175       for(i=0;opts[i].name;i++)
1176         if(opts[i].help && maxlen<strlen(opts[i].name))
1177           maxlen=strlen(opts[i].name);
1178
1179       for(i=0;opts[i].name;i++)
1180         if(opts[i].help)
1181           printf("%s%*s%s\n",opts[i].name,
1182                  maxlen+2-(int)strlen(opts[i].name),"",_(opts[i].help));
1183
1184       g10_exit(0);
1185     }
1186
1187   while((tok=optsep(&str)))
1188     {
1189       int i,rev=0;
1190       char *otok=tok;
1191
1192       if(tok[0]=='\0')
1193         continue;
1194
1195       if(ascii_strncasecmp("no-",tok,3)==0)
1196         {
1197           rev=1;
1198           tok+=3;
1199         }
1200
1201       for(i=0;opts[i].name;i++)
1202         {
1203           size_t toklen=optlen(tok);
1204
1205           if(ascii_strncasecmp(opts[i].name,tok,toklen)==0)
1206             {
1207               /* We have a match, but it might be incomplete */
1208               if(toklen!=strlen(opts[i].name))
1209                 {
1210                   int j;
1211
1212                   for(j=i+1;opts[j].name;j++)
1213                     {
1214                       if(ascii_strncasecmp(opts[j].name,tok,toklen)==0)
1215                         {
1216                           if(noisy)
1217                             log_info(_("ambiguous option `%s'\n"),otok);
1218                           return 0;
1219                         }
1220                     }
1221                 }
1222
1223               if(rev)
1224                 {
1225                   *options&=~opts[i].bit;
1226                   if(opts[i].value)
1227                     *opts[i].value=NULL;
1228                 }
1229               else
1230                 {
1231                   *options|=opts[i].bit;
1232                   if(opts[i].value)
1233                     *opts[i].value=argsplit(tok);
1234                 }
1235               break;
1236             }
1237         }
1238
1239       if(!opts[i].name)
1240         {
1241           if(noisy)
1242             log_info(_("unknown option `%s'\n"),otok);
1243           return 0;
1244         }
1245     }
1246
1247   return 1;
1248 }
1249
1250
1251 /* Check whether the string has characters not valid in an RFC-822
1252    address.  To cope with OpenPGP we ignore non-ascii characters
1253    so that for example umlauts are legal in an email address.  An
1254    OpenPGP user ID must be utf-8 encoded but there is no strict
1255    requirement for RFC-822.  Thus to avoid IDNA encoding we put the
1256    address verbatim as utf-8 into the user ID under the assumption
1257    that mail programs handle IDNA at a lower level and take OpenPGP
1258    user IDs as utf-8.  Note that we can't do an utf-8 encoding
1259    checking here because in keygen.c this function is called with the
1260    native encoding and native to utf-8 encoding is only done  later.  */
1261 int
1262 has_invalid_email_chars (const char *s)
1263 {
1264   int at_seen=0;
1265   const char *valid_chars=
1266     "01234567890_-.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
1267
1268   for ( ; *s; s++ ) 
1269     {
1270       if ( (*s & 0x80) )
1271         continue; /* We only care about ASCII.  */
1272       if ( *s == '@' )
1273         at_seen=1;
1274       else if ( !at_seen && !( !!strchr( valid_chars, *s ) || *s == '+' ) )
1275         return 1;
1276       else if ( at_seen && !strchr( valid_chars, *s ) )
1277         return 1;
1278     }
1279   return 0;
1280 }
1281
1282
1283 /* Check whether NAME represents a valid mailbox according to
1284    RFC822. Returns true if so. */
1285 int
1286 is_valid_mailbox (const char *name)
1287 {
1288   return !( !name
1289             || !*name
1290             || has_invalid_email_chars (name)
1291             || string_count_chr (name,'@') != 1
1292             || *name == '@'
1293             || name[strlen(name)-1] == '@'
1294             || name[strlen(name)-1] == '.'
1295             || strstr (name, "..") );
1296 }
1297
1298
1299 /* Similar to access(2), but uses PATH to find the file. */
1300 int
1301 path_access(const char *file,int mode)
1302 {
1303   char *envpath;
1304   int ret=-1;
1305
1306   envpath=getenv("PATH");
1307
1308   if(!envpath
1309 #ifdef HAVE_DRIVE_LETTERS
1310      || (((file[0]>='A' && file[0]<='Z')
1311           || (file[0]>='a' && file[0]<='z'))
1312          && file[1]==':')
1313 #else
1314      || file[0]=='/'
1315 #endif
1316      )
1317     return access(file,mode);
1318   else
1319     {
1320       /* At least as large as, but most often larger than we need. */
1321       char *buffer=xmalloc(strlen(envpath)+1+strlen(file)+1);
1322       char *split,*item,*path=xstrdup(envpath);
1323
1324       split=path;
1325
1326       while((item=strsep(&split,PATHSEP_S)))
1327         {
1328           strcpy(buffer,item);
1329           strcat(buffer,"/");
1330           strcat(buffer,file);
1331           ret=access(buffer,mode);
1332           if(ret==0)
1333             break;
1334         }
1335
1336       xfree(path);
1337       xfree(buffer);
1338     }
1339
1340   return ret;
1341 }
1342
1343
1344 \f
1345 /* Temporary helper. */
1346 int
1347 pubkey_get_npkey( int algo )
1348 {
1349   size_t n;
1350
1351   if (algo == GCRY_PK_ELG_E)
1352     algo = GCRY_PK_ELG;
1353   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NPKEY, NULL, &n))
1354     n = 0;
1355   return n;
1356 }
1357
1358 /* Temporary helper. */
1359 int
1360 pubkey_get_nskey( int algo )
1361 {
1362   size_t n;
1363
1364   if (algo == GCRY_PK_ELG_E)
1365     algo = GCRY_PK_ELG;
1366   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NSKEY, NULL, &n ))
1367     n = 0;
1368   return n;
1369 }
1370
1371 /* Temporary helper. */
1372 int
1373 pubkey_get_nsig( int algo )
1374 {
1375   size_t n;
1376
1377   if (algo == GCRY_PK_ELG_E)
1378     algo = GCRY_PK_ELG;
1379   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NSIGN, NULL, &n))
1380     n = 0;
1381   return n;
1382 }
1383
1384 /* Temporary helper. */
1385 int
1386 pubkey_get_nenc( int algo )
1387 {
1388   size_t n;
1389   
1390   if (algo == GCRY_PK_ELG_E)
1391     algo = GCRY_PK_ELG;
1392   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NENCR, NULL, &n ))
1393     n = 0;
1394   return n;
1395 }
1396
1397
1398 /* Temporary helper. */
1399 unsigned int
1400 pubkey_nbits( int algo, gcry_mpi_t *key )
1401 {
1402     int rc, nbits;
1403     gcry_sexp_t sexp;
1404
1405     if( algo == GCRY_PK_DSA ) {
1406         rc = gcry_sexp_build ( &sexp, NULL,
1407                               "(public-key(dsa(p%m)(q%m)(g%m)(y%m)))",
1408                                   key[0], key[1], key[2], key[3] );
1409     }
1410     else if( algo == GCRY_PK_ELG || algo == GCRY_PK_ELG_E ) {
1411         rc = gcry_sexp_build ( &sexp, NULL,
1412                               "(public-key(elg(p%m)(g%m)(y%m)))",
1413                                   key[0], key[1], key[2] );
1414     }
1415     else if( algo == GCRY_PK_RSA ) {
1416         rc = gcry_sexp_build ( &sexp, NULL,
1417                               "(public-key(rsa(n%m)(e%m)))",
1418                                   key[0], key[1] );
1419     }
1420     else
1421         return 0;
1422
1423     if ( rc )
1424         BUG ();
1425
1426     nbits = gcry_pk_get_nbits( sexp );
1427     gcry_sexp_release( sexp );
1428     return nbits;
1429 }
1430
1431
1432
1433 /* FIXME: Use gcry_mpi_print directly. */
1434 int
1435 mpi_print (estream_t fp, gcry_mpi_t a, int mode)
1436 {
1437   int n=0;
1438   
1439   if (!a)
1440     return es_fprintf (fp, "[MPI_NULL]");
1441   if (!mode)
1442     {
1443       unsigned int n1;
1444       n1 = gcry_mpi_get_nbits(a);
1445       n += es_fprintf (fp, "[%u bits]", n1);
1446     }
1447   else
1448     {
1449       unsigned char *buffer;
1450       
1451       if (gcry_mpi_aprint (GCRYMPI_FMT_HEX, &buffer, NULL, a))
1452         BUG ();
1453       es_fputs (buffer, fp);
1454       n += strlen (buffer);
1455       gcry_free (buffer);
1456     }
1457   return n;
1458 }
1459