Merge branch 'master' into STABLE-BRANCH-2-2
[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
691 /* Create a string from the buffer P_ARG of length N which is suitable
692    for printing.  Caller must release the created string using xfree.
693    This function terminates the process on memory shortage.  */
694 char *
695 sanitize_buffer (const void *p_arg, size_t n, int delim)
696 {
697   const unsigned char *p = p_arg;
698   size_t save_n, buflen;
699   const unsigned char *save_p;
700   char *buffer, *d;
701
702   /* First count length. */
703   for (save_n = n, save_p = p, buflen=1 ; n; n--, p++ )
704     {
705       if ( *p < 0x20 || *p == 0x7f || *p == delim  || (delim && *p=='\\'))
706         {
707           if ( *p=='\n' || *p=='\r' || *p=='\f'
708                || *p=='\v' || *p=='\b' || !*p )
709             buflen += 2;
710           else
711             buflen += 5;
712         }
713       else
714         buflen++;
715     }
716   p = save_p;
717   n = save_n;
718   /* And now make the string */
719   d = buffer = xmalloc( buflen );
720   for ( ; n; n--, p++ )
721     {
722       if (*p < 0x20 || *p == 0x7f || *p == delim || (delim && *p=='\\')) {
723         *d++ = '\\';
724         if( *p == '\n' )
725           *d++ = 'n';
726         else if( *p == '\r' )
727           *d++ = 'r';
728         else if( *p == '\f' )
729           *d++ = 'f';
730         else if( *p == '\v' )
731           *d++ = 'v';
732         else if( *p == '\b' )
733           *d++ = 'b';
734         else if( !*p )
735           *d++ = '0';
736         else {
737           sprintf(d, "x%02x", *p );
738           d += 3;
739         }
740       }
741       else
742         *d++ = *p;
743     }
744   *d = 0;
745   return buffer;
746 }
747
748
749 /* Given a string containing an UTF-8 encoded text, return the number
750    of characters in this string.  It differs from strlen in that it
751    only counts complete UTF-8 characters.  SIZE is the maximum length
752    of the string in bytes.  If SIZE is -1, then a NUL character is
753    taken to be the end of the string.  Note, that this function does
754    not take combined characters into account.  */
755 size_t
756 utf8_charcount (const char *s, int len)
757 {
758   size_t n;
759
760   if (len == 0)
761     return 0;
762
763   for (n=0; *s; s++)
764     {
765       if ( (*s&0xc0) != 0x80 ) /* Exclude continuation bytes: 10xxxxxx */
766         n++;
767
768       if (len != -1)
769         {
770           len --;
771           if (len == 0)
772             break;
773         }
774     }
775
776   return n;
777 }
778
779
780 /****************************************************
781  **********  W32 specific functions  ****************
782  ****************************************************/
783
784 #ifdef HAVE_W32_SYSTEM
785 const char *
786 w32_strerror (int ec)
787 {
788   static char strerr[256];
789
790   if (ec == -1)
791     ec = (int)GetLastError ();
792 #ifdef HAVE_W32CE_SYSTEM
793   /* There is only a wchar_t FormatMessage.  It does not make much
794      sense to play the conversion game; we print only the code.  */
795   snprintf (strerr, sizeof strerr, "ec=%d", (int)GetLastError ());
796 #else
797   FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, NULL, ec,
798                  MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
799                  strerr, DIM (strerr)-1, NULL);
800 #endif
801   return strerr;
802 }
803 #endif /*HAVE_W32_SYSTEM*/
804
805
806 /****************************************************
807  ******** Locale insensitive ctype functions ********
808  ****************************************************/
809 /* FIXME: replace them by a table lookup and macros */
810 int
811 ascii_isupper (int c)
812 {
813     return c >= 'A' && c <= 'Z';
814 }
815
816 int
817 ascii_islower (int c)
818 {
819     return c >= 'a' && c <= 'z';
820 }
821
822 int
823 ascii_toupper (int c)
824 {
825     if (c >= 'a' && c <= 'z')
826         c &= ~0x20;
827     return c;
828 }
829
830 int
831 ascii_tolower (int c)
832 {
833     if (c >= 'A' && c <= 'Z')
834         c |= 0x20;
835     return c;
836 }
837
838 /* Lowercase all ASCII characters in S.  */
839 char *
840 ascii_strlwr (char *s)
841 {
842   char *p = s;
843
844   for (p=s; *p; p++ )
845     if (isascii (*p) && *p >= 'A' && *p <= 'Z')
846       *p |= 0x20;
847
848   return s;
849 }
850
851 int
852 ascii_strcasecmp( const char *a, const char *b )
853 {
854     if (a == b)
855         return 0;
856
857     for (; *a && *b; a++, b++) {
858         if (*a != *b && ascii_toupper(*a) != ascii_toupper(*b))
859             break;
860     }
861     return *a == *b? 0 : (ascii_toupper (*a) - ascii_toupper (*b));
862 }
863
864 int
865 ascii_strncasecmp (const char *a, const char *b, size_t n)
866 {
867   const unsigned char *p1 = (const unsigned char *)a;
868   const unsigned char *p2 = (const unsigned char *)b;
869   unsigned char c1, c2;
870
871   if (p1 == p2 || !n )
872     return 0;
873
874   do
875     {
876       c1 = ascii_tolower (*p1);
877       c2 = ascii_tolower (*p2);
878
879       if ( !--n || c1 == '\0')
880         break;
881
882       ++p1;
883       ++p2;
884     }
885   while (c1 == c2);
886
887   return c1 - c2;
888 }
889
890
891 int
892 ascii_memcasecmp (const void *a_arg, const void *b_arg, size_t n )
893 {
894   const char *a = a_arg;
895   const char *b = b_arg;
896
897   if (a == b)
898     return 0;
899   for ( ; n; n--, a++, b++ )
900     {
901       if( *a != *b  && ascii_toupper (*a) != ascii_toupper (*b) )
902         return *a == *b? 0 : (ascii_toupper (*a) - ascii_toupper (*b));
903     }
904   return 0;
905 }
906
907 int
908 ascii_strcmp( const char *a, const char *b )
909 {
910     if (a == b)
911         return 0;
912
913     for (; *a && *b; a++, b++) {
914         if (*a != *b )
915             break;
916     }
917     return *a == *b? 0 : (*(signed char *)a - *(signed char *)b);
918 }
919
920
921 void *
922 ascii_memcasemem (const void *haystack, size_t nhaystack,
923                   const void *needle, size_t nneedle)
924 {
925
926   if (!nneedle)
927     return (void*)haystack; /* finding an empty needle is really easy */
928   if (nneedle <= nhaystack)
929     {
930       const char *a = haystack;
931       const char *b = a + nhaystack - nneedle;
932
933       for (; a <= b; a++)
934         {
935           if ( !ascii_memcasecmp (a, needle, nneedle) )
936             return (void *)a;
937         }
938     }
939   return NULL;
940 }
941
942 /*********************************************
943  ********** missing string functions *********
944  *********************************************/
945
946 #ifndef HAVE_STPCPY
947 char *
948 stpcpy(char *a,const char *b)
949 {
950     while( *b )
951         *a++ = *b++;
952     *a = 0;
953
954     return (char*)a;
955 }
956 #endif
957
958 #ifndef HAVE_STRPBRK
959 /* Find the first occurrence in S of any character in ACCEPT.
960    Code taken from glibc-2.6/string/strpbrk.c (LGPLv2.1+) and modified. */
961 char *
962 strpbrk (const char *s, const char *accept)
963 {
964   while (*s != '\0')
965     {
966       const char *a = accept;
967       while (*a != '\0')
968         if (*a++ == *s)
969           return (char *) s;
970       ++s;
971     }
972
973   return NULL;
974 }
975 #endif /*!HAVE_STRPBRK*/
976
977
978 #ifndef HAVE_STRSEP
979 /* Code taken from glibc-2.2.1/sysdeps/generic/strsep.c. */
980 char *
981 strsep (char **stringp, const char *delim)
982 {
983   char *begin, *end;
984
985   begin = *stringp;
986   if (begin == NULL)
987     return NULL;
988
989   /* A frequent case is when the delimiter string contains only one
990      character.  Here we don't need to call the expensive 'strpbrk'
991      function and instead work using 'strchr'.  */
992   if (delim[0] == '\0' || delim[1] == '\0')
993     {
994       char ch = delim[0];
995
996       if (ch == '\0')
997         end = NULL;
998       else
999         {
1000           if (*begin == ch)
1001             end = begin;
1002           else if (*begin == '\0')
1003             end = NULL;
1004           else
1005             end = strchr (begin + 1, ch);
1006         }
1007     }
1008   else
1009     /* Find the end of the token.  */
1010     end = strpbrk (begin, delim);
1011
1012   if (end)
1013     {
1014       /* Terminate the token and set *STRINGP past NUL character.  */
1015       *end++ = '\0';
1016       *stringp = end;
1017     }
1018   else
1019     /* No more delimiters; this is the last token.  */
1020     *stringp = NULL;
1021
1022   return begin;
1023 }
1024 #endif /*HAVE_STRSEP*/
1025
1026
1027 #ifndef HAVE_STRLWR
1028 char *
1029 strlwr(char *s)
1030 {
1031     char *p;
1032     for(p=s; *p; p++ )
1033         *p = tolower(*p);
1034     return s;
1035 }
1036 #endif
1037
1038
1039 #ifndef HAVE_STRCASECMP
1040 int
1041 strcasecmp( const char *a, const char *b )
1042 {
1043     for( ; *a && *b; a++, b++ ) {
1044         if( *a != *b && toupper(*a) != toupper(*b) )
1045             break;
1046     }
1047     return *(const byte*)a - *(const byte*)b;
1048 }
1049 #endif
1050
1051
1052 /****************
1053  * mingw32/cpd has a memicmp()
1054  */
1055 #ifndef HAVE_MEMICMP
1056 int
1057 memicmp( const char *a, const char *b, size_t n )
1058 {
1059     for( ; n; n--, a++, b++ )
1060         if( *a != *b  && toupper(*(const byte*)a) != toupper(*(const byte*)b) )
1061             return *(const byte *)a - *(const byte*)b;
1062     return 0;
1063 }
1064 #endif
1065
1066
1067 #ifndef HAVE_MEMRCHR
1068 void *
1069 memrchr (const void *buffer, int c, size_t n)
1070 {
1071   const unsigned char *p = buffer;
1072
1073   for (p += n; n ; n--)
1074     if (*--p == c)
1075       return (void *)p;
1076   return NULL;
1077 }
1078 #endif /*HAVE_MEMRCHR*/
1079
1080 \f
1081 /* Percent-escape the string STR by replacing colons with '%3a'.  If
1082    EXTRA is not NULL all characters in EXTRA are also escaped.  */
1083 static char *
1084 do_percent_escape (const char *str, const char *extra, int die)
1085 {
1086   int i, j;
1087   char *ptr;
1088
1089   if (!str)
1090     return NULL;
1091
1092   for (i=j=0; str[i]; i++)
1093     if (str[i] == ':' || str[i] == '%' || (extra && strchr (extra, str[i])))
1094       j++;
1095   if (die)
1096     ptr = xmalloc (i + 2 * j + 1);
1097   else
1098     {
1099       ptr = xtrymalloc (i + 2 * j + 1);
1100       if (!ptr)
1101         return NULL;
1102     }
1103   i = 0;
1104   while (*str)
1105     {
1106       if (*str == ':')
1107         {
1108           ptr[i++] = '%';
1109           ptr[i++] = '3';
1110           ptr[i++] = 'a';
1111         }
1112       else if (*str == '%')
1113         {
1114           ptr[i++] = '%';
1115           ptr[i++] = '2';
1116           ptr[i++] = '5';
1117         }
1118       else if (extra && strchr (extra, *str))
1119         {
1120           ptr[i++] = '%';
1121           ptr[i++] = tohex_lower ((*str>>4)&15);
1122           ptr[i++] = tohex_lower (*str&15);
1123         }
1124       else
1125         ptr[i++] = *str;
1126       str++;
1127     }
1128   ptr[i] = '\0';
1129
1130   return ptr;
1131 }
1132
1133 /* Percent-escape the string STR by replacing colons with '%3a'.  If
1134    EXTRA is not NULL all characters in EXTRA are also escaped.  This
1135    function terminates the process on memory shortage.  */
1136 char *
1137 percent_escape (const char *str, const char *extra)
1138 {
1139   return do_percent_escape (str, extra, 1);
1140 }
1141
1142 /* Same as percent_escape but return NULL instead of exiting on memory
1143    error. */
1144 char *
1145 try_percent_escape (const char *str, const char *extra)
1146 {
1147   return do_percent_escape (str, extra, 0);
1148 }
1149
1150
1151
1152 static char *
1153 do_strconcat (const char *s1, va_list arg_ptr)
1154 {
1155   const char *argv[48];
1156   size_t argc;
1157   size_t needed;
1158   char *buffer, *p;
1159
1160   argc = 0;
1161   argv[argc++] = s1;
1162   needed = strlen (s1);
1163   while (((argv[argc] = va_arg (arg_ptr, const char *))))
1164     {
1165       needed += strlen (argv[argc]);
1166       if (argc >= DIM (argv)-1)
1167         {
1168           gpg_err_set_errno (EINVAL);
1169           return NULL;
1170         }
1171       argc++;
1172     }
1173   needed++;
1174   buffer = xtrymalloc (needed);
1175   if (buffer)
1176     {
1177       for (p = buffer, argc=0; argv[argc]; argc++)
1178         p = stpcpy (p, argv[argc]);
1179     }
1180   return buffer;
1181 }
1182
1183
1184 /* Concatenate the string S1 with all the following strings up to a
1185    NULL.  Returns a malloced buffer with the new string or NULL on a
1186    malloc error or if too many arguments are given.  */
1187 char *
1188 strconcat (const char *s1, ...)
1189 {
1190   va_list arg_ptr;
1191   char *result;
1192
1193   if (!s1)
1194     result = xtrystrdup ("");
1195   else
1196     {
1197       va_start (arg_ptr, s1);
1198       result = do_strconcat (s1, arg_ptr);
1199       va_end (arg_ptr);
1200     }
1201   return result;
1202 }
1203
1204 /* Same as strconcat but terminate the process with an error message
1205    if something goes wrong.  */
1206 char *
1207 xstrconcat (const char *s1, ...)
1208 {
1209   va_list arg_ptr;
1210   char *result;
1211
1212   if (!s1)
1213     result = xstrdup ("");
1214   else
1215     {
1216       va_start (arg_ptr, s1);
1217       result = do_strconcat (s1, arg_ptr);
1218       va_end (arg_ptr);
1219     }
1220   if (!result)
1221     {
1222       if (errno == EINVAL)
1223         fputs ("\nfatal: too many args for xstrconcat\n", stderr);
1224       else
1225         fputs ("\nfatal: out of memory\n", stderr);
1226       exit (2);
1227     }
1228   return result;
1229 }
1230
1231 /* Split a string into fields at DELIM.  REPLACEMENT is the character
1232    to replace the delimiter with (normally: '\0' so that each field is
1233    NUL terminated).  The caller is responsible for freeing the result.
1234    Note: this function modifies STRING!  If you need the original
1235    value, then you should pass a copy to this function.
1236
1237    If malloc fails, this function returns NULL.  */
1238 char **
1239 strsplit (char *string, char delim, char replacement, int *count)
1240 {
1241   int fields = 1;
1242   char *t;
1243   char **result;
1244
1245   /* First, count the number of fields.  */
1246   for (t = strchr (string, delim); t; t = strchr (t + 1, delim))
1247     fields ++;
1248
1249   result = xtrycalloc ((fields + 1), sizeof (*result));
1250   if (! result)
1251     return NULL;
1252
1253   result[0] = string;
1254   fields = 1;
1255   for (t = strchr (string, delim); t; t = strchr (t + 1, delim))
1256     {
1257       result[fields ++] = t + 1;
1258       *t = replacement;
1259     }
1260
1261   if (count)
1262     *count = fields;
1263
1264   return result;
1265 }
1266
1267
1268 /* Tokenize STRING using the set of delimiters in DELIM.  Leading
1269  * spaces and tabs are removed from all tokens.  The caller must xfree
1270  * the result.
1271  *
1272  * Returns: A malloced and NULL delimited array with the tokens.  On
1273  *          memory error NULL is returned and ERRNO is set.
1274  */
1275 char **
1276 strtokenize (const char *string, const char *delim)
1277 {
1278   const char *s;
1279   size_t fields;
1280   size_t bytes, n;
1281   char *buffer;
1282   char *p, *px, *pend;
1283   char **result;
1284
1285   /* Count the number of fields.  */
1286   for (fields = 1, s = strpbrk (string, delim); s; s = strpbrk (s + 1, delim))
1287     fields++;
1288   fields++; /* Add one for the terminating NULL.  */
1289
1290   /* Allocate an array for all fields, a terminating NULL, and space
1291      for a copy of the string.  */
1292   bytes = fields * sizeof *result;
1293   if (bytes / sizeof *result != fields)
1294     {
1295       gpg_err_set_errno (ENOMEM);
1296       return NULL;
1297     }
1298   n = strlen (string) + 1;
1299   bytes += n;
1300   if (bytes < n)
1301     {
1302       gpg_err_set_errno (ENOMEM);
1303       return NULL;
1304     }
1305   result = xtrymalloc (bytes);
1306   if (!result)
1307     return NULL;
1308   buffer = (char*)(result + fields);
1309
1310   /* Copy and parse the string.  */
1311   strcpy (buffer, string);
1312   for (n = 0, p = buffer; (pend = strpbrk (p, delim)); p = pend + 1)
1313     {
1314       *pend = 0;
1315       while (spacep (p))
1316         p++;
1317       for (px = pend - 1; px >= p && spacep (px); px--)
1318         *px = 0;
1319       result[n++] = p;
1320     }
1321   while (spacep (p))
1322     p++;
1323   for (px = p + strlen (p) - 1; px >= p && spacep (px); px--)
1324     *px = 0;
1325   result[n++] = p;
1326   result[n] = NULL;
1327
1328   assert ((char*)(result + n + 1) == buffer);
1329
1330   return result;
1331 }
1332
1333
1334 /* Split a string into space delimited fields and remove leading and
1335  * trailing spaces from each field.  A pointer to each field is stored
1336  * in ARRAY.  Stop splitting at ARRAYSIZE fields.  The function
1337  * modifies STRING.  The number of parsed fields is returned.
1338  * Example:
1339  *
1340  *   char *fields[2];
1341  *   if (split_fields (string, fields, DIM (fields)) < 2)
1342  *     return  // Not enough args.
1343  *   foo (fields[0]);
1344  *   foo (fields[1]);
1345  */
1346 int
1347 split_fields (char *string, char **array, int arraysize)
1348 {
1349   int n = 0;
1350   char *p, *pend;
1351
1352   for (p = string; *p == ' '; p++)
1353     ;
1354   do
1355     {
1356       if (n == arraysize)
1357         break;
1358       array[n++] = p;
1359       pend = strchr (p, ' ');
1360       if (!pend)
1361         break;
1362       *pend++ = 0;
1363       for (p = pend; *p == ' '; p++)
1364         ;
1365     }
1366   while (*p);
1367
1368   return n;
1369 }
1370
1371
1372 \f
1373 /* Version number parsing.  */
1374
1375 /* This function parses the first portion of the version number S and
1376    stores it in *NUMBER.  On success, this function returns a pointer
1377    into S starting with the first character, which is not part of the
1378    initial number portion; on failure, NULL is returned.  */
1379 static const char*
1380 parse_version_number (const char *s, int *number)
1381 {
1382   int val = 0;
1383
1384   if (*s == '0' && digitp (s+1))
1385     return NULL;  /* Leading zeros are not allowed.  */
1386   for (; digitp (s); s++)
1387     {
1388       val *= 10;
1389       val += *s - '0';
1390     }
1391   *number = val;
1392   return val < 0 ? NULL : s;
1393 }
1394
1395
1396 /* This function breaks up the complete string-representation of the
1397    version number S, which is of the following struture: <major
1398    number>.<minor number>.<micro number><patch level>.  The major,
1399    minor and micro number components will be stored in *MAJOR, *MINOR
1400    and *MICRO.
1401
1402    On success, the last component, the patch level, will be returned;
1403    in failure, NULL will be returned.  */
1404 static const char *
1405 parse_version_string (const char *s, int *major, int *minor, int *micro)
1406 {
1407   s = parse_version_number (s, major);
1408   if (!s || *s != '.')
1409     return NULL;
1410   s++;
1411   s = parse_version_number (s, minor);
1412   if (!s)
1413     return NULL;
1414   if (*s == '.')
1415     {
1416       s++;
1417       s = parse_version_number (s, micro);
1418       if (!s)
1419         return NULL;
1420     }
1421   else
1422     *micro = 0;
1423   return s;  /* Patchlevel.  */
1424 }
1425
1426
1427 /* Check that the version string MY_VERSION is greater or equal than
1428    REQ_VERSION.  Returns true if the condition is satisfied or false
1429    if not.  This works with 3 part and two part version strings; for a
1430    two part version string the micor part is assumed to be 0.  */
1431 int
1432 compare_version_strings (const char *my_version, const char *req_version)
1433 {
1434   int my_major, my_minor, my_micro;
1435   int rq_major, rq_minor, rq_micro;
1436
1437   if (!my_version || !req_version)
1438     return 0;
1439
1440   if (!parse_version_string (my_version, &my_major, &my_minor, &my_micro))
1441     return 0;
1442   if (!parse_version_string(req_version, &rq_major, &rq_minor, &rq_micro))
1443     return 0;
1444
1445   if (my_major > rq_major
1446       || (my_major == rq_major && my_minor > rq_minor)
1447       || (my_major == rq_major && my_minor == rq_minor
1448           && my_micro >= rq_micro))
1449     {
1450       return 1;
1451     }
1452   return 0;
1453 }
1454
1455
1456 \f
1457 /* Format a string so that it fits within about TARGET_COLS columns.
1458    If IN_PLACE is 0, then TEXT is copied to a new buffer, which is
1459    returned.  Otherwise, TEXT is modified in place and returned.
1460    Normally, target_cols will be 72 and max_cols is 80.  */
1461 char *
1462 format_text (char *text, int in_place, int target_cols, int max_cols)
1463 {
1464   const int do_debug = 0;
1465
1466   /* The character under consideration.  */
1467   char *p;
1468   /* The start of the current line.  */
1469   char *line;
1470   /* The last space that we saw.  */
1471   char *last_space = NULL;
1472   int last_space_cols = 0;
1473   int copied_last_space = 0;
1474
1475   if (! in_place)
1476     text = xstrdup (text);
1477
1478   p = line = text;
1479   while (1)
1480     {
1481       /* The number of columns including any trailing space.  */
1482       int cols;
1483
1484       p = p + strcspn (p, "\n ");
1485       if (! p)
1486         /* P now points to the NUL character.  */
1487         p = &text[strlen (text)];
1488
1489       if (*p == '\n')
1490         /* Pass through any newlines.  */
1491         {
1492           p ++;
1493           line = p;
1494           last_space = NULL;
1495           last_space_cols = 0;
1496           copied_last_space = 1;
1497           continue;
1498         }
1499
1500       /* Have a space or a NUL.  Note: we don't count the trailing
1501          space.  */
1502       cols = utf8_charcount (line, (uintptr_t) p - (uintptr_t) line);
1503       if (cols < target_cols)
1504         {
1505           if (! *p)
1506             /* Nothing left to break.  */
1507             break;
1508
1509           last_space = p;
1510           last_space_cols = cols;
1511           p ++;
1512           /* Skip any immediately following spaces.  If we break:
1513              "... foo bar ..." between "foo" and "bar" then we want:
1514              "... foo\nbar ...", which means that the left space has
1515              to be the first space after foo, not the last space
1516              before bar.  */
1517           while (*p == ' ')
1518             p ++;
1519         }
1520       else
1521         {
1522           int cols_with_left_space;
1523           int cols_with_right_space;
1524           int left_penalty;
1525           int right_penalty;
1526
1527           cols_with_left_space = last_space_cols;
1528           cols_with_right_space = cols;
1529
1530           if (do_debug)
1531             log_debug ("Breaking: '%.*s'\n",
1532                        (int) ((uintptr_t) p - (uintptr_t) line), line);
1533
1534           /* The number of columns away from TARGET_COLS.  We prefer
1535              to underflow than to overflow.  */
1536           left_penalty = target_cols - cols_with_left_space;
1537           right_penalty = 2 * (cols_with_right_space - target_cols);
1538
1539           if (cols_with_right_space > max_cols)
1540             /* Add a large penalty for each column that exceeds
1541                max_cols.  */
1542             right_penalty += 4 * (cols_with_right_space - max_cols);
1543
1544           if (do_debug)
1545             log_debug ("Left space => %d cols (penalty: %d); right space => %d cols (penalty: %d)\n",
1546                        cols_with_left_space, left_penalty,
1547                        cols_with_right_space, right_penalty);
1548           if (last_space_cols && left_penalty <= right_penalty)
1549             /* Prefer the left space.  */
1550             {
1551               if (do_debug)
1552                 log_debug ("Breaking at left space.\n");
1553               p = last_space;
1554             }
1555           else
1556             {
1557               if (do_debug)
1558                 log_debug ("Breaking at right space.\n");
1559             }
1560
1561           if (! *p)
1562             break;
1563
1564           *p = '\n';
1565           p ++;
1566           if (*p == ' ')
1567             {
1568               int spaces;
1569               for (spaces = 1; p[spaces] == ' '; spaces ++)
1570                 ;
1571               memmove (p, &p[spaces], strlen (&p[spaces]) + 1);
1572             }
1573           line = p;
1574           last_space = NULL;
1575           last_space_cols = 0;
1576           copied_last_space = 0;
1577         }
1578     }
1579
1580   /* Chop off any trailing space.  */
1581   trim_trailing_chars (text, strlen (text), " ");
1582   /* If we inserted the trailing newline, then remove it.  */
1583   if (! copied_last_space && *text && text[strlen (text) - 1] == '\n')
1584     text[strlen (text) - 1] = '\0';
1585
1586   return text;
1587 }