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