common: Remove debug output from gnupg_get_socket_name.
[gnupg.git] / common / stringhelp.c
1 /* stringhelp.c -  standard string helper functions
2  * Copyright (C) 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007,
3  *               2008, 2009, 2010  Free Software Foundation, Inc.
4  * Copyright (C) 2014 Werner Koch
5  * Copyright (C) 2015  g10 Code GmbH
6  *
7  * This file is part of GnuPG.
8  *
9  * GnuPG is free software; you can redistribute it and/or modify it
10  * under the terms of either
11  *
12  *   - the GNU Lesser General Public License as published by the Free
13  *     Software Foundation; either version 3 of the License, or (at
14  *     your option) any later version.
15  *
16  * or
17  *
18  *   - the GNU General Public License as published by the Free
19  *     Software Foundation; either version 2 of the License, or (at
20  *     your option) any later version.
21  *
22  * or both in parallel, as here.
23  *
24  * GnuPG is distributed in the hope that it will be useful, but
25  * WITHOUT ANY WARRANTY; without even the implied warranty of
26  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
27  * General Public License for more details.
28  *
29  * You should have received a copies of the GNU General Public License
30  * and the GNU Lesser General Public License along with this program;
31  * if not, see <http://www.gnu.org/licenses/>.
32  */
33
34 #include <config.h>
35 #include <stdlib.h>
36 #include <string.h>
37 #include <stdarg.h>
38 #include <ctype.h>
39 #include <errno.h>
40 #ifdef HAVE_PWD_H
41 # include <pwd.h>
42 #endif
43 #include <unistd.h>
44 #include <sys/types.h>
45 #ifdef HAVE_W32_SYSTEM
46 # ifdef HAVE_WINSOCK2_H
47 #  include <winsock2.h>
48 # endif
49 # include <windows.h>
50 #endif
51 #include <assert.h>
52
53 #include "util.h"
54 #include "common-defs.h"
55 #include "utf8conv.h"
56 #include "sysutils.h"
57 #include "stringhelp.h"
58
59 #define tohex_lower(n) ((n) < 10 ? ((n) + '0') : (((n) - 10) + 'a'))
60
61
62 /* Sometimes we want to avoid mixing slashes and backslashes on W32
63    and prefer backslashes.  There is usual no problem with mixing
64    them, however a very few W32 API calls can't grok plain slashes.
65    Printing filenames with mixed slashes also looks a bit strange.
66    This function has no effext on POSIX. */
67 static inline char *
68 change_slashes (char *name)
69 {
70 #ifdef HAVE_DOSISH_SYSTEM
71   char *p;
72
73   if (strchr (name, '\\'))
74     {
75       for (p=name; *p; p++)
76         if (*p == '/')
77           *p = '\\';
78     }
79 #endif /*HAVE_DOSISH_SYSTEM*/
80   return name;
81 }
82
83
84 /*
85  * Check whether STRING starts with KEYWORD.  The keyword is
86  * delimited by end of string, a space or a tab.  Returns NULL if not
87  * found or a pointer into STRING to the next non-space character
88  * after the KEYWORD (which may be end of string).
89  */
90 char *
91 has_leading_keyword (const char *string, const char *keyword)
92 {
93   size_t n = strlen (keyword);
94
95   if (!strncmp (string, keyword, n)
96       && (!string[n] || string[n] == ' ' || string[n] == '\t'))
97     {
98       string += n;
99       while (*string == ' ' || *string == '\t')
100         string++;
101       return (char*)string;
102     }
103   return NULL;
104 }
105
106
107 /*
108  * Look for the substring SUB in buffer and return a pointer to that
109  * substring in BUFFER or NULL if not found.
110  * Comparison is case-insensitive.
111  */
112 const char *
113 memistr (const void *buffer, size_t buflen, const char *sub)
114 {
115   const unsigned char *buf = buffer;
116   const unsigned char *t = (const unsigned char *)buffer;
117   const unsigned char *s = (const unsigned char *)sub;
118   size_t n = buflen;
119
120   for ( ; n ; t++, n-- )
121     {
122       if ( toupper (*t) == toupper (*s) )
123         {
124           for ( buf=t++, buflen = n--, s++;
125                 n && toupper (*t) == toupper (*s); t++, s++, n-- )
126             ;
127           if (!*s)
128             return (const char*)buf;
129           t = buf;
130           s = (const unsigned char *)sub ;
131           n = buflen;
132         }
133     }
134   return NULL;
135 }
136
137 const char *
138 ascii_memistr ( const void *buffer, size_t buflen, const char *sub )
139 {
140   const unsigned char *buf = buffer;
141   const unsigned char *t = (const unsigned char *)buf;
142   const unsigned char *s = (const unsigned char *)sub;
143   size_t n = buflen;
144
145   for ( ; n ; t++, n-- )
146     {
147       if (ascii_toupper (*t) == ascii_toupper (*s) )
148         {
149           for ( buf=t++, buflen = n--, s++;
150                 n && ascii_toupper (*t) == ascii_toupper (*s); t++, s++, n-- )
151             ;
152           if (!*s)
153             return (const char*)buf;
154           t = (const unsigned char *)buf;
155           s = (const unsigned char *)sub ;
156           n = buflen;
157         }
158     }
159   return NULL;
160 }
161
162 /* This function is similar to strncpy().  However it won't copy more
163    than N - 1 characters and makes sure that a '\0' is appended. With
164    N given as 0, nothing will happen.  With DEST given as NULL, memory
165    will be allocated using xmalloc (i.e. if it runs out of core
166    the function terminates).  Returns DES or a pointer to the
167    allocated memory.
168  */
169 char *
170 mem2str( char *dest , const void *src , size_t n )
171 {
172     char *d;
173     const char *s;
174
175     if( n ) {
176         if( !dest )
177             dest = xmalloc( n ) ;
178         d = dest;
179         s = src ;
180         for(n--; n && *s; n-- )
181             *d++ = *s++;
182         *d = '\0' ;
183     }
184
185     return dest ;
186 }
187
188
189 /****************
190  * remove leading and trailing white spaces
191  */
192 char *
193 trim_spaces( char *str )
194 {
195     char *string, *p, *mark;
196
197     string = str;
198     /* find first non space character */
199     for( p=string; *p && isspace( *(byte*)p ) ; p++ )
200         ;
201     /* move characters */
202     for( (mark = NULL); (*string = *p); string++, p++ )
203         if( isspace( *(byte*)p ) ) {
204             if( !mark )
205                 mark = string ;
206         }
207         else
208             mark = NULL ;
209     if( mark )
210         *mark = '\0' ;  /* remove trailing spaces */
211
212     return str ;
213 }
214
215 /****************
216  * remove trailing white spaces
217  */
218 char *
219 trim_trailing_spaces( char *string )
220 {
221     char *p, *mark;
222
223     for( mark = NULL, p = string; *p; p++ ) {
224         if( isspace( *(byte*)p ) ) {
225             if( !mark )
226                 mark = p;
227         }
228         else
229             mark = NULL;
230     }
231     if( mark )
232         *mark = '\0' ;
233
234     return string ;
235 }
236
237
238 unsigned
239 trim_trailing_chars( byte *line, unsigned len, const char *trimchars )
240 {
241     byte *p, *mark;
242     unsigned n;
243
244     for(mark=NULL, p=line, n=0; n < len; n++, p++ ) {
245         if( strchr(trimchars, *p ) ) {
246             if( !mark )
247                 mark = p;
248         }
249         else
250             mark = NULL;
251     }
252
253     if( mark ) {
254         *mark = 0;
255         return mark - line;
256     }
257     return len;
258 }
259
260 /****************
261  * remove trailing white spaces and return the length of the buffer
262  */
263 unsigned
264 trim_trailing_ws( byte *line, unsigned len )
265 {
266     return trim_trailing_chars( line, len, " \t\r\n" );
267 }
268
269 size_t
270 length_sans_trailing_chars (const unsigned char *line, size_t len,
271                             const char *trimchars )
272 {
273   const unsigned char *p, *mark;
274   size_t n;
275
276   for( mark=NULL, p=line, n=0; n < len; n++, p++ )
277     {
278       if (strchr (trimchars, *p ))
279         {
280           if( !mark )
281             mark = p;
282         }
283       else
284         mark = NULL;
285     }
286
287   if (mark)
288     return mark - line;
289   return len;
290 }
291
292 /*
293  *  Return the length of line ignoring trailing white-space.
294  */
295 size_t
296 length_sans_trailing_ws (const unsigned char *line, size_t len)
297 {
298   return length_sans_trailing_chars (line, len, " \t\r\n");
299 }
300
301
302
303 /*
304  * Extract from a given path the filename component.  This function
305  * terminates the process on memory shortage.
306  */
307 char *
308 make_basename(const char *filepath, const char *inputpath)
309 {
310 #ifdef __riscos__
311     return riscos_make_basename(filepath, inputpath);
312 #else
313     char *p;
314
315     (void)inputpath; /* Only required for riscos.  */
316
317     if ( !(p=strrchr(filepath, '/')) )
318 #ifdef HAVE_DOSISH_SYSTEM
319         if ( !(p=strrchr(filepath, '\\')) )
320 #endif
321 #ifdef HAVE_DRIVE_LETTERS
322             if ( !(p=strrchr(filepath, ':')) )
323 #endif
324               {
325                 return xstrdup(filepath);
326               }
327
328     return xstrdup(p+1);
329 #endif
330 }
331
332
333
334 /*
335  * Extract from a given filename the path prepended to it.  If there
336  * isn't a path prepended to the filename, a dot is returned ('.').
337  * This function terminates the process on memory shortage.
338  */
339 char *
340 make_dirname(const char *filepath)
341 {
342     char *dirname;
343     int  dirname_length;
344     char *p;
345
346     if ( !(p=strrchr(filepath, '/')) )
347 #ifdef HAVE_DOSISH_SYSTEM
348         if ( !(p=strrchr(filepath, '\\')) )
349 #endif
350 #ifdef HAVE_DRIVE_LETTERS
351             if ( !(p=strrchr(filepath, ':')) )
352 #endif
353               {
354                 return xstrdup(".");
355               }
356
357     dirname_length = p-filepath;
358     dirname = xmalloc(dirname_length+1);
359     strncpy(dirname, filepath, dirname_length);
360     dirname[dirname_length] = 0;
361
362     return dirname;
363 }
364
365
366 \f
367 static char *
368 get_pwdir (int xmode, const char *name)
369 {
370   char *result = NULL;
371 #ifdef HAVE_PWD_H
372   struct passwd *pwd = NULL;
373
374   if (name)
375     {
376 #ifdef HAVE_GETPWNAM
377       /* Fixme: We should use getpwnam_r if available.  */
378       pwd = getpwnam (name);
379 #endif
380     }
381   else
382     {
383 #ifdef HAVE_GETPWUID
384       /* Fixme: We should use getpwuid_r if available.  */
385       pwd = getpwuid (getuid());
386 #endif
387     }
388   if (pwd)
389     {
390       if (xmode)
391         result = xstrdup (pwd->pw_dir);
392       else
393         result = xtrystrdup (pwd->pw_dir);
394     }
395 #else /*!HAVE_PWD_H*/
396   /* No support at all.  */
397   (void)xmode;
398   (void)name;
399 #endif /*HAVE_PWD_H*/
400   return result;
401 }
402
403
404 /* xmode 0 := Return NULL on error
405          1 := Terminate on error
406          2 := Make sure that name is absolute; return NULL on error
407          3 := Make sure that name is absolute; terminate on error
408  */
409 static char *
410 do_make_filename (int xmode, const char *first_part, va_list arg_ptr)
411 {
412   const char *argv[32];
413   int argc;
414   size_t n;
415   int skip = 1;
416   char *home_buffer = NULL;
417   char *name, *home, *p;
418   int want_abs;
419
420   want_abs = !!(xmode & 2);
421   xmode &= 1;
422
423   n = strlen (first_part) + 1;
424   argc = 0;
425   while ( (argv[argc] = va_arg (arg_ptr, const char *)) )
426     {
427       n += strlen (argv[argc]) + 1;
428       if (argc >= DIM (argv)-1)
429         {
430           if (xmode)
431             BUG ();
432           gpg_err_set_errno (EINVAL);
433           return NULL;
434         }
435       argc++;
436     }
437   n++;
438
439   home = NULL;
440   if (*first_part == '~')
441     {
442       if (first_part[1] == '/' || !first_part[1])
443         {
444           /* This is the "~/" or "~" case.  */
445           home = getenv("HOME");
446           if (!home)
447             home = home_buffer = get_pwdir (xmode, NULL);
448           if (home && *home)
449             n += strlen (home);
450         }
451       else
452         {
453           /* This is the "~username/" or "~username" case.  */
454           char *user;
455
456           if (xmode)
457             user = xstrdup (first_part+1);
458           else
459             {
460               user = xtrystrdup (first_part+1);
461               if (!user)
462                 return NULL;
463             }
464           p = strchr (user, '/');
465           if (p)
466             *p = 0;
467           skip = 1 + strlen (user);
468
469           home = home_buffer = get_pwdir (xmode, user);
470           xfree (user);
471           if (home)
472             n += strlen (home);
473           else
474             skip = 1;
475         }
476     }
477
478   if (xmode)
479     name = xmalloc (n);
480   else
481     {
482       name = xtrymalloc (n);
483       if (!name)
484         {
485           xfree (home_buffer);
486           return NULL;
487         }
488     }
489
490   if (home)
491     p = stpcpy (stpcpy (name, home), first_part + skip);
492   else
493     p = stpcpy (name, first_part);
494
495   xfree (home_buffer);
496   for (argc=0; argv[argc]; argc++)
497     {
498       /* Avoid a leading double slash if the first part was "/".  */
499       if (!argc && name[0] == '/' && !name[1])
500         p = stpcpy (p, argv[argc]);
501       else
502         p = stpcpy (stpcpy (p, "/"), argv[argc]);
503     }
504
505   if (want_abs)
506     {
507 #ifdef HAVE_DRIVE_LETTERS
508       p = strchr (name, ':');
509       if (p)
510         p++;
511       else
512         p = name;
513 #else
514       p = name;
515 #endif
516       if (*p != '/'
517 #ifdef HAVE_DRIVE_LETTERS
518           && *p != '\\'
519 #endif
520           )
521         {
522           home = gnupg_getcwd ();
523           if (!home)
524             {
525               if (xmode)
526                 {
527                   fprintf (stderr, "\nfatal: getcwd failed: %s\n",
528                            strerror (errno));
529                   exit(2);
530                 }
531               xfree (name);
532               return NULL;
533             }
534           n = strlen (home) + 1 + strlen (name) + 1;
535           if (xmode)
536             home_buffer = xmalloc (n);
537           else
538             {
539               home_buffer = xtrymalloc (n);
540               if (!home_buffer)
541                 {
542                   xfree (home);
543                   xfree (name);
544                   return NULL;
545                 }
546             }
547           if (p == name)
548             p = home_buffer;
549           else /* Windows case.  */
550             {
551               memcpy (home_buffer, p, p - name + 1);
552               p = home_buffer + (p - name + 1);
553             }
554
555           /* Avoid a leading double slash if the cwd is "/".  */
556           if (home[0] == '/' && !home[1])
557             strcpy (stpcpy (p, "/"), name);
558           else
559             strcpy (stpcpy (stpcpy (p, home), "/"), name);
560
561           xfree (home);
562           xfree (name);
563           name = home_buffer;
564           /* Let's do a simple compression to catch the most common
565              case of using "." for gpg's --homedir option.  */
566           n = strlen (name);
567           if (n > 2 && name[n-2] == '/' && name[n-1] == '.')
568             name[n-2] = 0;
569         }
570     }
571   return change_slashes (name);
572 }
573
574 /* Construct a filename from the NULL terminated list of parts.  Tilde
575    expansion is done for the first argument.  This function terminates
576    the process on memory shortage. */
577 char *
578 make_filename (const char *first_part, ... )
579 {
580   va_list arg_ptr;
581   char *result;
582
583   va_start (arg_ptr, first_part);
584   result = do_make_filename (1, first_part, arg_ptr);
585   va_end (arg_ptr);
586   return result;
587 }
588
589 /* Construct a filename from the NULL terminated list of parts.  Tilde
590    expansion is done for the first argument.  This function may return
591    NULL on error. */
592 char *
593 make_filename_try (const char *first_part, ... )
594 {
595   va_list arg_ptr;
596   char *result;
597
598   va_start (arg_ptr, first_part);
599   result = do_make_filename (0, first_part, arg_ptr);
600   va_end (arg_ptr);
601   return result;
602 }
603
604 /* Construct an absolute filename from the NULL terminated list of
605    parts.  Tilde expansion is done for the first argument.  This
606    function terminates the process on memory shortage. */
607 char *
608 make_absfilename (const char *first_part, ... )
609 {
610   va_list arg_ptr;
611   char *result;
612
613   va_start (arg_ptr, first_part);
614   result = do_make_filename (3, first_part, arg_ptr);
615   va_end (arg_ptr);
616   return result;
617 }
618
619 /* Construct an absolute filename from the NULL terminated list of
620    parts.  Tilde expansion is done for the first argument.  This
621    function may return NULL on error. */
622 char *
623 make_absfilename_try (const char *first_part, ... )
624 {
625   va_list arg_ptr;
626   char *result;
627
628   va_start (arg_ptr, first_part);
629   result = do_make_filename (2, first_part, arg_ptr);
630   va_end (arg_ptr);
631   return result;
632 }
633
634
635 \f
636 /* Compare whether the filenames are identical.  This is a
637    special version of strcmp() taking the semantics of filenames in
638    account.  Note that this function works only on the supplied names
639    without considering any context like the current directory.  See
640    also same_file_p(). */
641 int
642 compare_filenames (const char *a, const char *b)
643 {
644 #ifdef HAVE_DOSISH_SYSTEM
645   for ( ; *a && *b; a++, b++ )
646     {
647       if (*a != *b
648           && (toupper (*(const unsigned char*)a)
649               != toupper (*(const unsigned char*)b) )
650           && !((*a == '/' && *b == '\\') || (*a == '\\' && *b == '/')))
651         break;
652     }
653   if ((*a == '/' && *b == '\\') || (*a == '\\' && *b == '/'))
654     return 0;
655   else
656     return (toupper (*(const unsigned char*)a)
657             - toupper (*(const unsigned char*)b));
658 #else
659     return strcmp(a,b);
660 #endif
661 }
662
663
664 /* Convert a base-10 number in STRING into a 64 bit unsigned int
665  * value.  Leading white spaces are skipped but no error checking is
666  * done.  Thus it is similar to atoi(). */
667 uint64_t
668 string_to_u64 (const char *string)
669 {
670   uint64_t val = 0;
671
672   while (spacep (string))
673     string++;
674   for (; digitp (string); string++)
675     {
676       val *= 10;
677       val += *string - '0';
678     }
679   return val;
680 }
681
682
683 /* Convert 2 hex characters at S to a byte value.  Return this value
684    or -1 if there is an error. */
685 int
686 hextobyte (const char *s)
687 {
688   int c;
689
690   if ( *s >= '0' && *s <= '9' )
691     c = 16 * (*s - '0');
692   else if ( *s >= 'A' && *s <= 'F' )
693     c = 16 * (10 + *s - 'A');
694   else if ( *s >= 'a' && *s <= 'f' )
695     c = 16 * (10 + *s - 'a');
696   else
697     return -1;
698   s++;
699   if ( *s >= '0' && *s <= '9' )
700     c += *s - '0';
701   else if ( *s >= 'A' && *s <= 'F' )
702     c += 10 + *s - 'A';
703   else if ( *s >= 'a' && *s <= 'f' )
704     c += 10 + *s - 'a';
705   else
706     return -1;
707   return c;
708 }
709
710 /* Given a string containing an UTF-8 encoded text, return the number
711    of characters in this string.  It differs from strlen in that it
712    only counts complete UTF-8 characters.  SIZE is the maximum length
713    of the string in bytes.  If SIZE is -1, then a NUL character is
714    taken to be the end of the string.  Note, that this function does
715    not take combined characters into account.  */
716 size_t
717 utf8_charcount (const char *s, int len)
718 {
719   size_t n;
720
721   if (len == 0)
722     return 0;
723
724   for (n=0; *s; s++)
725     {
726       if ( (*s&0xc0) != 0x80 ) /* Exclude continuation bytes: 10xxxxxx */
727         n++;
728
729       if (len != -1)
730         {
731           len --;
732           if (len == 0)
733             break;
734         }
735     }
736
737   return n;
738 }
739
740
741 /****************************************************
742  **********  W32 specific functions  ****************
743  ****************************************************/
744
745 #ifdef HAVE_W32_SYSTEM
746 const char *
747 w32_strerror (int ec)
748 {
749   static char strerr[256];
750
751   if (ec == -1)
752     ec = (int)GetLastError ();
753 #ifdef HAVE_W32CE_SYSTEM
754   /* There is only a wchar_t FormatMessage.  It does not make much
755      sense to play the conversion game; we print only the code.  */
756   snprintf (strerr, sizeof strerr, "ec=%d", (int)GetLastError ());
757 #else
758   FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, NULL, ec,
759                  MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
760                  strerr, DIM (strerr)-1, NULL);
761 #endif
762   return strerr;
763 }
764 #endif /*HAVE_W32_SYSTEM*/
765
766
767 /****************************************************
768  ******** Locale insensitive ctype functions ********
769  ****************************************************/
770 /* FIXME: replace them by a table lookup and macros */
771 int
772 ascii_isupper (int c)
773 {
774     return c >= 'A' && c <= 'Z';
775 }
776
777 int
778 ascii_islower (int c)
779 {
780     return c >= 'a' && c <= 'z';
781 }
782
783 int
784 ascii_toupper (int c)
785 {
786     if (c >= 'a' && c <= 'z')
787         c &= ~0x20;
788     return c;
789 }
790
791 int
792 ascii_tolower (int c)
793 {
794     if (c >= 'A' && c <= 'Z')
795         c |= 0x20;
796     return c;
797 }
798
799 /* Lowercase all ASCII characters in S.  */
800 char *
801 ascii_strlwr (char *s)
802 {
803   char *p = s;
804
805   for (p=s; *p; p++ )
806     if (isascii (*p) && *p >= 'A' && *p <= 'Z')
807       *p |= 0x20;
808
809   return s;
810 }
811
812 int
813 ascii_strcasecmp( const char *a, const char *b )
814 {
815     if (a == b)
816         return 0;
817
818     for (; *a && *b; a++, b++) {
819         if (*a != *b && ascii_toupper(*a) != ascii_toupper(*b))
820             break;
821     }
822     return *a == *b? 0 : (ascii_toupper (*a) - ascii_toupper (*b));
823 }
824
825 int
826 ascii_strncasecmp (const char *a, const char *b, size_t n)
827 {
828   const unsigned char *p1 = (const unsigned char *)a;
829   const unsigned char *p2 = (const unsigned char *)b;
830   unsigned char c1, c2;
831
832   if (p1 == p2 || !n )
833     return 0;
834
835   do
836     {
837       c1 = ascii_tolower (*p1);
838       c2 = ascii_tolower (*p2);
839
840       if ( !--n || c1 == '\0')
841         break;
842
843       ++p1;
844       ++p2;
845     }
846   while (c1 == c2);
847
848   return c1 - c2;
849 }
850
851
852 int
853 ascii_memcasecmp (const void *a_arg, const void *b_arg, size_t n )
854 {
855   const char *a = a_arg;
856   const char *b = b_arg;
857
858   if (a == b)
859     return 0;
860   for ( ; n; n--, a++, b++ )
861     {
862       if( *a != *b  && ascii_toupper (*a) != ascii_toupper (*b) )
863         return *a == *b? 0 : (ascii_toupper (*a) - ascii_toupper (*b));
864     }
865   return 0;
866 }
867
868 int
869 ascii_strcmp( const char *a, const char *b )
870 {
871     if (a == b)
872         return 0;
873
874     for (; *a && *b; a++, b++) {
875         if (*a != *b )
876             break;
877     }
878     return *a == *b? 0 : (*(signed char *)a - *(signed char *)b);
879 }
880
881
882 void *
883 ascii_memcasemem (const void *haystack, size_t nhaystack,
884                   const void *needle, size_t nneedle)
885 {
886
887   if (!nneedle)
888     return (void*)haystack; /* finding an empty needle is really easy */
889   if (nneedle <= nhaystack)
890     {
891       const char *a = haystack;
892       const char *b = a + nhaystack - nneedle;
893
894       for (; a <= b; a++)
895         {
896           if ( !ascii_memcasecmp (a, needle, nneedle) )
897             return (void *)a;
898         }
899     }
900   return NULL;
901 }
902
903 /*********************************************
904  ********** missing string functions *********
905  *********************************************/
906
907 #ifndef HAVE_STPCPY
908 char *
909 stpcpy(char *a,const char *b)
910 {
911     while( *b )
912         *a++ = *b++;
913     *a = 0;
914
915     return (char*)a;
916 }
917 #endif
918
919 #ifndef HAVE_STRPBRK
920 /* Find the first occurrence in S of any character in ACCEPT.
921    Code taken from glibc-2.6/string/strpbrk.c (LGPLv2.1+) and modified. */
922 char *
923 strpbrk (const char *s, const char *accept)
924 {
925   while (*s != '\0')
926     {
927       const char *a = accept;
928       while (*a != '\0')
929         if (*a++ == *s)
930           return (char *) s;
931       ++s;
932     }
933
934   return NULL;
935 }
936 #endif /*!HAVE_STRPBRK*/
937
938
939 #ifndef HAVE_STRSEP
940 /* Code taken from glibc-2.2.1/sysdeps/generic/strsep.c. */
941 char *
942 strsep (char **stringp, const char *delim)
943 {
944   char *begin, *end;
945
946   begin = *stringp;
947   if (begin == NULL)
948     return NULL;
949
950   /* A frequent case is when the delimiter string contains only one
951      character.  Here we don't need to call the expensive 'strpbrk'
952      function and instead work using 'strchr'.  */
953   if (delim[0] == '\0' || delim[1] == '\0')
954     {
955       char ch = delim[0];
956
957       if (ch == '\0')
958         end = NULL;
959       else
960         {
961           if (*begin == ch)
962             end = begin;
963           else if (*begin == '\0')
964             end = NULL;
965           else
966             end = strchr (begin + 1, ch);
967         }
968     }
969   else
970     /* Find the end of the token.  */
971     end = strpbrk (begin, delim);
972
973   if (end)
974     {
975       /* Terminate the token and set *STRINGP past NUL character.  */
976       *end++ = '\0';
977       *stringp = end;
978     }
979   else
980     /* No more delimiters; this is the last token.  */
981     *stringp = NULL;
982
983   return begin;
984 }
985 #endif /*HAVE_STRSEP*/
986
987
988 #ifndef HAVE_STRLWR
989 char *
990 strlwr(char *s)
991 {
992     char *p;
993     for(p=s; *p; p++ )
994         *p = tolower(*p);
995     return s;
996 }
997 #endif
998
999
1000 #ifndef HAVE_STRCASECMP
1001 int
1002 strcasecmp( const char *a, const char *b )
1003 {
1004     for( ; *a && *b; a++, b++ ) {
1005         if( *a != *b && toupper(*a) != toupper(*b) )
1006             break;
1007     }
1008     return *(const byte*)a - *(const byte*)b;
1009 }
1010 #endif
1011
1012
1013 /****************
1014  * mingw32/cpd has a memicmp()
1015  */
1016 #ifndef HAVE_MEMICMP
1017 int
1018 memicmp( const char *a, const char *b, size_t n )
1019 {
1020     for( ; n; n--, a++, b++ )
1021         if( *a != *b  && toupper(*(const byte*)a) != toupper(*(const byte*)b) )
1022             return *(const byte *)a - *(const byte*)b;
1023     return 0;
1024 }
1025 #endif
1026
1027
1028 #ifndef HAVE_MEMRCHR
1029 void *
1030 memrchr (const void *buffer, int c, size_t n)
1031 {
1032   const unsigned char *p = buffer;
1033
1034   for (p += n; n ; n--)
1035     if (*--p == c)
1036       return (void *)p;
1037   return NULL;
1038 }
1039 #endif /*HAVE_MEMRCHR*/
1040
1041 \f
1042 /* Percent-escape the string STR by replacing colons with '%3a'.  If
1043    EXTRA is not NULL all characters in EXTRA are also escaped.  */
1044 static char *
1045 do_percent_escape (const char *str, const char *extra, int die)
1046 {
1047   int i, j;
1048   char *ptr;
1049
1050   if (!str)
1051     return NULL;
1052
1053   for (i=j=0; str[i]; i++)
1054     if (str[i] == ':' || str[i] == '%' || (extra && strchr (extra, str[i])))
1055       j++;
1056   if (die)
1057     ptr = xmalloc (i + 2 * j + 1);
1058   else
1059     {
1060       ptr = xtrymalloc (i + 2 * j + 1);
1061       if (!ptr)
1062         return NULL;
1063     }
1064   i = 0;
1065   while (*str)
1066     {
1067       if (*str == ':')
1068         {
1069           ptr[i++] = '%';
1070           ptr[i++] = '3';
1071           ptr[i++] = 'a';
1072         }
1073       else if (*str == '%')
1074         {
1075           ptr[i++] = '%';
1076           ptr[i++] = '2';
1077           ptr[i++] = '5';
1078         }
1079       else if (extra && strchr (extra, *str))
1080         {
1081           ptr[i++] = '%';
1082           ptr[i++] = tohex_lower ((*str>>4)&15);
1083           ptr[i++] = tohex_lower (*str&15);
1084         }
1085       else
1086         ptr[i++] = *str;
1087       str++;
1088     }
1089   ptr[i] = '\0';
1090
1091   return ptr;
1092 }
1093
1094 /* Percent-escape the string STR by replacing colons with '%3a'.  If
1095    EXTRA is not NULL all characters in EXTRA are also escaped.  This
1096    function terminates the process on memory shortage.  */
1097 char *
1098 percent_escape (const char *str, const char *extra)
1099 {
1100   return do_percent_escape (str, extra, 1);
1101 }
1102
1103 /* Same as percent_escape but return NULL instead of exiting on memory
1104    error. */
1105 char *
1106 try_percent_escape (const char *str, const char *extra)
1107 {
1108   return do_percent_escape (str, extra, 0);
1109 }
1110
1111
1112
1113 static char *
1114 do_strconcat (const char *s1, va_list arg_ptr)
1115 {
1116   const char *argv[48];
1117   size_t argc;
1118   size_t needed;
1119   char *buffer, *p;
1120
1121   argc = 0;
1122   argv[argc++] = s1;
1123   needed = strlen (s1);
1124   while (((argv[argc] = va_arg (arg_ptr, const char *))))
1125     {
1126       needed += strlen (argv[argc]);
1127       if (argc >= DIM (argv)-1)
1128         {
1129           gpg_err_set_errno (EINVAL);
1130           return NULL;
1131         }
1132       argc++;
1133     }
1134   needed++;
1135   buffer = xtrymalloc (needed);
1136   if (buffer)
1137     {
1138       for (p = buffer, argc=0; argv[argc]; argc++)
1139         p = stpcpy (p, argv[argc]);
1140     }
1141   return buffer;
1142 }
1143
1144
1145 /* Concatenate the string S1 with all the following strings up to a
1146    NULL.  Returns a malloced buffer with the new string or NULL on a
1147    malloc error or if too many arguments are given.  */
1148 char *
1149 strconcat (const char *s1, ...)
1150 {
1151   va_list arg_ptr;
1152   char *result;
1153
1154   if (!s1)
1155     result = xtrystrdup ("");
1156   else
1157     {
1158       va_start (arg_ptr, s1);
1159       result = do_strconcat (s1, arg_ptr);
1160       va_end (arg_ptr);
1161     }
1162   return result;
1163 }
1164
1165 /* Same as strconcat but terminate the process with an error message
1166    if something goes wrong.  */
1167 char *
1168 xstrconcat (const char *s1, ...)
1169 {
1170   va_list arg_ptr;
1171   char *result;
1172
1173   if (!s1)
1174     result = xstrdup ("");
1175   else
1176     {
1177       va_start (arg_ptr, s1);
1178       result = do_strconcat (s1, arg_ptr);
1179       va_end (arg_ptr);
1180     }
1181   if (!result)
1182     {
1183       if (errno == EINVAL)
1184         fputs ("\nfatal: too many args for xstrconcat\n", stderr);
1185       else
1186         fputs ("\nfatal: out of memory\n", stderr);
1187       exit (2);
1188     }
1189   return result;
1190 }
1191
1192 /* Split a string into fields at DELIM.  REPLACEMENT is the character
1193    to replace the delimiter with (normally: '\0' so that each field is
1194    NUL terminated).  The caller is responsible for freeing the result.
1195    Note: this function modifies STRING!  If you need the original
1196    value, then you should pass a copy to this function.
1197
1198    If malloc fails, this function returns NULL.  */
1199 char **
1200 strsplit (char *string, char delim, char replacement, int *count)
1201 {
1202   int fields = 1;
1203   char *t;
1204   char **result;
1205
1206   /* First, count the number of fields.  */
1207   for (t = strchr (string, delim); t; t = strchr (t + 1, delim))
1208     fields ++;
1209
1210   result = xtrycalloc ((fields + 1), sizeof (*result));
1211   if (! result)
1212     return NULL;
1213
1214   result[0] = string;
1215   fields = 1;
1216   for (t = strchr (string, delim); t; t = strchr (t + 1, delim))
1217     {
1218       result[fields ++] = t + 1;
1219       *t = replacement;
1220     }
1221
1222   if (count)
1223     *count = fields;
1224
1225   return result;
1226 }
1227
1228
1229 /* Tokenize STRING using the set of delimiters in DELIM.  Leading
1230  * spaces and tabs are removed from all tokens.  The caller must xfree
1231  * the result.
1232  *
1233  * Returns: A malloced and NULL delimited array with the tokens.  On
1234  *          memory error NULL is returned and ERRNO is set.
1235  */
1236 char **
1237 strtokenize (const char *string, const char *delim)
1238 {
1239   const char *s;
1240   size_t fields;
1241   size_t bytes, n;
1242   char *buffer;
1243   char *p, *px, *pend;
1244   char **result;
1245
1246   /* Count the number of fields.  */
1247   for (fields = 1, s = strpbrk (string, delim); s; s = strpbrk (s + 1, delim))
1248     fields++;
1249   fields++; /* Add one for the terminating NULL.  */
1250
1251   /* Allocate an array for all fields, a terminating NULL, and space
1252      for a copy of the string.  */
1253   bytes = fields * sizeof *result;
1254   if (bytes / sizeof *result != fields)
1255     {
1256       gpg_err_set_errno (ENOMEM);
1257       return NULL;
1258     }
1259   n = strlen (string) + 1;
1260   bytes += n;
1261   if (bytes < n)
1262     {
1263       gpg_err_set_errno (ENOMEM);
1264       return NULL;
1265     }
1266   result = xtrymalloc (bytes);
1267   if (!result)
1268     return NULL;
1269   buffer = (char*)(result + fields);
1270
1271   /* Copy and parse the string.  */
1272   strcpy (buffer, string);
1273   for (n = 0, p = buffer; (pend = strpbrk (p, delim)); p = pend + 1)
1274     {
1275       *pend = 0;
1276       while (spacep (p))
1277         p++;
1278       for (px = pend - 1; px >= p && spacep (px); px--)
1279         *px = 0;
1280       result[n++] = p;
1281     }
1282   while (spacep (p))
1283     p++;
1284   for (px = p + strlen (p) - 1; px >= p && spacep (px); px--)
1285     *px = 0;
1286   result[n++] = p;
1287   result[n] = NULL;
1288
1289   assert ((char*)(result + n + 1) == buffer);
1290
1291   return result;
1292 }
1293
1294
1295 /* Split a string into space delimited fields and remove leading and
1296  * trailing spaces from each field.  A pointer to each field is stored
1297  * in ARRAY.  Stop splitting at ARRAYSIZE fields.  The function
1298  * modifies STRING.  The number of parsed fields is returned.
1299  * Example:
1300  *
1301  *   char *fields[2];
1302  *   if (split_fields (string, fields, DIM (fields)) < 2)
1303  *     return  // Not enough args.
1304  *   foo (fields[0]);
1305  *   foo (fields[1]);
1306  */
1307 int
1308 split_fields (char *string, char **array, int arraysize)
1309 {
1310   int n = 0;
1311   char *p, *pend;
1312
1313   for (p = string; *p == ' '; p++)
1314     ;
1315   do
1316     {
1317       if (n == arraysize)
1318         break;
1319       array[n++] = p;
1320       pend = strchr (p, ' ');
1321       if (!pend)
1322         break;
1323       *pend++ = 0;
1324       for (p = pend; *p == ' '; p++)
1325         ;
1326     }
1327   while (*p);
1328
1329   return n;
1330 }
1331
1332
1333 \f
1334 /* Version number parsing.  */
1335
1336 /* This function parses the first portion of the version number S and
1337    stores it in *NUMBER.  On success, this function returns a pointer
1338    into S starting with the first character, which is not part of the
1339    initial number portion; on failure, NULL is returned.  */
1340 static const char*
1341 parse_version_number (const char *s, int *number)
1342 {
1343   int val = 0;
1344
1345   if (*s == '0' && digitp (s+1))
1346     return NULL;  /* Leading zeros are not allowed.  */
1347   for (; digitp (s); s++)
1348     {
1349       val *= 10;
1350       val += *s - '0';
1351     }
1352   *number = val;
1353   return val < 0 ? NULL : s;
1354 }
1355
1356
1357 /* This function breaks up the complete string-representation of the
1358    version number S, which is of the following struture: <major
1359    number>.<minor number>.<micro number><patch level>.  The major,
1360    minor and micro number components will be stored in *MAJOR, *MINOR
1361    and *MICRO.
1362
1363    On success, the last component, the patch level, will be returned;
1364    in failure, NULL will be returned.  */
1365 static const char *
1366 parse_version_string (const char *s, int *major, int *minor, int *micro)
1367 {
1368   s = parse_version_number (s, major);
1369   if (!s || *s != '.')
1370     return NULL;
1371   s++;
1372   s = parse_version_number (s, minor);
1373   if (!s)
1374     return NULL;
1375   if (*s == '.')
1376     {
1377       s++;
1378       s = parse_version_number (s, micro);
1379       if (!s)
1380         return NULL;
1381     }
1382   else
1383     *micro = 0;
1384   return s;  /* Patchlevel.  */
1385 }
1386
1387
1388 /* Check that the version string MY_VERSION is greater or equal than
1389    REQ_VERSION.  Returns true if the condition is satisfied or false
1390    if not.  This works with 3 part and two part version strings; for a
1391    two part version string the micor part is assumed to be 0.  */
1392 int
1393 compare_version_strings (const char *my_version, const char *req_version)
1394 {
1395   int my_major, my_minor, my_micro;
1396   int rq_major, rq_minor, rq_micro;
1397
1398   if (!my_version || !req_version)
1399     return 0;
1400
1401   if (!parse_version_string (my_version, &my_major, &my_minor, &my_micro))
1402     return 0;
1403   if (!parse_version_string(req_version, &rq_major, &rq_minor, &rq_micro))
1404     return 0;
1405
1406   if (my_major > rq_major
1407       || (my_major == rq_major && my_minor > rq_minor)
1408       || (my_major == rq_major && my_minor == rq_minor
1409           && my_micro >= rq_micro))
1410     {
1411       return 1;
1412     }
1413   return 0;
1414 }
1415
1416
1417 \f
1418 /* Format a string so that it fits within about TARGET_COLS columns.
1419    If IN_PLACE is 0, then TEXT is copied to a new buffer, which is
1420    returned.  Otherwise, TEXT is modified in place and returned.
1421    Normally, target_cols will be 72 and max_cols is 80.  */
1422 char *
1423 format_text (char *text, int in_place, int target_cols, int max_cols)
1424 {
1425   const int do_debug = 0;
1426
1427   /* The character under consideration.  */
1428   char *p;
1429   /* The start of the current line.  */
1430   char *line;
1431   /* The last space that we saw.  */
1432   char *last_space = NULL;
1433   int last_space_cols = 0;
1434   int copied_last_space = 0;
1435
1436   if (! in_place)
1437     text = xstrdup (text);
1438
1439   p = line = text;
1440   while (1)
1441     {
1442       /* The number of columns including any trailing space.  */
1443       int cols;
1444
1445       p = p + strcspn (p, "\n ");
1446       if (! p)
1447         /* P now points to the NUL character.  */
1448         p = &text[strlen (text)];
1449
1450       if (*p == '\n')
1451         /* Pass through any newlines.  */
1452         {
1453           p ++;
1454           line = p;
1455           last_space = NULL;
1456           last_space_cols = 0;
1457           copied_last_space = 1;
1458           continue;
1459         }
1460
1461       /* Have a space or a NUL.  Note: we don't count the trailing
1462          space.  */
1463       cols = utf8_charcount (line, (uintptr_t) p - (uintptr_t) line);
1464       if (cols < target_cols)
1465         {
1466           if (! *p)
1467             /* Nothing left to break.  */
1468             break;
1469
1470           last_space = p;
1471           last_space_cols = cols;
1472           p ++;
1473           /* Skip any immediately following spaces.  If we break:
1474              "... foo bar ..." between "foo" and "bar" then we want:
1475              "... foo\nbar ...", which means that the left space has
1476              to be the first space after foo, not the last space
1477              before bar.  */
1478           while (*p == ' ')
1479             p ++;
1480         }
1481       else
1482         {
1483           int cols_with_left_space;
1484           int cols_with_right_space;
1485           int left_penalty;
1486           int right_penalty;
1487
1488           cols_with_left_space = last_space_cols;
1489           cols_with_right_space = cols;
1490
1491           if (do_debug)
1492             log_debug ("Breaking: '%.*s'\n",
1493                        (int) ((uintptr_t) p - (uintptr_t) line), line);
1494
1495           /* The number of columns away from TARGET_COLS.  We prefer
1496              to underflow than to overflow.  */
1497           left_penalty = target_cols - cols_with_left_space;
1498           right_penalty = 2 * (cols_with_right_space - target_cols);
1499
1500           if (cols_with_right_space > max_cols)
1501             /* Add a large penalty for each column that exceeds
1502                max_cols.  */
1503             right_penalty += 4 * (cols_with_right_space - max_cols);
1504
1505           if (do_debug)
1506             log_debug ("Left space => %d cols (penalty: %d); right space => %d cols (penalty: %d)\n",
1507                        cols_with_left_space, left_penalty,
1508                        cols_with_right_space, right_penalty);
1509           if (last_space_cols && left_penalty <= right_penalty)
1510             /* Prefer the left space.  */
1511             {
1512               if (do_debug)
1513                 log_debug ("Breaking at left space.\n");
1514               p = last_space;
1515             }
1516           else
1517             {
1518               if (do_debug)
1519                 log_debug ("Breaking at right space.\n");
1520             }
1521
1522           if (! *p)
1523             break;
1524
1525           *p = '\n';
1526           p ++;
1527           if (*p == ' ')
1528             {
1529               int spaces;
1530               for (spaces = 1; p[spaces] == ' '; spaces ++)
1531                 ;
1532               memmove (p, &p[spaces], strlen (&p[spaces]) + 1);
1533             }
1534           line = p;
1535           last_space = NULL;
1536           last_space_cols = 0;
1537           copied_last_space = 0;
1538         }
1539     }
1540
1541   /* Chop off any trailing space.  */
1542   trim_trailing_chars (text, strlen (text), " ");
1543   /* If we inserted the trailing newline, then remove it.  */
1544   if (! copied_last_space && *text && text[strlen (text) - 1] == '\n')
1545     text[strlen (text) - 1] = '\0';
1546
1547   return text;
1548 }