Use inline functions to convert buffer data to scalars.
[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 #ifdef _WIN32
40 #include <time.h>
41 #include <process.h>
42 #include <windows.h>
43 #include <shlobj.h>
44 #ifndef CSIDL_APPDATA
45 #define CSIDL_APPDATA 0x001a
46 #endif
47 #ifndef CSIDL_LOCAL_APPDATA
48 #define CSIDL_LOCAL_APPDATA 0x001c
49 #endif
50 #ifndef CSIDL_FLAG_CREATE
51 #define CSIDL_FLAG_CREATE 0x8000
52 #endif
53 #include "errors.h"
54 #include "dynload.h"
55 #endif /*_WIN32*/
56
57 #ifdef __VMS
58 # include <time.h>
59 #endif /* def __VMS */
60
61 #include "util.h"
62 #include "main.h"
63 #include "photoid.h"
64 #include "options.h"
65 #include "i18n.h"
66 #include "cardglue.h"
67
68
69
70
71 #ifdef ENABLE_SELINUX_HACKS
72 /* A object and a global variable to keep track of files marked as
73    secured. */
74 struct secured_file_item
75 {
76   struct secured_file_item *next;
77   ino_t ino;
78   dev_t dev;
79 };
80 static struct secured_file_item *secured_files;
81 #endif /*ENABLE_SELINUX_HACKS*/
82
83
84
85 #if defined(__linux__) && defined(__alpha__) && __GLIBC__ < 2
86 static int
87 setsysinfo(unsigned long op, void *buffer, unsigned long size,
88                      int *start, void *arg, unsigned long flag)
89 {
90     return syscall(__NR_osf_setsysinfo, op, buffer, size, start, arg, flag);
91 }
92
93 void
94 trap_unaligned(void)
95 {
96     unsigned int buf[2];
97
98     buf[0] = SSIN_UACPROC;
99     buf[1] = UAC_SIGBUS | UAC_NOPRINT;
100     setsysinfo(SSI_NVPAIRS, buf, 1, 0, 0, 0);
101 }
102 #else
103 void
104 trap_unaligned(void)
105 {  /* dummy */
106 }
107 #endif
108
109
110 int
111 disable_core_dumps()
112 {
113 #if defined(HAVE_DOSISH_SYSTEM) || defined(__VMS)
114     return 0;
115 #else
116 #ifdef HAVE_SETRLIMIT
117     struct rlimit limit;
118
119     limit.rlim_cur = 0;
120     limit.rlim_max = 0;
121     if( !setrlimit( RLIMIT_CORE, &limit ) )
122         return 0;
123     if( errno != EINVAL && errno != ENOSYS )
124         log_fatal(_("can't disable core dumps: %s\n"), strerror(errno) );
125 #endif
126     return 1;
127 #endif
128 }
129
130
131 /* For the sake of SELinux we want to restrict access through gpg to
132    certain files we keep under our own control.  This function
133    registers such a file and is_secured_file may then be used to
134    check whether a file has ben registered as secured. */
135 void
136 register_secured_file (const char *fname)
137 {
138 #ifdef ENABLE_SELINUX_HACKS
139   struct stat buf;
140   struct secured_file_item *sf;
141
142   /* Note that we stop immediatley if something goes wrong here. */
143   if (stat (fname, &buf))
144     log_fatal (_("fstat of `%s' failed in %s: %s\n"), fname,
145                "register_secured_file", strerror (errno));
146 /*   log_debug ("registering `%s' i=%lu.%lu\n", fname, */
147 /*              (unsigned long)buf.st_dev, (unsigned long)buf.st_ino); */
148   for (sf=secured_files; sf; sf = sf->next)
149     {
150       if (sf->ino == buf.st_ino && sf->dev == buf.st_dev)
151         return; /* Already registered.  */
152     }
153
154   sf = xmalloc (sizeof *sf);
155   sf->ino = buf.st_ino;
156   sf->dev = buf.st_dev;
157   sf->next = secured_files;
158   secured_files = sf;
159 #endif /*ENABLE_SELINUX_HACKS*/
160 }
161
162 /* Remove a file registerd as secure. */
163 void
164 unregister_secured_file (const char *fname)
165 {
166 #ifdef ENABLE_SELINUX_HACKS
167   struct stat buf;
168   struct secured_file_item *sf, *sfprev;
169
170   if (stat (fname, &buf))
171     {
172       log_error (_("fstat of `%s' failed in %s: %s\n"), fname,
173                  "unregister_secured_file", strerror (errno));
174       return;
175     }
176 /*   log_debug ("unregistering `%s' i=%lu.%lu\n", fname,  */
177 /*              (unsigned long)buf.st_dev, (unsigned long)buf.st_ino); */
178   for (sfprev=NULL,sf=secured_files; sf; sfprev=sf, sf = sf->next)
179     {
180       if (sf->ino == buf.st_ino && sf->dev == buf.st_dev)
181         {
182           if (sfprev)
183             sfprev->next = sf->next;
184           else
185             secured_files = sf->next;
186           xfree (sf);
187           return;
188         }
189     }
190 #endif /*ENABLE_SELINUX_HACKS*/
191 }
192
193 /* Return true if FD is corresponds to a secured file.  Using -1 for
194    FS is allowed and will return false. */
195 int
196 is_secured_file (int fd)
197 {
198 #ifdef ENABLE_SELINUX_HACKS
199   struct stat buf;
200   struct secured_file_item *sf;
201
202   if (fd == -1)
203     return 0; /* No file descriptor so it can't be secured either.  */
204
205   /* Note that we print out a error here and claim that a file is
206      secure if something went wrong. */
207   if (fstat (fd, &buf))
208     {
209       log_error (_("fstat(%d) failed in %s: %s\n"), fd,
210                  "is_secured_file", strerror (errno));
211       return 1;
212     }
213 /*   log_debug ("is_secured_file (%d) i=%lu.%lu\n", fd, */
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 /* Return true if FNAME is corresponds to a secured file.  Using NULL,
225    "" or "-" for FS is allowed and will return false. This function is
226    used before creating a file, thus it won't fail if the file does
227    not exist. */
228 int
229 is_secured_filename (const char *fname)
230 {
231 #ifdef ENABLE_SELINUX_HACKS
232   struct stat buf;
233   struct secured_file_item *sf;
234
235   if (iobuf_is_pipe_filename (fname) || !*fname)
236     return 0;
237
238   /* Note that we print out a error here and claim that a file is
239      secure if something went wrong. */
240   if (stat (fname, &buf))
241     {
242       if (errno == ENOENT || errno == EPERM || errno == EACCES)
243         return 0;
244       log_error (_("fstat of `%s' failed in %s: %s\n"), fname,
245                  "is_secured_filename", strerror (errno));
246       return 1;
247     }
248 /*   log_debug ("is_secured_filename (%s) i=%lu.%lu\n", fname, */
249 /*              (unsigned long)buf.st_dev, (unsigned long)buf.st_ino); */
250   for (sf=secured_files; sf; sf = sf->next)
251     {
252       if (sf->ino == buf.st_ino && sf->dev == buf.st_dev)
253         return 1; /* Yes.  */
254     }
255 #endif /*ENABLE_SELINUX_HACKS*/
256   return 0; /* No. */
257 }
258
259
260
261 u16
262 checksum_u16( unsigned n )
263 {
264     u16 a;
265
266     a  = (n >> 8) & 0xff;
267     a += n & 0xff;
268     return a;
269 }
270
271
272 u16
273 checksum( byte *p, unsigned n )
274 {
275     u16 a;
276
277     for(a=0; n; n-- )
278         a += *p++;
279     return a;
280 }
281
282 u16
283 checksum_mpi( MPI a )
284 {
285     u16 csum;
286     byte *buffer;
287     unsigned nbytes;
288     unsigned nbits;
289
290     buffer = mpi_get_buffer( a, &nbytes, NULL );
291     nbits = mpi_get_nbits(a);
292     csum = checksum_u16( nbits );
293     csum += checksum( buffer, nbytes );
294     xfree( buffer );
295     return csum;
296 }
297
298 void
299 print_pubkey_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 public key algorithm %s\n"),
308                    pubkey_algo_to_string(algo));
309         }
310     }
311   else if (algo == 20)
312     {
313       log_info (_("WARNING: Elgamal sign+encrypt keys are deprecated\n"));
314     }
315 }
316
317 void
318 print_cipher_algo_note( int algo )
319 {
320   if(algo >= 100 && algo <= 110)
321     {
322       static int warn=0;
323       if(!warn)
324         {
325           warn=1;
326           log_info(_("WARNING: using experimental cipher algorithm %s\n"),
327                    cipher_algo_to_string(algo));
328         }
329     }
330 }
331
332 void
333 print_digest_algo_note( int algo )
334 {
335   if(algo >= 100 && algo <= 110)
336     {
337       static int warn=0;
338       if(!warn)
339         {
340           warn=1;
341           log_info(_("WARNING: using experimental digest algorithm %s\n"),
342                    digest_algo_to_string(algo));
343         }
344     }
345   else if(algo==DIGEST_ALGO_MD5)
346     md5_digest_warn (1);
347 }
348
349 /* Return a string which is used as a kind of process ID */
350 const byte *
351 get_session_marker( size_t *rlen )
352 {
353     static byte marker[SIZEOF_UNSIGNED_LONG*2];
354     static int initialized;
355
356     if ( !initialized ) {
357         volatile ulong aa, bb; /* we really want the uninitialized value */
358         ulong a, b;
359
360         initialized = 1;
361         /* also this marker is guessable it is not easy to use this
362          * for a faked control packet because an attacker does not
363          * have enough control about the time the verification does
364          * take place.  Of course, we can add just more random but
365          * than we need the random generator even for verification
366          * tasks - which does not make sense. */
367         a = aa ^ (ulong)getpid();
368         b = bb ^ (ulong)time(NULL);
369         memcpy( marker, &a, SIZEOF_UNSIGNED_LONG );
370         memcpy( marker+SIZEOF_UNSIGNED_LONG, &b, SIZEOF_UNSIGNED_LONG );
371     }
372     *rlen = sizeof(marker);
373     return marker;
374 }
375
376 /****************
377  * Wrapper around the libgcrypt function with addional checks on
378  * openPGP contraints for the algo ID.
379  */
380 int
381 openpgp_cipher_test_algo( int algo )
382 {
383     if( algo < 0 || algo > 110 )
384         return G10ERR_CIPHER_ALGO;
385     return check_cipher_algo(algo);
386 }
387
388 int
389 openpgp_pk_test_algo( int algo, unsigned int usage_flags )
390 {
391     /* Dont't allow type 20 keys unless in rfc2440 mode.  */
392     if (!RFC2440 && algo == 20)
393         return G10ERR_PUBKEY_ALGO;
394     if( algo < 0 || algo > 110 )
395         return G10ERR_PUBKEY_ALGO;
396     return check_pubkey_algo2( algo, usage_flags );
397 }
398
399 int
400 openpgp_pk_algo_usage ( int algo )
401 {
402     int use = 0;
403
404     /* they are hardwired in gpg 1.0 */
405     switch ( algo ) {
406       case PUBKEY_ALGO_RSA:
407           use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG | PUBKEY_USAGE_ENC | PUBKEY_USAGE_AUTH;
408           break;
409       case PUBKEY_ALGO_RSA_E:
410           use = PUBKEY_USAGE_ENC;
411           break;
412       case PUBKEY_ALGO_RSA_S:
413           use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG;
414           break;
415       case PUBKEY_ALGO_ELGAMAL:
416           /* Allow encryption with type 20 keys if RFC-2440 compliance
417              has been selected.  Signing is broken thus we won't allow
418              this.  */
419           if (RFC2440)
420             use = PUBKEY_USAGE_ENC;
421           break;
422       case PUBKEY_ALGO_ELGAMAL_E:
423           use = PUBKEY_USAGE_ENC;
424           break;
425       case PUBKEY_ALGO_DSA:
426           use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG | PUBKEY_USAGE_AUTH;
427           break;
428       default:
429           break;
430     }
431     return use;
432 }
433
434 int
435 openpgp_md_test_algo( int algo )
436 {
437     if( algo < 0 || algo > 110 )
438         return G10ERR_DIGEST_ALGO;
439     return check_digest_algo(algo);
440 }
441
442 /* Print a warning if the md5 digest algorithm has been used.  This
443    warning is printed only once unless SHOW is used. */
444 void
445 md5_digest_warn (int show)
446 {
447   static int warned = 0;
448
449   if (!warned || show)
450     {
451       log_info (_("WARNING: digest algorithm %s is deprecated\n"),
452                 digest_algo_to_string (DIGEST_ALGO_MD5));
453       log_info (_("please see %s for more information\n"),
454                 "https://gnupg.org/faq/weak-digest-algos.html");
455       warned = 1;
456     }
457 }
458
459
460 void
461 not_in_gpg1_notice (void)
462 {
463   static int warned = 0;
464
465   if (!warned)
466     {
467       log_info (_("NOTE: This feature is not available in %s\n"), "GnuPG 1.x");
468       log_info (_("please see %s for more information\n"),
469                 "https://gnupg.org/faq/features-not-in-gnupg-1.html");
470       warned = 1;
471     }
472 }
473
474
475 static unsigned long
476 get_signature_count(PKT_secret_key *sk)
477 {
478 #ifdef ENABLE_CARD_SUPPORT
479   if(sk && sk->is_protected && sk->protect.s2k.mode==1002)
480     {
481       struct agent_card_info_s info;
482       if(agent_scd_getattr("SIG-COUNTER",&info)==0)
483         return info.sig_counter;
484     }
485 #endif
486
487   /* How to do this without a card? */
488
489   return 0;
490 }
491
492 /* Expand %-strings.  Returns a string which must be xfreed.  Returns
493    NULL if the string cannot be expanded (too large). */
494 char *
495 pct_expando(const char *string,struct expando_args *args)
496 {
497   const char *ch=string;
498   int idx=0,maxlen=0,done=0;
499   u32 pk_keyid[2]={0,0},sk_keyid[2]={0,0};
500   char *ret=NULL;
501
502   if(args->pk)
503     keyid_from_pk(args->pk,pk_keyid);
504
505   if(args->sk)
506     keyid_from_sk(args->sk,sk_keyid);
507
508   /* This is used so that %k works in photoid command strings in
509      --list-secret-keys (which of course has a sk, but no pk). */
510   if(!args->pk && args->sk)
511     keyid_from_sk(args->sk,pk_keyid);
512
513   while(*ch!='\0')
514     {
515       if(!done)
516         {
517           /* 8192 is way bigger than we'll need here */
518           if(maxlen>=8192)
519             goto fail;
520
521           maxlen+=1024;
522           ret=xrealloc(ret,maxlen);
523         }
524
525       done=0;
526
527       if(*ch=='%')
528         {
529           switch(*(ch+1))
530             {
531             case 's': /* short key id */
532               if(idx+8<maxlen)
533                 {
534                   sprintf(&ret[idx],"%08lX",(ulong)sk_keyid[1]);
535                   idx+=8;
536                   done=1;
537                 }
538               break;
539
540             case 'S': /* long key id */
541               if(idx+16<maxlen)
542                 {
543                   sprintf(&ret[idx],"%08lX%08lX",
544                           (ulong)sk_keyid[0],(ulong)sk_keyid[1]);
545                   idx+=16;
546                   done=1;
547                 }
548               break;
549
550             case 'k': /* short key id */
551               if(idx+8<maxlen)
552                 {
553                   sprintf(&ret[idx],"%08lX",(ulong)pk_keyid[1]);
554                   idx+=8;
555                   done=1;
556                 }
557               break;
558
559             case 'K': /* long key id */
560               if(idx+16<maxlen)
561                 {
562                   sprintf(&ret[idx],"%08lX%08lX",
563                           (ulong)pk_keyid[0],(ulong)pk_keyid[1]);
564                   idx+=16;
565                   done=1;
566                 }
567               break;
568
569             case 'c': /* signature count from card, if any. */
570               if(idx+10<maxlen)
571                 {
572                   sprintf(&ret[idx],"%lu",get_signature_count(args->sk));
573                   idx+=strlen(&ret[idx]);
574                   done=1;
575                 }
576               break;
577
578             case 'p': /* primary pk fingerprint of a sk */
579             case 'f': /* pk fingerprint */
580             case 'g': /* sk fingerprint */
581               {
582                 byte array[MAX_FINGERPRINT_LEN];
583                 size_t len;
584                 int i;
585
586                 if((*(ch+1))=='p' && args->sk)
587                   {
588                     if(args->sk->is_primary)
589                       fingerprint_from_sk(args->sk,array,&len);
590                     else if(args->sk->main_keyid[0] || args->sk->main_keyid[1])
591                       {
592                         PKT_public_key *pk=
593                           xmalloc_clear(sizeof(PKT_public_key));
594
595                         if(get_pubkey_fast(pk,args->sk->main_keyid)==0)
596                           fingerprint_from_pk(pk,array,&len);
597                         else
598                           memset(array,0,(len=MAX_FINGERPRINT_LEN));
599                         free_public_key(pk);
600                       }
601                     else
602                       memset(array,0,(len=MAX_FINGERPRINT_LEN));
603                   }
604                 else if((*(ch+1))=='f' && args->pk)
605                   fingerprint_from_pk(args->pk,array,&len);
606                 else if((*(ch+1))=='g' && args->sk)
607                   fingerprint_from_sk(args->sk,array,&len);
608                 else
609                   memset(array,0,(len=MAX_FINGERPRINT_LEN));
610
611                 if(idx+(len*2)<maxlen)
612                   {
613                     for(i=0;i<len;i++)
614                       {
615                         sprintf(&ret[idx],"%02X",array[i]);
616                         idx+=2;
617                       }
618                     done=1;
619                   }
620               }
621               break;
622
623             case 'v': /* validity letters */
624               if(args->validity_info && idx+1<maxlen)
625                 {
626                   ret[idx++]=args->validity_info;
627                   ret[idx]='\0';
628                   done=1;
629                 }
630               break;
631
632               /* The text string types */
633             case 't':
634             case 'T':
635             case 'V':
636               {
637                 const char *str=NULL;
638
639                 switch(*(ch+1))
640                   {
641                   case 't': /* e.g. "jpg" */
642                     str=image_type_to_string(args->imagetype,0);
643                     break;
644
645                   case 'T': /* e.g. "image/jpeg" */
646                     str=image_type_to_string(args->imagetype,2);
647                     break;
648
649                   case 'V': /* e.g. "full", "expired", etc. */
650                     str=args->validity_string;
651                     break;
652                   }
653
654                 if(str && idx+strlen(str)<maxlen)
655                   {
656                     strcpy(&ret[idx],str);
657                     idx+=strlen(str);
658                     done=1;
659                   }
660               }
661               break;
662
663             case '%':
664               if(idx+1<maxlen)
665                 {
666                   ret[idx++]='%';
667                   ret[idx]='\0';
668                   done=1;
669                 }
670               break;
671
672               /* Any unknown %-keys (like %i, %o, %I, and %O) are
673                  passed through for later expansion.  Note this also
674                  handles the case where the last character in the
675                  string is a '%' - the terminating \0 will end up here
676                  and properly terminate the string. */
677             default:
678               if(idx+2<maxlen)
679                 {
680                   ret[idx++]='%';
681                   ret[idx++]=*(ch+1);
682                   ret[idx]='\0';
683                   done=1;
684                 }
685               break;
686               }
687
688           if(done)
689             ch++;
690         }
691       else
692         {
693           if(idx+1<maxlen)
694             {
695               ret[idx++]=*ch;
696               ret[idx]='\0';
697               done=1;
698             }
699         }
700
701       if(done)
702         ch++;
703     }
704
705   return ret;
706
707  fail:
708   xfree(ret);
709   return NULL;
710 }
711
712 void
713 deprecated_warning(const char *configname,unsigned int configlineno,
714                    const char *option,const char *repl1,const char *repl2)
715 {
716   if(configname)
717     {
718       if(strncmp("--",option,2)==0)
719         option+=2;
720
721       if(strncmp("--",repl1,2)==0)
722         repl1+=2;
723
724       log_info(_("%s:%d: deprecated option \"%s\"\n"),
725                configname,configlineno,option);
726     }
727   else
728     log_info(_("WARNING: \"%s\" is a deprecated option\n"),option);
729
730   log_info(_("please use \"%s%s\" instead\n"),repl1,repl2);
731 }
732
733
734 void
735 deprecated_command (const char *name)
736 {
737   log_info(_("WARNING: \"%s\" is a deprecated command - do not use it\n"),
738            name);
739 }
740
741
742 const char *
743 compress_algo_to_string(int algo)
744 {
745   const char *s=NULL;
746
747   switch(algo)
748     {
749     case COMPRESS_ALGO_NONE:
750       s=_("Uncompressed");
751       break;
752
753     case COMPRESS_ALGO_ZIP:
754       s="ZIP";
755       break;
756
757     case COMPRESS_ALGO_ZLIB:
758       s="ZLIB";
759       break;
760
761 #ifdef HAVE_BZIP2
762     case COMPRESS_ALGO_BZIP2:
763       s="BZIP2";
764       break;
765 #endif
766     }
767
768   return s;
769 }
770
771 int
772 string_to_compress_algo(const char *string)
773 {
774   /* TRANSLATORS: See doc/TRANSLATE about this string. */
775   if(match_multistr(_("uncompressed|none"),string))
776     return 0;
777   else if(ascii_strcasecmp(string,"uncompressed")==0)
778     return 0;
779   else if(ascii_strcasecmp(string,"none")==0)
780     return 0;
781   else if(ascii_strcasecmp(string,"zip")==0)
782     return 1;
783   else if(ascii_strcasecmp(string,"zlib")==0)
784     return 2;
785 #ifdef HAVE_BZIP2
786   else if(ascii_strcasecmp(string,"bzip2")==0)
787     return 3;
788 #endif
789   else if(ascii_strcasecmp(string,"z0")==0)
790     return 0;
791   else if(ascii_strcasecmp(string,"z1")==0)
792     return 1;
793   else if(ascii_strcasecmp(string,"z2")==0)
794     return 2;
795 #ifdef HAVE_BZIP2
796   else if(ascii_strcasecmp(string,"z3")==0)
797     return 3;
798 #endif
799   else
800     return -1;
801 }
802
803 int
804 check_compress_algo(int algo)
805 {
806 #ifdef HAVE_BZIP2
807   if(algo>=0 && algo<=3)
808     return 0;
809 #else
810   if(algo>=0 && algo<=2)
811     return 0;
812 #endif
813
814   return G10ERR_COMPR_ALGO;
815 }
816
817 int
818 default_cipher_algo(void)
819 {
820   if(opt.def_cipher_algo)
821     return opt.def_cipher_algo;
822   else if(opt.personal_cipher_prefs)
823     return opt.personal_cipher_prefs[0].value;
824   else
825     return opt.s2k_cipher_algo;
826 }
827
828 /* There is no default_digest_algo function, but see
829    sign.c:hash_for() */
830
831 int
832 default_compress_algo(void)
833 {
834   if(opt.compress_algo!=-1)
835     return opt.compress_algo;
836   else if(opt.personal_compress_prefs)
837     return opt.personal_compress_prefs[0].value;
838   else
839     return DEFAULT_COMPRESS_ALGO;
840 }
841
842 const char *
843 compliance_option_string(void)
844 {
845   char *ver="???";
846
847   switch(opt.compliance)
848     {
849     case CO_GNUPG:   return "--gnupg";
850     case CO_RFC4880: return "--openpgp";
851     case CO_RFC2440: return "--rfc2440";
852     case CO_RFC1991: return "--rfc1991";
853     case CO_PGP2:    return "--pgp2";
854     case CO_PGP6:    return "--pgp6";
855     case CO_PGP7:    return "--pgp7";
856     case CO_PGP8:    return "--pgp8";
857     }
858
859   return ver;
860 }
861
862 void
863 compliance_failure(void)
864 {
865   char *ver="???";
866
867   switch(opt.compliance)
868     {
869     case CO_GNUPG:
870       ver="GnuPG";
871       break;
872
873     case CO_RFC4880:
874       ver="OpenPGP";
875       break;
876
877     case CO_RFC2440:
878       ver="OpenPGP (older)";
879       break;
880
881     case CO_RFC1991:
882       ver="old PGP";
883       break;
884
885     case CO_PGP2:
886       ver="PGP 2.x";
887       break;
888
889     case CO_PGP6:
890       ver="PGP 6.x";
891       break;
892
893     case CO_PGP7:
894       ver="PGP 7.x";
895       break;
896
897     case CO_PGP8:
898       ver="PGP 8.x";
899       break;
900     }
901
902   log_info(_("this message may not be usable by %s\n"),ver);
903   opt.compliance=CO_GNUPG;
904 }
905
906 /* Break a string into successive option pieces.  Accepts single word
907    options and key=value argument options. */
908 char *
909 optsep(char **stringp)
910 {
911   char *tok,*end;
912
913   tok=*stringp;
914   if(tok)
915     {
916       end=strpbrk(tok," ,=");
917       if(end)
918         {
919           int sawequals=0;
920           char *ptr=end;
921
922           /* what we need to do now is scan along starting with *end,
923              If the next character we see (ignoring spaces) is an =
924              sign, then there is an argument. */
925
926           while(*ptr)
927             {
928               if(*ptr=='=')
929                 sawequals=1;
930               else if(*ptr!=' ')
931                 break;
932               ptr++;
933             }
934
935           /* There is an argument, so grab that too.  At this point,
936              ptr points to the first character of the argument. */
937           if(sawequals)
938             {
939               /* Is it a quoted argument? */
940               if(*ptr=='"')
941                 {
942                   ptr++;
943                   end=strchr(ptr,'"');
944                   if(end)
945                     end++;
946                 }
947               else
948                 end=strpbrk(ptr," ,");
949             }
950
951           if(end && *end)
952             {
953               *end='\0';
954               *stringp=end+1;
955             }
956           else
957             *stringp=NULL;
958         }
959       else
960         *stringp=NULL;
961     }
962
963   return tok;
964 }
965
966 /* Breaks an option value into key and value.  Returns NULL if there
967    is no value.  Note that "string" is modified to remove the =value
968    part. */
969 char *
970 argsplit(char *string)
971 {
972   char *equals,*arg=NULL;
973
974   equals=strchr(string,'=');
975   if(equals)
976     {
977       char *quote,*space;
978
979       *equals='\0';
980       arg=equals+1;
981
982       /* Quoted arg? */
983       quote=strchr(arg,'"');
984       if(quote)
985         {
986           arg=quote+1;
987
988           quote=strchr(arg,'"');
989           if(quote)
990             *quote='\0';
991         }
992       else
993         {
994           size_t spaces;
995
996           /* Trim leading spaces off of the arg */
997           spaces=strspn(arg," ");
998           arg+=spaces;
999         }
1000
1001       /* Trim tailing spaces off of the tag */
1002       space=strchr(string,' ');
1003       if(space)
1004         *space='\0';
1005     }
1006
1007   return arg;
1008 }
1009
1010 /* Return the length of the initial token, leaving off any
1011    argument. */
1012 static size_t
1013 optlen(const char *s)
1014 {
1015   char *end=strpbrk(s," =");
1016
1017   if(end)
1018     return end-s;
1019   else
1020     return strlen(s);
1021 }
1022
1023 int
1024 parse_options(char *str,unsigned int *options,
1025               struct parse_options *opts,int noisy)
1026 {
1027   char *tok;
1028
1029   if (str && !strcmp (str, "help"))
1030     {
1031       int i,maxlen=0;
1032
1033       /* Figure out the longest option name so we can line these up
1034          neatly. */
1035       for(i=0;opts[i].name;i++)
1036         if(opts[i].help && maxlen<strlen(opts[i].name))
1037           maxlen=strlen(opts[i].name);
1038
1039       for(i=0;opts[i].name;i++)
1040         if(opts[i].help)
1041           printf("%s%*s%s\n",opts[i].name,
1042                  maxlen+2-(int)strlen(opts[i].name),"",_(opts[i].help));
1043
1044       g10_exit(0);
1045     }
1046
1047   while((tok=optsep(&str)))
1048     {
1049       int i,rev=0;
1050       char *otok=tok;
1051
1052       if(tok[0]=='\0')
1053         continue;
1054
1055       if(ascii_strncasecmp("no-",tok,3)==0)
1056         {
1057           rev=1;
1058           tok+=3;
1059         }
1060
1061       for(i=0;opts[i].name;i++)
1062         {
1063           size_t toklen=optlen(tok);
1064
1065           if(ascii_strncasecmp(opts[i].name,tok,toklen)==0)
1066             {
1067               /* We have a match, but it might be incomplete */
1068               if(toklen!=strlen(opts[i].name))
1069                 {
1070                   int j;
1071
1072                   for(j=i+1;opts[j].name;j++)
1073                     {
1074                       if(ascii_strncasecmp(opts[j].name,tok,toklen)==0)
1075                         {
1076                           if(noisy)
1077                             log_info(_("ambiguous option `%s'\n"),otok);
1078                           return 0;
1079                         }
1080                     }
1081                 }
1082
1083               if(rev)
1084                 {
1085                   *options&=~opts[i].bit;
1086                   if(opts[i].value)
1087                     *opts[i].value=NULL;
1088                 }
1089               else
1090                 {
1091                   *options|=opts[i].bit;
1092                   if(opts[i].value)
1093                     *opts[i].value=argsplit(tok);
1094                 }
1095               break;
1096             }
1097         }
1098
1099       if(!opts[i].name)
1100         {
1101           if(noisy)
1102             log_info(_("unknown option `%s'\n"),otok);
1103           return 0;
1104         }
1105     }
1106
1107   return 1;
1108 }
1109
1110
1111 /* Return a new malloced string by unescaping the string S.  Escaping
1112    is percent escaping and '+'/space mapping.  A binary nul will
1113    silently be replaced by a 0xFF. */
1114 char *
1115 unescape_percent_string (const unsigned char *s)
1116 {
1117   char *buffer, *d;
1118
1119   buffer = d = xmalloc (strlen (s)+1);
1120   while (*s)
1121     {
1122       if (*s == '%' && s[1] && s[2])
1123         {
1124           s++;
1125           *d = xtoi_2 (s);
1126           if (!*d)
1127             *d = '\xff';
1128           d++;
1129           s += 2;
1130         }
1131       else if (*s == '+')
1132         {
1133           *d++ = ' ';
1134           s++;
1135         }
1136       else
1137         *d++ = *s++;
1138     }
1139   *d = 0;
1140   return buffer;
1141 }
1142
1143
1144 /* Check whether the string has characters not valid in an RFC-822
1145    address.  To cope with OpenPGP we ignore non-ascii characters
1146    so that for example umlauts are legal in an email address.  An
1147    OpenPGP user ID must be utf-8 encoded but there is no strict
1148    requirement for RFC-822.  Thus to avoid IDNA encoding we put the
1149    address verbatim as utf-8 into the user ID under the assumption
1150    that mail programs handle IDNA at a lower level and take OpenPGP
1151    user IDs as utf-8.  Note that we can't do an utf-8 encoding
1152    checking here because in keygen.c this function is called with the
1153    native encoding and native to utf-8 encoding is only done  later.  */
1154 int
1155 has_invalid_email_chars (const char *s)
1156 {
1157   int at_seen=0;
1158   const char *valid_chars=
1159     "01234567890_-.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
1160
1161   for ( ; *s; s++ )
1162     {
1163       if ( *s & 0x80 )
1164         continue; /* We only care about ASCII.  */
1165       if ( *s == '@' )
1166         at_seen=1;
1167       else if ( !at_seen && !( !!strchr( valid_chars, *s ) || *s == '+' ) )
1168         return 1;
1169       else if ( at_seen && !strchr( valid_chars, *s ) )
1170         return 1;
1171     }
1172   return 0;
1173 }
1174
1175
1176 /* Check whether NAME represents a valid mailbox according to
1177    RFC822. Returns true if so. */
1178 int
1179 is_valid_mailbox (const char *name)
1180 {
1181   return !( !name
1182             || !*name
1183             || has_invalid_email_chars (name)
1184             || string_count_chr (name,'@') != 1
1185             || *name == '@'
1186             || name[strlen(name)-1] == '@'
1187             || name[strlen(name)-1] == '.'
1188             || strstr (name, "..") );
1189 }
1190
1191
1192 /* This is a helper function to load a Windows function from either of
1193    one DLLs. */
1194 #ifdef HAVE_W32_SYSTEM
1195 static HRESULT
1196 w32_shgetfolderpath (HWND a, int b, HANDLE c, DWORD d, LPSTR e)
1197 {
1198   static int initialized;
1199   static HRESULT (WINAPI * func)(HWND,int,HANDLE,DWORD,LPSTR);
1200
1201   if (!initialized)
1202     {
1203       static char *dllnames[] = { "shell32.dll", "shfolder.dll", NULL };
1204       void *handle;
1205       int i;
1206
1207       initialized = 1;
1208
1209       for (i=0, handle = NULL; !handle && dllnames[i]; i++)
1210         {
1211           handle = dlopen (dllnames[i], RTLD_LAZY);
1212           if (handle)
1213             {
1214               func = dlsym (handle, "SHGetFolderPathA");
1215               if (!func)
1216                 {
1217                   dlclose (handle);
1218                   handle = NULL;
1219                 }
1220             }
1221         }
1222     }
1223
1224   if (func)
1225     return func (a,b,c,d,e);
1226   else
1227     return -1;
1228 }
1229 #endif /*HAVE_W32_SYSTEM*/
1230
1231
1232 /* Set up the default home directory.  The usual --homedir option
1233    should be parsed later. */
1234 char *
1235 default_homedir (void)
1236 {
1237   char *dir;
1238
1239   dir = getenv("GNUPGHOME");
1240 #ifdef HAVE_W32_SYSTEM
1241   if (!dir || !*dir)
1242     dir = read_w32_registry_string (NULL, "Software\\GNU\\GnuPG", "HomeDir");
1243   if (!dir || !*dir)
1244     {
1245       char path[MAX_PATH];
1246
1247       /* It might be better to use LOCAL_APPDATA because this is
1248          defined as "non roaming" and thus more likely to be kept
1249          locally.  For private keys this is desired.  However, given
1250          that many users copy private keys anyway forth and back,
1251          using a system roaming serives might be better than to let
1252          them do it manually.  A security conscious user will anyway
1253          use the registry entry to have better control.  */
1254       if (w32_shgetfolderpath (NULL, CSIDL_APPDATA|CSIDL_FLAG_CREATE,
1255                                NULL, 0, path) >= 0)
1256         {
1257           char *tmp = xmalloc (strlen (path) + 6 +1);
1258           strcpy (stpcpy (tmp, path), "\\gnupg");
1259           dir = tmp;
1260
1261           /* Try to create the directory if it does not yet
1262              exists.  */
1263           if (access (dir, F_OK))
1264             CreateDirectory (dir, NULL);
1265         }
1266     }
1267 #endif /*HAVE_W32_SYSTEM*/
1268   if (!dir || !*dir)
1269     dir = GNUPG_HOMEDIR;
1270
1271   return dir;
1272 }
1273
1274
1275 /* Return the name of the libexec directory.  The name is allocated in
1276    a static area on the first use.  This function won't fail. */
1277 const char *
1278 get_libexecdir (void)
1279 {
1280 #ifdef HAVE_W32_SYSTEM
1281   static int got_dir;
1282   static char dir[MAX_PATH+5];
1283
1284   if (!got_dir)
1285     {
1286       char *p;
1287
1288       if ( !GetModuleFileName ( NULL, dir, MAX_PATH) )
1289         {
1290           log_debug ("GetModuleFileName failed: %s\n", w32_strerror (0));
1291           *dir = 0;
1292         }
1293       got_dir = 1;
1294       p = strrchr (dir, DIRSEP_C);
1295       if (p)
1296         *p = 0;
1297       else
1298         {
1299           log_debug ("bad filename `%s' returned for this process\n", dir);
1300           *dir = 0;
1301         }
1302     }
1303
1304   if (*dir)
1305     return dir;
1306   /* Fallback to the hardwired value. */
1307 #endif /*HAVE_W32_SYSTEM*/
1308
1309   return GNUPG_LIBEXECDIR;
1310 }
1311
1312 /* Similar to access(2), but uses PATH to find the file.
1313
1314    (2006-07-08 SMS: See "vmslib/vms.c" for a VMS-specific replacement
1315    function) */
1316 #ifndef __VMS
1317 int
1318 path_access(const char *file,int mode)
1319 {
1320   char *envpath;
1321   int ret=-1;
1322
1323   envpath=getenv("PATH");
1324
1325   if(!envpath
1326 #ifdef HAVE_DRIVE_LETTERS
1327      || (((file[0]>='A' && file[0]<='Z')
1328           || (file[0]>='a' && file[0]<='z'))
1329          && file[1]==':')
1330 #else
1331      || file[0]=='/'
1332 #endif
1333      )
1334     return access(file,mode);
1335   else
1336     {
1337       /* At least as large as, but most often larger than we need. */
1338       char *buffer=xmalloc(strlen(envpath)+1+strlen(file)+1);
1339       char *split,*item,*path=xstrdup(envpath);
1340
1341       split=path;
1342
1343       while((item=strsep(&split,PATHSEP_S)))
1344         {
1345           strcpy(buffer,item);
1346           strcat(buffer,"/");
1347           strcat(buffer,file);
1348           ret=access(buffer,mode);
1349           if(ret==0)
1350             break;
1351         }
1352
1353       xfree(path);
1354       xfree(buffer);
1355     }
1356
1357   return ret;
1358 }
1359 #endif /*ndef __VMS*/
1360