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