./autogen.sh --build-w32ce does now succeed.
[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   switch (algo)
909     {
910     case 0: return 0;
911 #ifdef HAVE_ZIP
912     case 1:  
913     case 2: return 0;
914 #endif
915 #ifdef HAVE_BZIP2
916     case 3: return 0;
917 #endif
918     default: return G10ERR_COMPR_ALGO;
919     }
920 }
921
922 int
923 default_cipher_algo(void)
924 {
925   if(opt.def_cipher_algo)
926     return opt.def_cipher_algo;
927   else if(opt.personal_cipher_prefs)
928     return opt.personal_cipher_prefs[0].value;
929   else
930     return opt.s2k_cipher_algo;
931 }
932
933 /* There is no default_digest_algo function, but see
934    sign.c:hash_for() */
935
936 int
937 default_compress_algo(void)
938 {
939   if(opt.compress_algo!=-1)
940     return opt.compress_algo;
941   else if(opt.personal_compress_prefs)
942     return opt.personal_compress_prefs[0].value;
943   else
944     return DEFAULT_COMPRESS_ALGO;
945 }
946
947 const char *
948 compliance_option_string(void)
949 {
950   char *ver="???";
951
952   switch(opt.compliance)
953     {
954     case CO_GNUPG:   return "--gnupg";
955     case CO_RFC4880: return "--openpgp";
956     case CO_RFC2440: return "--rfc2440";
957     case CO_RFC1991: return "--rfc1991";
958     case CO_PGP2:    return "--pgp2";
959     case CO_PGP6:    return "--pgp6";
960     case CO_PGP7:    return "--pgp7";
961     case CO_PGP8:    return "--pgp8";
962     }
963
964   return ver;
965 }
966
967 void
968 compliance_failure(void)
969 {
970   char *ver="???";
971
972   switch(opt.compliance)
973     {
974     case CO_GNUPG:
975       ver="GnuPG";
976       break;
977
978     case CO_RFC4880:
979       ver="OpenPGP";
980       break;
981
982     case CO_RFC2440:
983       ver="OpenPGP (older)";
984       break;
985
986     case CO_RFC1991:
987       ver="old PGP";
988       break;
989
990     case CO_PGP2:
991       ver="PGP 2.x";
992       break;
993
994     case CO_PGP6:
995       ver="PGP 6.x";
996       break;
997
998     case CO_PGP7:
999       ver="PGP 7.x";
1000       break;
1001
1002     case CO_PGP8:
1003       ver="PGP 8.x";
1004       break;
1005     }
1006
1007   log_info(_("this message may not be usable by %s\n"),ver);
1008   opt.compliance=CO_GNUPG;
1009 }
1010
1011 /* Break a string into successive option pieces.  Accepts single word
1012    options and key=value argument options. */
1013 char *
1014 optsep(char **stringp)
1015 {
1016   char *tok,*end;
1017
1018   tok=*stringp;
1019   if(tok)
1020     {
1021       end=strpbrk(tok," ,=");
1022       if(end)
1023         {
1024           int sawequals=0;
1025           char *ptr=end;
1026
1027           /* what we need to do now is scan along starting with *end,
1028              If the next character we see (ignoring spaces) is an =
1029              sign, then there is an argument. */
1030
1031           while(*ptr)
1032             {
1033               if(*ptr=='=')
1034                 sawequals=1;
1035               else if(*ptr!=' ')
1036                 break;
1037               ptr++;
1038             }
1039
1040           /* There is an argument, so grab that too.  At this point,
1041              ptr points to the first character of the argument. */
1042           if(sawequals)
1043             {
1044               /* Is it a quoted argument? */
1045               if(*ptr=='"')
1046                 {
1047                   ptr++;
1048                   end=strchr(ptr,'"');
1049                   if(end)
1050                     end++;
1051                 }
1052               else
1053                 end=strpbrk(ptr," ,");
1054             }
1055
1056           if(end && *end)
1057             {
1058               *end='\0';
1059               *stringp=end+1;
1060             }
1061           else
1062             *stringp=NULL;
1063         }
1064       else
1065         *stringp=NULL;
1066     }
1067
1068   return tok;
1069 }
1070
1071 /* Breaks an option value into key and value.  Returns NULL if there
1072    is no value.  Note that "string" is modified to remove the =value
1073    part. */
1074 char *
1075 argsplit(char *string)
1076 {
1077   char *equals,*arg=NULL;
1078
1079   equals=strchr(string,'=');
1080   if(equals)
1081     {
1082       char *quote,*space;
1083
1084       *equals='\0';
1085       arg=equals+1;
1086
1087       /* Quoted arg? */
1088       quote=strchr(arg,'"');
1089       if(quote)
1090         {
1091           arg=quote+1;
1092
1093           quote=strchr(arg,'"');
1094           if(quote)
1095             *quote='\0';
1096         }
1097       else
1098         {
1099           size_t spaces;
1100
1101           /* Trim leading spaces off of the arg */
1102           spaces=strspn(arg," ");
1103           arg+=spaces;
1104         }
1105
1106       /* Trim tailing spaces off of the tag */
1107       space=strchr(string,' ');
1108       if(space)
1109         *space='\0';
1110     }
1111
1112   return arg;
1113 }
1114
1115 /* Return the length of the initial token, leaving off any
1116    argument. */
1117 static size_t
1118 optlen(const char *s)
1119 {
1120   char *end=strpbrk(s," =");
1121
1122   if(end)
1123     return end-s;
1124   else
1125     return strlen(s);
1126 }
1127
1128 int
1129 parse_options(char *str,unsigned int *options,
1130               struct parse_options *opts,int noisy)
1131 {
1132   char *tok;
1133
1134   if (str && !strcmp (str, "help"))
1135     {
1136       int i,maxlen=0;
1137
1138       /* Figure out the longest option name so we can line these up
1139          neatly. */
1140       for(i=0;opts[i].name;i++)
1141         if(opts[i].help && maxlen<strlen(opts[i].name))
1142           maxlen=strlen(opts[i].name);
1143
1144       for(i=0;opts[i].name;i++)
1145         if(opts[i].help)
1146           printf("%s%*s%s\n",opts[i].name,
1147                  maxlen+2-(int)strlen(opts[i].name),"",_(opts[i].help));
1148
1149       g10_exit(0);
1150     }
1151
1152   while((tok=optsep(&str)))
1153     {
1154       int i,rev=0;
1155       char *otok=tok;
1156
1157       if(tok[0]=='\0')
1158         continue;
1159
1160       if(ascii_strncasecmp("no-",tok,3)==0)
1161         {
1162           rev=1;
1163           tok+=3;
1164         }
1165
1166       for(i=0;opts[i].name;i++)
1167         {
1168           size_t toklen=optlen(tok);
1169
1170           if(ascii_strncasecmp(opts[i].name,tok,toklen)==0)
1171             {
1172               /* We have a match, but it might be incomplete */
1173               if(toklen!=strlen(opts[i].name))
1174                 {
1175                   int j;
1176
1177                   for(j=i+1;opts[j].name;j++)
1178                     {
1179                       if(ascii_strncasecmp(opts[j].name,tok,toklen)==0)
1180                         {
1181                           if(noisy)
1182                             log_info(_("ambiguous option `%s'\n"),otok);
1183                           return 0;
1184                         }
1185                     }
1186                 }
1187
1188               if(rev)
1189                 {
1190                   *options&=~opts[i].bit;
1191                   if(opts[i].value)
1192                     *opts[i].value=NULL;
1193                 }
1194               else
1195                 {
1196                   *options|=opts[i].bit;
1197                   if(opts[i].value)
1198                     *opts[i].value=argsplit(tok);
1199                 }
1200               break;
1201             }
1202         }
1203
1204       if(!opts[i].name)
1205         {
1206           if(noisy)
1207             log_info(_("unknown option `%s'\n"),otok);
1208           return 0;
1209         }
1210     }
1211
1212   return 1;
1213 }
1214
1215
1216 /* Check whether the string has characters not valid in an RFC-822
1217    address.  To cope with OpenPGP we ignore non-ascii characters
1218    so that for example umlauts are legal in an email address.  An
1219    OpenPGP user ID must be utf-8 encoded but there is no strict
1220    requirement for RFC-822.  Thus to avoid IDNA encoding we put the
1221    address verbatim as utf-8 into the user ID under the assumption
1222    that mail programs handle IDNA at a lower level and take OpenPGP
1223    user IDs as utf-8.  Note that we can't do an utf-8 encoding
1224    checking here because in keygen.c this function is called with the
1225    native encoding and native to utf-8 encoding is only done  later.  */
1226 int
1227 has_invalid_email_chars (const char *s)
1228 {
1229   int at_seen=0;
1230   const char *valid_chars=
1231     "01234567890_-.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
1232
1233   for ( ; *s; s++ ) 
1234     {
1235       if ( (*s & 0x80) )
1236         continue; /* We only care about ASCII.  */
1237       if ( *s == '@' )
1238         at_seen=1;
1239       else if ( !at_seen && !( !!strchr( valid_chars, *s ) || *s == '+' ) )
1240         return 1;
1241       else if ( at_seen && !strchr( valid_chars, *s ) )
1242         return 1;
1243     }
1244   return 0;
1245 }
1246
1247
1248 /* Check whether NAME represents a valid mailbox according to
1249    RFC822. Returns true if so. */
1250 int
1251 is_valid_mailbox (const char *name)
1252 {
1253   return !( !name
1254             || !*name
1255             || has_invalid_email_chars (name)
1256             || string_count_chr (name,'@') != 1
1257             || *name == '@'
1258             || name[strlen(name)-1] == '@'
1259             || name[strlen(name)-1] == '.'
1260             || strstr (name, "..") );
1261 }
1262
1263
1264 /* Similar to access(2), but uses PATH to find the file. */
1265 int
1266 path_access(const char *file,int mode)
1267 {
1268   char *envpath;
1269   int ret=-1;
1270
1271   envpath=getenv("PATH");
1272
1273   if(!envpath
1274 #ifdef HAVE_DRIVE_LETTERS
1275      || (((file[0]>='A' && file[0]<='Z')
1276           || (file[0]>='a' && file[0]<='z'))
1277          && file[1]==':')
1278 #else
1279      || file[0]=='/'
1280 #endif
1281      )
1282     return access(file,mode);
1283   else
1284     {
1285       /* At least as large as, but most often larger than we need. */
1286       char *buffer=xmalloc(strlen(envpath)+1+strlen(file)+1);
1287       char *split,*item,*path=xstrdup(envpath);
1288
1289       split=path;
1290
1291       while((item=strsep(&split,PATHSEP_S)))
1292         {
1293           strcpy(buffer,item);
1294           strcat(buffer,"/");
1295           strcat(buffer,file);
1296           ret=access(buffer,mode);
1297           if(ret==0)
1298             break;
1299         }
1300
1301       xfree(path);
1302       xfree(buffer);
1303     }
1304
1305   return ret;
1306 }
1307
1308
1309 \f
1310 /* Temporary helper. */
1311 int
1312 pubkey_get_npkey( int algo )
1313 {
1314   size_t n;
1315
1316   if (algo == GCRY_PK_ELG_E)
1317     algo = GCRY_PK_ELG;
1318   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NPKEY, NULL, &n))
1319     n = 0;
1320   return n;
1321 }
1322
1323 /* Temporary helper. */
1324 int
1325 pubkey_get_nskey( int algo )
1326 {
1327   size_t n;
1328
1329   if (algo == GCRY_PK_ELG_E)
1330     algo = GCRY_PK_ELG;
1331   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NSKEY, NULL, &n ))
1332     n = 0;
1333   return n;
1334 }
1335
1336 /* Temporary helper. */
1337 int
1338 pubkey_get_nsig( int algo )
1339 {
1340   size_t n;
1341
1342   if (algo == GCRY_PK_ELG_E)
1343     algo = GCRY_PK_ELG;
1344   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NSIGN, NULL, &n))
1345     n = 0;
1346   return n;
1347 }
1348
1349 /* Temporary helper. */
1350 int
1351 pubkey_get_nenc( int algo )
1352 {
1353   size_t n;
1354   
1355   if (algo == GCRY_PK_ELG_E)
1356     algo = GCRY_PK_ELG;
1357   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NENCR, NULL, &n ))
1358     n = 0;
1359   return n;
1360 }
1361
1362
1363 /* Temporary helper. */
1364 unsigned int
1365 pubkey_nbits( int algo, gcry_mpi_t *key )
1366 {
1367     int rc, nbits;
1368     gcry_sexp_t sexp;
1369
1370     if( algo == GCRY_PK_DSA ) {
1371         rc = gcry_sexp_build ( &sexp, NULL,
1372                               "(public-key(dsa(p%m)(q%m)(g%m)(y%m)))",
1373                                   key[0], key[1], key[2], key[3] );
1374     }
1375     else if( algo == GCRY_PK_ELG || algo == GCRY_PK_ELG_E ) {
1376         rc = gcry_sexp_build ( &sexp, NULL,
1377                               "(public-key(elg(p%m)(g%m)(y%m)))",
1378                                   key[0], key[1], key[2] );
1379     }
1380     else if( algo == GCRY_PK_RSA ) {
1381         rc = gcry_sexp_build ( &sexp, NULL,
1382                               "(public-key(rsa(n%m)(e%m)))",
1383                                   key[0], key[1] );
1384     }
1385     else
1386         return 0;
1387
1388     if ( rc )
1389         BUG ();
1390
1391     nbits = gcry_pk_get_nbits( sexp );
1392     gcry_sexp_release( sexp );
1393     return nbits;
1394 }
1395
1396
1397
1398 /* FIXME: Use gcry_mpi_print directly. */
1399 int
1400 mpi_print (estream_t fp, gcry_mpi_t a, int mode)
1401 {
1402   int n=0;
1403   
1404   if (!a)
1405     return es_fprintf (fp, "[MPI_NULL]");
1406   if (!mode)
1407     {
1408       unsigned int n1;
1409       n1 = gcry_mpi_get_nbits(a);
1410       n += es_fprintf (fp, "[%u bits]", n1);
1411     }
1412   else
1413     {
1414       unsigned char *buffer;
1415       
1416       if (gcry_mpi_aprint (GCRYMPI_FMT_HEX, &buffer, NULL, a))
1417         BUG ();
1418       es_fputs (buffer, fp);
1419       n += strlen (buffer);
1420       gcry_free (buffer);
1421     }
1422   return n;
1423 }
1424