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