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