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