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