iobuf: Add the IOBUF_INPUT_TEMP type to improve input temp handling.
[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.  Note, that this function
750    does not take combined characters into account.  */
751 size_t
752 utf8_charcount (const char *s)
753 {
754   size_t n;
755
756   for (n=0; *s; s++)
757     if ( (*s&0xc0) != 0x80 ) /* Exclude continuation bytes: 10xxxxxx */
758       n++;
759
760   return n;
761 }
762
763
764 /****************************************************
765  **********  W32 specific functions  ****************
766  ****************************************************/
767
768 #ifdef HAVE_W32_SYSTEM
769 const char *
770 w32_strerror (int ec)
771 {
772   static char strerr[256];
773
774   if (ec == -1)
775     ec = (int)GetLastError ();
776 #ifdef HAVE_W32CE_SYSTEM
777   /* There is only a wchar_t FormatMessage.  It does not make much
778      sense to play the conversion game; we print only the code.  */
779   snprintf (strerr, sizeof strerr, "ec=%d", (int)GetLastError ());
780 #else
781   FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, NULL, ec,
782                  MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
783                  strerr, DIM (strerr)-1, NULL);
784 #endif
785   return strerr;
786 }
787 #endif /*HAVE_W32_SYSTEM*/
788
789
790 /****************************************************
791  ******** Locale insensitive ctype functions ********
792  ****************************************************/
793 /* FIXME: replace them by a table lookup and macros */
794 int
795 ascii_isupper (int c)
796 {
797     return c >= 'A' && c <= 'Z';
798 }
799
800 int
801 ascii_islower (int c)
802 {
803     return c >= 'a' && c <= 'z';
804 }
805
806 int
807 ascii_toupper (int c)
808 {
809     if (c >= 'a' && c <= 'z')
810         c &= ~0x20;
811     return c;
812 }
813
814 int
815 ascii_tolower (int c)
816 {
817     if (c >= 'A' && c <= 'Z')
818         c |= 0x20;
819     return c;
820 }
821
822 /* Lowercase all ASCII characters in S.  */
823 char *
824 ascii_strlwr (char *s)
825 {
826   char *p = s;
827
828   for (p=s; *p; p++ )
829     if (isascii (*p) && *p >= 'A' && *p <= 'Z')
830       *p |= 0x20;
831
832   return s;
833 }
834
835 int
836 ascii_strcasecmp( const char *a, const char *b )
837 {
838     if (a == b)
839         return 0;
840
841     for (; *a && *b; a++, b++) {
842         if (*a != *b && ascii_toupper(*a) != ascii_toupper(*b))
843             break;
844     }
845     return *a == *b? 0 : (ascii_toupper (*a) - ascii_toupper (*b));
846 }
847
848 int
849 ascii_strncasecmp (const char *a, const char *b, size_t n)
850 {
851   const unsigned char *p1 = (const unsigned char *)a;
852   const unsigned char *p2 = (const unsigned char *)b;
853   unsigned char c1, c2;
854
855   if (p1 == p2 || !n )
856     return 0;
857
858   do
859     {
860       c1 = ascii_tolower (*p1);
861       c2 = ascii_tolower (*p2);
862
863       if ( !--n || c1 == '\0')
864         break;
865
866       ++p1;
867       ++p2;
868     }
869   while (c1 == c2);
870
871   return c1 - c2;
872 }
873
874
875 int
876 ascii_memcasecmp (const void *a_arg, const void *b_arg, size_t n )
877 {
878   const char *a = a_arg;
879   const char *b = b_arg;
880
881   if (a == b)
882     return 0;
883   for ( ; n; n--, a++, b++ )
884     {
885       if( *a != *b  && ascii_toupper (*a) != ascii_toupper (*b) )
886         return *a == *b? 0 : (ascii_toupper (*a) - ascii_toupper (*b));
887     }
888   return 0;
889 }
890
891 int
892 ascii_strcmp( const char *a, const char *b )
893 {
894     if (a == b)
895         return 0;
896
897     for (; *a && *b; a++, b++) {
898         if (*a != *b )
899             break;
900     }
901     return *a == *b? 0 : (*(signed char *)a - *(signed char *)b);
902 }
903
904
905 void *
906 ascii_memcasemem (const void *haystack, size_t nhaystack,
907                   const void *needle, size_t nneedle)
908 {
909
910   if (!nneedle)
911     return (void*)haystack; /* finding an empty needle is really easy */
912   if (nneedle <= nhaystack)
913     {
914       const char *a = haystack;
915       const char *b = a + nhaystack - nneedle;
916
917       for (; a <= b; a++)
918         {
919           if ( !ascii_memcasecmp (a, needle, nneedle) )
920             return (void *)a;
921         }
922     }
923   return NULL;
924 }
925
926 /*********************************************
927  ********** missing string functions *********
928  *********************************************/
929
930 #ifndef HAVE_STPCPY
931 char *
932 stpcpy(char *a,const char *b)
933 {
934     while( *b )
935         *a++ = *b++;
936     *a = 0;
937
938     return (char*)a;
939 }
940 #endif
941
942 #ifndef HAVE_STRPBRK
943 /* Find the first occurrence in S of any character in ACCEPT.
944    Code taken from glibc-2.6/string/strpbrk.c (LGPLv2.1+) and modified. */
945 char *
946 strpbrk (const char *s, const char *accept)
947 {
948   while (*s != '\0')
949     {
950       const char *a = accept;
951       while (*a != '\0')
952         if (*a++ == *s)
953           return (char *) s;
954       ++s;
955     }
956
957   return NULL;
958 }
959 #endif /*!HAVE_STRPBRK*/
960
961
962 #ifndef HAVE_STRSEP
963 /* Code taken from glibc-2.2.1/sysdeps/generic/strsep.c. */
964 char *
965 strsep (char **stringp, const char *delim)
966 {
967   char *begin, *end;
968
969   begin = *stringp;
970   if (begin == NULL)
971     return NULL;
972
973   /* A frequent case is when the delimiter string contains only one
974      character.  Here we don't need to call the expensive 'strpbrk'
975      function and instead work using 'strchr'.  */
976   if (delim[0] == '\0' || delim[1] == '\0')
977     {
978       char ch = delim[0];
979
980       if (ch == '\0')
981         end = NULL;
982       else
983         {
984           if (*begin == ch)
985             end = begin;
986           else if (*begin == '\0')
987             end = NULL;
988           else
989             end = strchr (begin + 1, ch);
990         }
991     }
992   else
993     /* Find the end of the token.  */
994     end = strpbrk (begin, delim);
995
996   if (end)
997     {
998       /* Terminate the token and set *STRINGP past NUL character.  */
999       *end++ = '\0';
1000       *stringp = end;
1001     }
1002   else
1003     /* No more delimiters; this is the last token.  */
1004     *stringp = NULL;
1005
1006   return begin;
1007 }
1008 #endif /*HAVE_STRSEP*/
1009
1010
1011 #ifndef HAVE_STRLWR
1012 char *
1013 strlwr(char *s)
1014 {
1015     char *p;
1016     for(p=s; *p; p++ )
1017         *p = tolower(*p);
1018     return s;
1019 }
1020 #endif
1021
1022
1023 #ifndef HAVE_STRCASECMP
1024 int
1025 strcasecmp( const char *a, const char *b )
1026 {
1027     for( ; *a && *b; a++, b++ ) {
1028         if( *a != *b && toupper(*a) != toupper(*b) )
1029             break;
1030     }
1031     return *(const byte*)a - *(const byte*)b;
1032 }
1033 #endif
1034
1035
1036 /****************
1037  * mingw32/cpd has a memicmp()
1038  */
1039 #ifndef HAVE_MEMICMP
1040 int
1041 memicmp( const char *a, const char *b, size_t n )
1042 {
1043     for( ; n; n--, a++, b++ )
1044         if( *a != *b  && toupper(*(const byte*)a) != toupper(*(const byte*)b) )
1045             return *(const byte *)a - *(const byte*)b;
1046     return 0;
1047 }
1048 #endif
1049
1050
1051 #ifndef HAVE_MEMRCHR
1052 void *
1053 memrchr (const void *buffer, int c, size_t n)
1054 {
1055   const unsigned char *p = buffer;
1056
1057   for (p += n; n ; n--)
1058     if (*--p == c)
1059       return (void *)p;
1060   return NULL;
1061 }
1062 #endif /*HAVE_MEMRCHR*/
1063
1064 \f
1065 /* Percent-escape the string STR by replacing colons with '%3a'.  If
1066    EXTRA is not NULL all characters in EXTRA are also escaped.  */
1067 static char *
1068 do_percent_escape (const char *str, const char *extra, int die)
1069 {
1070   int i, j;
1071   char *ptr;
1072
1073   if (!str)
1074     return NULL;
1075
1076   for (i=j=0; str[i]; i++)
1077     if (str[i] == ':' || str[i] == '%' || (extra && strchr (extra, str[i])))
1078       j++;
1079   if (die)
1080     ptr = xmalloc (i + 2 * j + 1);
1081   else
1082     {
1083       ptr = xtrymalloc (i + 2 * j + 1);
1084       if (!ptr)
1085         return NULL;
1086     }
1087   i = 0;
1088   while (*str)
1089     {
1090       if (*str == ':')
1091         {
1092           ptr[i++] = '%';
1093           ptr[i++] = '3';
1094           ptr[i++] = 'a';
1095         }
1096       else if (*str == '%')
1097         {
1098           ptr[i++] = '%';
1099           ptr[i++] = '2';
1100           ptr[i++] = '5';
1101         }
1102       else if (extra && strchr (extra, *str))
1103         {
1104           ptr[i++] = '%';
1105           ptr[i++] = tohex_lower ((*str>>4)&15);
1106           ptr[i++] = tohex_lower (*str&15);
1107         }
1108       else
1109         ptr[i++] = *str;
1110       str++;
1111     }
1112   ptr[i] = '\0';
1113
1114   return ptr;
1115 }
1116
1117 /* Percent-escape the string STR by replacing colons with '%3a'.  If
1118    EXTRA is not NULL all characters in EXTRA are also escaped.  This
1119    function terminates the process on memory shortage.  */
1120 char *
1121 percent_escape (const char *str, const char *extra)
1122 {
1123   return do_percent_escape (str, extra, 1);
1124 }
1125
1126 /* Same as percent_escape but return NULL instead of exiting on memory
1127    error. */
1128 char *
1129 try_percent_escape (const char *str, const char *extra)
1130 {
1131   return do_percent_escape (str, extra, 0);
1132 }
1133
1134
1135
1136 static char *
1137 do_strconcat (const char *s1, va_list arg_ptr)
1138 {
1139   const char *argv[48];
1140   size_t argc;
1141   size_t needed;
1142   char *buffer, *p;
1143
1144   argc = 0;
1145   argv[argc++] = s1;
1146   needed = strlen (s1);
1147   while (((argv[argc] = va_arg (arg_ptr, const char *))))
1148     {
1149       needed += strlen (argv[argc]);
1150       if (argc >= DIM (argv)-1)
1151         {
1152           gpg_err_set_errno (EINVAL);
1153           return NULL;
1154         }
1155       argc++;
1156     }
1157   needed++;
1158   buffer = xtrymalloc (needed);
1159   if (buffer)
1160     {
1161       for (p = buffer, argc=0; argv[argc]; argc++)
1162         p = stpcpy (p, argv[argc]);
1163     }
1164   return buffer;
1165 }
1166
1167
1168 /* Concatenate the string S1 with all the following strings up to a
1169    NULL.  Returns a malloced buffer with the new string or NULL on a
1170    malloc error or if too many arguments are given.  */
1171 char *
1172 strconcat (const char *s1, ...)
1173 {
1174   va_list arg_ptr;
1175   char *result;
1176
1177   if (!s1)
1178     result = xtrystrdup ("");
1179   else
1180     {
1181       va_start (arg_ptr, s1);
1182       result = do_strconcat (s1, arg_ptr);
1183       va_end (arg_ptr);
1184     }
1185   return result;
1186 }
1187
1188 /* Same as strconcat but terminate the process with an error message
1189    if something goes wrong.  */
1190 char *
1191 xstrconcat (const char *s1, ...)
1192 {
1193   va_list arg_ptr;
1194   char *result;
1195
1196   if (!s1)
1197     result = xstrdup ("");
1198   else
1199     {
1200       va_start (arg_ptr, s1);
1201       result = do_strconcat (s1, arg_ptr);
1202       va_end (arg_ptr);
1203     }
1204   if (!result)
1205     {
1206       if (errno == EINVAL)
1207         fputs ("\nfatal: too many args for xstrconcat\n", stderr);
1208       else
1209         fputs ("\nfatal: out of memory\n", stderr);
1210       exit (2);
1211     }
1212   return result;
1213 }
1214
1215 /* Split a string into fields at DELIM.  REPLACEMENT is the character
1216    to replace the delimiter with (normally: '\0' so that each field is
1217    NUL terminated).  The caller is responsible for freeing the result.
1218    Note: this function modifies STRING!  If you need the original
1219    value, then you should pass a copy to this function.
1220
1221    If malloc fails, this function returns NULL.  */
1222 char **
1223 strsplit (char *string, char delim, char replacement, int *count)
1224 {
1225   int fields = 1;
1226   char *t;
1227   char **result;
1228
1229   /* First, count the number of fields.  */
1230   for (t = strchr (string, delim); t; t = strchr (t + 1, delim))
1231     fields ++;
1232
1233   result = xtrycalloc (sizeof (*result), (fields + 1));
1234   if (! result)
1235     return NULL;
1236
1237   result[0] = string;
1238   fields = 1;
1239   for (t = strchr (string, delim); t; t = strchr (t + 1, delim))
1240     {
1241       result[fields ++] = t + 1;
1242       *t = replacement;
1243     }
1244
1245   if (count)
1246     *count = fields;
1247
1248   return result;
1249 }
1250
1251
1252 /* Tokenize STRING using the set of delimiters in DELIM.  Leading
1253  * spaces and tabs are removed from all tokens.  The caller must xfree
1254  * the result.
1255  *
1256  * Returns: A malloced and NULL delimited array with the tokens.  On
1257  *          memory error NULL is returned and ERRNO is set.
1258  */
1259 char **
1260 strtokenize (const char *string, const char *delim)
1261 {
1262   const char *s;
1263   size_t fields;
1264   size_t bytes, n;
1265   char *buffer;
1266   char *p, *px, *pend;
1267   char **result;
1268
1269   /* Count the number of fields.  */
1270   for (fields = 1, s = strpbrk (string, delim); s; s = strpbrk (s + 1, delim))
1271     fields++;
1272   fields++; /* Add one for the terminating NULL.  */
1273
1274   /* Allocate an array for all fields, a terminating NULL, and space
1275      for a copy of the string.  */
1276   bytes = fields * sizeof *result;
1277   if (bytes / sizeof *result != fields)
1278     {
1279       gpg_err_set_errno (ENOMEM);
1280       return NULL;
1281     }
1282   n = strlen (string) + 1;
1283   bytes += n;
1284   if (bytes < n)
1285     {
1286       gpg_err_set_errno (ENOMEM);
1287       return NULL;
1288     }
1289   result = xtrymalloc (bytes);
1290   if (!result)
1291     return NULL;
1292   buffer = (char*)(result + fields);
1293
1294   /* Copy and parse the string.  */
1295   strcpy (buffer, string);
1296   for (n = 0, p = buffer; (pend = strpbrk (p, delim)); p = pend + 1)
1297     {
1298       *pend = 0;
1299       while (spacep (p))
1300         p++;
1301       for (px = pend - 1; px >= p && spacep (px); px--)
1302         *px = 0;
1303       result[n++] = p;
1304     }
1305   while (spacep (p))
1306     p++;
1307   for (px = p + strlen (p) - 1; px >= p && spacep (px); px--)
1308     *px = 0;
1309   result[n++] = p;
1310   result[n] = NULL;
1311
1312   assert ((char*)(result + n + 1) == buffer);
1313
1314   return result;
1315 }