common: Reduce buffer size.
[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 \f
1333 /* Version number parsing.  */
1334
1335 /* This function parses the first portion of the version number S and
1336    stores it in *NUMBER.  On success, this function returns a pointer
1337    into S starting with the first character, which is not part of the
1338    initial number portion; on failure, NULL is returned.  */
1339 static const char*
1340 parse_version_number (const char *s, int *number)
1341 {
1342   int val = 0;
1343
1344   if (*s == '0' && digitp (s+1))
1345     return NULL;  /* Leading zeros are not allowed.  */
1346   for (; digitp (s); s++)
1347     {
1348       val *= 10;
1349       val += *s - '0';
1350     }
1351   *number = val;
1352   return val < 0 ? NULL : s;
1353 }
1354
1355
1356 /* This function breaks up the complete string-representation of the
1357    version number S, which is of the following struture: <major
1358    number>.<minor number>.<micro number><patch level>.  The major,
1359    minor and micro number components will be stored in *MAJOR, *MINOR
1360    and *MICRO.
1361
1362    On success, the last component, the patch level, will be returned;
1363    in failure, NULL will be returned.  */
1364 static const char *
1365 parse_version_string (const char *s, int *major, int *minor, int *micro)
1366 {
1367   s = parse_version_number (s, major);
1368   if (!s || *s != '.')
1369     return NULL;
1370   s++;
1371   s = parse_version_number (s, minor);
1372   if (!s)
1373     return NULL;
1374   if (*s == '.')
1375     {
1376       s++;
1377       s = parse_version_number (s, micro);
1378       if (!s)
1379         return NULL;
1380     }
1381   else
1382     *micro = 0;
1383   return s;  /* Patchlevel.  */
1384 }
1385
1386
1387 /* Check that the version string MY_VERSION is greater or equal than
1388    REQ_VERSION.  Returns true if the condition is satisfied or false
1389    if not.  This works with 3 part and two part version strings; for a
1390    two part version string the micor part is assumed to be 0.  */
1391 int
1392 compare_version_strings (const char *my_version, const char *req_version)
1393 {
1394   int my_major, my_minor, my_micro;
1395   int rq_major, rq_minor, rq_micro;
1396
1397   if (!my_version || !req_version)
1398     return 0;
1399
1400   if (!parse_version_string (my_version, &my_major, &my_minor, &my_micro))
1401     return 0;
1402   if (!parse_version_string(req_version, &rq_major, &rq_minor, &rq_micro))
1403     return 0;
1404
1405   if (my_major > rq_major
1406       || (my_major == rq_major && my_minor > rq_minor)
1407       || (my_major == rq_major && my_minor == rq_minor
1408           && my_micro >= rq_micro))
1409     {
1410       return 1;
1411     }
1412   return 0;
1413 }
1414
1415
1416 \f
1417 /* Format a string so that it fits within about TARGET_COLS columns.
1418    If IN_PLACE is 0, then TEXT is copied to a new buffer, which is
1419    returned.  Otherwise, TEXT is modified in place and returned.
1420    Normally, target_cols will be 72 and max_cols is 80.  */
1421 char *
1422 format_text (char *text, int in_place, int target_cols, int max_cols)
1423 {
1424   const int do_debug = 0;
1425
1426   /* The character under consideration.  */
1427   char *p;
1428   /* The start of the current line.  */
1429   char *line;
1430   /* The last space that we saw.  */
1431   char *last_space = NULL;
1432   int last_space_cols = 0;
1433   int copied_last_space = 0;
1434
1435   if (! in_place)
1436     text = xstrdup (text);
1437
1438   p = line = text;
1439   while (1)
1440     {
1441       /* The number of columns including any trailing space.  */
1442       int cols;
1443
1444       p = p + strcspn (p, "\n ");
1445       if (! p)
1446         /* P now points to the NUL character.  */
1447         p = &text[strlen (text)];
1448
1449       if (*p == '\n')
1450         /* Pass through any newlines.  */
1451         {
1452           p ++;
1453           line = p;
1454           last_space = NULL;
1455           last_space_cols = 0;
1456           copied_last_space = 1;
1457           continue;
1458         }
1459
1460       /* Have a space or a NUL.  Note: we don't count the trailing
1461          space.  */
1462       cols = utf8_charcount (line, (uintptr_t) p - (uintptr_t) line);
1463       if (cols < target_cols)
1464         {
1465           if (! *p)
1466             /* Nothing left to break.  */
1467             break;
1468
1469           last_space = p;
1470           last_space_cols = cols;
1471           p ++;
1472           /* Skip any immediately following spaces.  If we break:
1473              "... foo bar ..." between "foo" and "bar" then we want:
1474              "... foo\nbar ...", which means that the left space has
1475              to be the first space after foo, not the last space
1476              before bar.  */
1477           while (*p == ' ')
1478             p ++;
1479         }
1480       else
1481         {
1482           int cols_with_left_space;
1483           int cols_with_right_space;
1484           int left_penalty;
1485           int right_penalty;
1486
1487           cols_with_left_space = last_space_cols;
1488           cols_with_right_space = cols;
1489
1490           if (do_debug)
1491             log_debug ("Breaking: '%.*s'\n",
1492                        (int) ((uintptr_t) p - (uintptr_t) line), line);
1493
1494           /* The number of columns away from TARGET_COLS.  We prefer
1495              to underflow than to overflow.  */
1496           left_penalty = target_cols - cols_with_left_space;
1497           right_penalty = 2 * (cols_with_right_space - target_cols);
1498
1499           if (cols_with_right_space > max_cols)
1500             /* Add a large penalty for each column that exceeds
1501                max_cols.  */
1502             right_penalty += 4 * (cols_with_right_space - max_cols);
1503
1504           if (do_debug)
1505             log_debug ("Left space => %d cols (penalty: %d); right space => %d cols (penalty: %d)\n",
1506                        cols_with_left_space, left_penalty,
1507                        cols_with_right_space, right_penalty);
1508           if (last_space_cols && left_penalty <= right_penalty)
1509             /* Prefer the left space.  */
1510             {
1511               if (do_debug)
1512                 log_debug ("Breaking at left space.\n");
1513               p = last_space;
1514             }
1515           else
1516             {
1517               if (do_debug)
1518                 log_debug ("Breaking at right space.\n");
1519             }
1520
1521           if (! *p)
1522             break;
1523
1524           *p = '\n';
1525           p ++;
1526           if (*p == ' ')
1527             {
1528               int spaces;
1529               for (spaces = 1; p[spaces] == ' '; spaces ++)
1530                 ;
1531               memmove (p, &p[spaces], strlen (&p[spaces]) + 1);
1532             }
1533           line = p;
1534           last_space = NULL;
1535           last_space_cols = 0;
1536           copied_last_space = 0;
1537         }
1538     }
1539
1540   /* Chop off any trailing space.  */
1541   trim_trailing_chars (text, strlen (text), " ");
1542   /* If we inserted the trailing newline, then remove it.  */
1543   if (! copied_last_space && *text && text[strlen (text) - 1] == '\n')
1544     text[strlen (text) - 1] = '\0';
1545
1546   return text;
1547 }