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