Pass DBUS_SESSION_BUS_ADDRESS for gnome3
[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     p = stpcpy (stpcpy (p, "/"), argv[argc]);
497
498   if (want_abs)
499     {
500 #ifdef HAVE_DRIVE_LETTERS
501       p = strchr (name, ':');
502       if (p)
503         p++;
504       else
505         p = name;
506 #else
507       p = name;
508 #endif
509       if (*p != '/'
510 #ifdef HAVE_DRIVE_LETTERS
511           && *p != '\\'
512 #endif
513           )
514         {
515           home = gnupg_getcwd ();
516           if (!home)
517             {
518               if (xmode)
519                 {
520                   fprintf (stderr, "\nfatal: getcwd failed: %s\n",
521                            strerror (errno));
522                   exit(2);
523                 }
524               xfree (name);
525               return NULL;
526             }
527           n = strlen (home) + 1 + strlen (name) + 1;
528           if (xmode)
529             home_buffer = xmalloc (n);
530           else
531             {
532               home_buffer = xtrymalloc (n);
533               if (!home_buffer)
534                 {
535                   xfree (name);
536                   return NULL;
537                 }
538             }
539           if (p == name)
540             p = home_buffer;
541           else /* Windows case.  */
542             {
543               memcpy (home_buffer, p, p - name + 1);
544               p = home_buffer + (p - name + 1);
545             }
546           strcpy (stpcpy (stpcpy (p, home), "/"), name);
547           xfree (name);
548           name = home_buffer;
549           /* Let's do a simple compression to catch the most common
550              case of using "." for gpg's --homedir option.  */
551           n = strlen (name);
552           if (n > 2 && name[n-2] == '/' && name[n-1] == '.')
553             name[n-2] = 0;
554         }
555     }
556   return change_slashes (name);
557 }
558
559 /* Construct a filename from the NULL terminated list of parts.  Tilde
560    expansion is done for the first argument.  This function terminates
561    the process on memory shortage. */
562 char *
563 make_filename (const char *first_part, ... )
564 {
565   va_list arg_ptr;
566   char *result;
567
568   va_start (arg_ptr, first_part);
569   result = do_make_filename (1, first_part, arg_ptr);
570   va_end (arg_ptr);
571   return result;
572 }
573
574 /* Construct a filename from the NULL terminated list of parts.  Tilde
575    expansion is done for the first argument.  This function may return
576    NULL on error. */
577 char *
578 make_filename_try (const char *first_part, ... )
579 {
580   va_list arg_ptr;
581   char *result;
582
583   va_start (arg_ptr, first_part);
584   result = do_make_filename (0, first_part, arg_ptr);
585   va_end (arg_ptr);
586   return result;
587 }
588
589 /* Construct an absolute filename from the NULL terminated list of
590    parts.  Tilde expansion is done for the first argument.  This
591    function terminates the process on memory shortage. */
592 char *
593 make_absfilename (const char *first_part, ... )
594 {
595   va_list arg_ptr;
596   char *result;
597
598   va_start (arg_ptr, first_part);
599   result = do_make_filename (3, first_part, arg_ptr);
600   va_end (arg_ptr);
601   return result;
602 }
603
604 /* Construct an absolute filename from the NULL terminated list of
605    parts.  Tilde expansion is done for the first argument.  This
606    function may return NULL on error. */
607 char *
608 make_absfilename_try (const char *first_part, ... )
609 {
610   va_list arg_ptr;
611   char *result;
612
613   va_start (arg_ptr, first_part);
614   result = do_make_filename (2, first_part, arg_ptr);
615   va_end (arg_ptr);
616   return result;
617 }
618
619
620 \f
621 /* Compare whether the filenames are identical.  This is a
622    special version of strcmp() taking the semantics of filenames in
623    account.  Note that this function works only on the supplied names
624    without considering any context like the current directory.  See
625    also same_file_p(). */
626 int
627 compare_filenames (const char *a, const char *b)
628 {
629 #ifdef HAVE_DOSISH_SYSTEM
630   for ( ; *a && *b; a++, b++ )
631     {
632       if (*a != *b
633           && (toupper (*(const unsigned char*)a)
634               != toupper (*(const unsigned char*)b) )
635           && !((*a == '/' && *b == '\\') || (*a == '\\' && *b == '/')))
636         break;
637     }
638   if ((*a == '/' && *b == '\\') || (*a == '\\' && *b == '/'))
639     return 0;
640   else
641     return (toupper (*(const unsigned char*)a)
642             - toupper (*(const unsigned char*)b));
643 #else
644     return strcmp(a,b);
645 #endif
646 }
647
648
649 /* Convert 2 hex characters at S to a byte value.  Return this value
650    or -1 if there is an error. */
651 int
652 hextobyte (const char *s)
653 {
654   int c;
655
656   if ( *s >= '0' && *s <= '9' )
657     c = 16 * (*s - '0');
658   else if ( *s >= 'A' && *s <= 'F' )
659     c = 16 * (10 + *s - 'A');
660   else if ( *s >= 'a' && *s <= 'f' )
661     c = 16 * (10 + *s - 'a');
662   else
663     return -1;
664   s++;
665   if ( *s >= '0' && *s <= '9' )
666     c += *s - '0';
667   else if ( *s >= 'A' && *s <= 'F' )
668     c += 10 + *s - 'A';
669   else if ( *s >= 'a' && *s <= 'f' )
670     c += 10 + *s - 'a';
671   else
672     return -1;
673   return c;
674 }
675
676
677 /* Create a string from the buffer P_ARG of length N which is suitable
678    for printing.  Caller must release the created string using xfree.
679    This function terminates the process on memory shortage.  */
680 char *
681 sanitize_buffer (const void *p_arg, size_t n, int delim)
682 {
683   const unsigned char *p = p_arg;
684   size_t save_n, buflen;
685   const unsigned char *save_p;
686   char *buffer, *d;
687
688   /* First count length. */
689   for (save_n = n, save_p = p, buflen=1 ; n; n--, p++ )
690     {
691       if ( *p < 0x20 || *p == 0x7f || *p == delim  || (delim && *p=='\\'))
692         {
693           if ( *p=='\n' || *p=='\r' || *p=='\f'
694                || *p=='\v' || *p=='\b' || !*p )
695             buflen += 2;
696           else
697             buflen += 5;
698         }
699       else
700         buflen++;
701     }
702   p = save_p;
703   n = save_n;
704   /* And now make the string */
705   d = buffer = xmalloc( buflen );
706   for ( ; n; n--, p++ )
707     {
708       if (*p < 0x20 || *p == 0x7f || *p == delim || (delim && *p=='\\')) {
709         *d++ = '\\';
710         if( *p == '\n' )
711           *d++ = 'n';
712         else if( *p == '\r' )
713           *d++ = 'r';
714         else if( *p == '\f' )
715           *d++ = 'f';
716         else if( *p == '\v' )
717           *d++ = 'v';
718         else if( *p == '\b' )
719           *d++ = 'b';
720         else if( !*p )
721           *d++ = '0';
722         else {
723           sprintf(d, "x%02x", *p );
724           d += 3;
725         }
726       }
727       else
728         *d++ = *p;
729     }
730   *d = 0;
731   return buffer;
732 }
733
734
735 /* Given a string containing an UTF-8 encoded text, return the number
736    of characters in this string.  It differs from strlen in that it
737    only counts complete UTF-8 characters.  Note, that this function
738    does not take combined characters into account.  */
739 size_t
740 utf8_charcount (const char *s)
741 {
742   size_t n;
743
744   for (n=0; *s; s++)
745     if ( (*s&0xc0) != 0x80 ) /* Exclude continuation bytes: 10xxxxxx */
746       n++;
747
748   return n;
749 }
750
751
752 /****************************************************
753  **********  W32 specific functions  ****************
754  ****************************************************/
755
756 #ifdef HAVE_W32_SYSTEM
757 const char *
758 w32_strerror (int ec)
759 {
760   static char strerr[256];
761
762   if (ec == -1)
763     ec = (int)GetLastError ();
764 #ifdef HAVE_W32CE_SYSTEM
765   /* There is only a wchar_t FormatMessage.  It does not make much
766      sense to play the conversion game; we print only the code.  */
767   snprintf (strerr, sizeof strerr, "ec=%d", (int)GetLastError ());
768 #else
769   FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, NULL, ec,
770                  MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
771                  strerr, DIM (strerr)-1, NULL);
772 #endif
773   return strerr;
774 }
775 #endif /*HAVE_W32_SYSTEM*/
776
777
778 /****************************************************
779  ******** Locale insensitive ctype functions ********
780  ****************************************************/
781 /* FIXME: replace them by a table lookup and macros */
782 int
783 ascii_isupper (int c)
784 {
785     return c >= 'A' && c <= 'Z';
786 }
787
788 int
789 ascii_islower (int c)
790 {
791     return c >= 'a' && c <= 'z';
792 }
793
794 int
795 ascii_toupper (int c)
796 {
797     if (c >= 'a' && c <= 'z')
798         c &= ~0x20;
799     return c;
800 }
801
802 int
803 ascii_tolower (int c)
804 {
805     if (c >= 'A' && c <= 'Z')
806         c |= 0x20;
807     return c;
808 }
809
810 /* Lowercase all ASCII characters in S.  */
811 char *
812 ascii_strlwr (char *s)
813 {
814   char *p = s;
815
816   for (p=s; *p; p++ )
817     if (isascii (*p) && *p >= 'A' && *p <= 'Z')
818       *p |= 0x20;
819
820   return s;
821 }
822
823 int
824 ascii_strcasecmp( const char *a, const char *b )
825 {
826     if (a == b)
827         return 0;
828
829     for (; *a && *b; a++, b++) {
830         if (*a != *b && ascii_toupper(*a) != ascii_toupper(*b))
831             break;
832     }
833     return *a == *b? 0 : (ascii_toupper (*a) - ascii_toupper (*b));
834 }
835
836 int
837 ascii_strncasecmp (const char *a, const char *b, size_t n)
838 {
839   const unsigned char *p1 = (const unsigned char *)a;
840   const unsigned char *p2 = (const unsigned char *)b;
841   unsigned char c1, c2;
842
843   if (p1 == p2 || !n )
844     return 0;
845
846   do
847     {
848       c1 = ascii_tolower (*p1);
849       c2 = ascii_tolower (*p2);
850
851       if ( !--n || c1 == '\0')
852         break;
853
854       ++p1;
855       ++p2;
856     }
857   while (c1 == c2);
858
859   return c1 - c2;
860 }
861
862
863 int
864 ascii_memcasecmp (const void *a_arg, const void *b_arg, size_t n )
865 {
866   const char *a = a_arg;
867   const char *b = b_arg;
868
869   if (a == b)
870     return 0;
871   for ( ; n; n--, a++, b++ )
872     {
873       if( *a != *b  && ascii_toupper (*a) != ascii_toupper (*b) )
874         return *a == *b? 0 : (ascii_toupper (*a) - ascii_toupper (*b));
875     }
876   return 0;
877 }
878
879 int
880 ascii_strcmp( const char *a, const char *b )
881 {
882     if (a == b)
883         return 0;
884
885     for (; *a && *b; a++, b++) {
886         if (*a != *b )
887             break;
888     }
889     return *a == *b? 0 : (*(signed char *)a - *(signed char *)b);
890 }
891
892
893 void *
894 ascii_memcasemem (const void *haystack, size_t nhaystack,
895                   const void *needle, size_t nneedle)
896 {
897
898   if (!nneedle)
899     return (void*)haystack; /* finding an empty needle is really easy */
900   if (nneedle <= nhaystack)
901     {
902       const char *a = haystack;
903       const char *b = a + nhaystack - nneedle;
904
905       for (; a <= b; a++)
906         {
907           if ( !ascii_memcasecmp (a, needle, nneedle) )
908             return (void *)a;
909         }
910     }
911   return NULL;
912 }
913
914 /*********************************************
915  ********** missing string functions *********
916  *********************************************/
917
918 #ifndef HAVE_STPCPY
919 char *
920 stpcpy(char *a,const char *b)
921 {
922     while( *b )
923         *a++ = *b++;
924     *a = 0;
925
926     return (char*)a;
927 }
928 #endif
929
930 #ifndef HAVE_STRPBRK
931 /* Find the first occurrence in S of any character in ACCEPT.
932    Code taken from glibc-2.6/string/strpbrk.c (LGPLv2.1+) and modified. */
933 char *
934 strpbrk (const char *s, const char *accept)
935 {
936   while (*s != '\0')
937     {
938       const char *a = accept;
939       while (*a != '\0')
940         if (*a++ == *s)
941           return (char *) s;
942       ++s;
943     }
944
945   return NULL;
946 }
947 #endif /*!HAVE_STRPBRK*/
948
949
950 #ifndef HAVE_STRSEP
951 /* Code taken from glibc-2.2.1/sysdeps/generic/strsep.c. */
952 char *
953 strsep (char **stringp, const char *delim)
954 {
955   char *begin, *end;
956
957   begin = *stringp;
958   if (begin == NULL)
959     return NULL;
960
961   /* A frequent case is when the delimiter string contains only one
962      character.  Here we don't need to call the expensive 'strpbrk'
963      function and instead work using 'strchr'.  */
964   if (delim[0] == '\0' || delim[1] == '\0')
965     {
966       char ch = delim[0];
967
968       if (ch == '\0')
969         end = NULL;
970       else
971         {
972           if (*begin == ch)
973             end = begin;
974           else if (*begin == '\0')
975             end = NULL;
976           else
977             end = strchr (begin + 1, ch);
978         }
979     }
980   else
981     /* Find the end of the token.  */
982     end = strpbrk (begin, delim);
983
984   if (end)
985     {
986       /* Terminate the token and set *STRINGP past NUL character.  */
987       *end++ = '\0';
988       *stringp = end;
989     }
990   else
991     /* No more delimiters; this is the last token.  */
992     *stringp = NULL;
993
994   return begin;
995 }
996 #endif /*HAVE_STRSEP*/
997
998
999 #ifndef HAVE_STRLWR
1000 char *
1001 strlwr(char *s)
1002 {
1003     char *p;
1004     for(p=s; *p; p++ )
1005         *p = tolower(*p);
1006     return s;
1007 }
1008 #endif
1009
1010
1011 #ifndef HAVE_STRCASECMP
1012 int
1013 strcasecmp( const char *a, const char *b )
1014 {
1015     for( ; *a && *b; a++, b++ ) {
1016         if( *a != *b && toupper(*a) != toupper(*b) )
1017             break;
1018     }
1019     return *(const byte*)a - *(const byte*)b;
1020 }
1021 #endif
1022
1023
1024 /****************
1025  * mingw32/cpd has a memicmp()
1026  */
1027 #ifndef HAVE_MEMICMP
1028 int
1029 memicmp( const char *a, const char *b, size_t n )
1030 {
1031     for( ; n; n--, a++, b++ )
1032         if( *a != *b  && toupper(*(const byte*)a) != toupper(*(const byte*)b) )
1033             return *(const byte *)a - *(const byte*)b;
1034     return 0;
1035 }
1036 #endif
1037
1038
1039 #ifndef HAVE_MEMRCHR
1040 void *
1041 memrchr (const void *buffer, int c, size_t n)
1042 {
1043   const unsigned char *p = buffer;
1044
1045   for (p += n; n ; n--)
1046     if (*--p == c)
1047       return (void *)p;
1048   return NULL;
1049 }
1050 #endif /*HAVE_MEMRCHR*/
1051
1052 \f
1053 /* Percent-escape the string STR by replacing colons with '%3a'.  If
1054    EXTRA is not NULL all characters in EXTRA are also escaped.  */
1055 static char *
1056 do_percent_escape (const char *str, const char *extra, int die)
1057 {
1058   int i, j;
1059   char *ptr;
1060
1061   if (!str)
1062     return NULL;
1063
1064   for (i=j=0; str[i]; i++)
1065     if (str[i] == ':' || str[i] == '%' || (extra && strchr (extra, str[i])))
1066       j++;
1067   if (die)
1068     ptr = xmalloc (i + 2 * j + 1);
1069   else
1070     {
1071       ptr = xtrymalloc (i + 2 * j + 1);
1072       if (!ptr)
1073         return NULL;
1074     }
1075   i = 0;
1076   while (*str)
1077     {
1078       if (*str == ':')
1079         {
1080           ptr[i++] = '%';
1081           ptr[i++] = '3';
1082           ptr[i++] = 'a';
1083         }
1084       else if (*str == '%')
1085         {
1086           ptr[i++] = '%';
1087           ptr[i++] = '2';
1088           ptr[i++] = '5';
1089         }
1090       else if (extra && strchr (extra, *str))
1091         {
1092           ptr[i++] = '%';
1093           ptr[i++] = tohex_lower ((*str>>4)&15);
1094           ptr[i++] = tohex_lower (*str&15);
1095         }
1096       else
1097         ptr[i++] = *str;
1098       str++;
1099     }
1100   ptr[i] = '\0';
1101
1102   return ptr;
1103 }
1104
1105 /* Percent-escape the string STR by replacing colons with '%3a'.  If
1106    EXTRA is not NULL all characters in EXTRA are also escaped.  This
1107    function terminates the process on memory shortage.  */
1108 char *
1109 percent_escape (const char *str, const char *extra)
1110 {
1111   return do_percent_escape (str, extra, 1);
1112 }
1113
1114 /* Same as percent_escape but return NULL instead of exiting on memory
1115    error. */
1116 char *
1117 try_percent_escape (const char *str, const char *extra)
1118 {
1119   return do_percent_escape (str, extra, 0);
1120 }
1121
1122
1123
1124 static char *
1125 do_strconcat (const char *s1, va_list arg_ptr)
1126 {
1127   const char *argv[48];
1128   size_t argc;
1129   size_t needed;
1130   char *buffer, *p;
1131
1132   argc = 0;
1133   argv[argc++] = s1;
1134   needed = strlen (s1);
1135   while (((argv[argc] = va_arg (arg_ptr, const char *))))
1136     {
1137       needed += strlen (argv[argc]);
1138       if (argc >= DIM (argv)-1)
1139         {
1140           gpg_err_set_errno (EINVAL);
1141           return NULL;
1142         }
1143       argc++;
1144     }
1145   needed++;
1146   buffer = xtrymalloc (needed);
1147   if (buffer)
1148     {
1149       for (p = buffer, argc=0; argv[argc]; argc++)
1150         p = stpcpy (p, argv[argc]);
1151     }
1152   return buffer;
1153 }
1154
1155
1156 /* Concatenate the string S1 with all the following strings up to a
1157    NULL.  Returns a malloced buffer with the new string or NULL on a
1158    malloc error or if too many arguments are given.  */
1159 char *
1160 strconcat (const char *s1, ...)
1161 {
1162   va_list arg_ptr;
1163   char *result;
1164
1165   if (!s1)
1166     result = xtrystrdup ("");
1167   else
1168     {
1169       va_start (arg_ptr, s1);
1170       result = do_strconcat (s1, arg_ptr);
1171       va_end (arg_ptr);
1172     }
1173   return result;
1174 }
1175
1176 /* Same as strconcat but terminate the process with an error message
1177    if something goes wrong.  */
1178 char *
1179 xstrconcat (const char *s1, ...)
1180 {
1181   va_list arg_ptr;
1182   char *result;
1183
1184   if (!s1)
1185     result = xstrdup ("");
1186   else
1187     {
1188       va_start (arg_ptr, s1);
1189       result = do_strconcat (s1, arg_ptr);
1190       va_end (arg_ptr);
1191     }
1192   if (!result)
1193     {
1194       if (errno == EINVAL)
1195         fputs ("\nfatal: too many args for xstrconcat\n", stderr);
1196       else
1197         fputs ("\nfatal: out of memory\n", stderr);
1198       exit (2);
1199     }
1200   return result;
1201 }
1202
1203 /* Split a string into fields at DELIM.  REPLACEMENT is the character
1204    to replace the delimiter with (normally: '\0' so that each field is
1205    NUL terminated).  The caller is responsible for freeing the result.
1206    Note: this function modifies STRING!  If you need the original
1207    value, then you should pass a copy to this function.
1208
1209    If malloc fails, this function returns NULL.  */
1210 char **
1211 strsplit (char *string, char delim, char replacement, int *count)
1212 {
1213   int fields = 1;
1214   char *t;
1215   char **result;
1216
1217   /* First, count the number of fields.  */
1218   for (t = strchr (string, delim); t; t = strchr (t + 1, delim))
1219     fields ++;
1220
1221   result = xtrycalloc (sizeof (*result), (fields + 1));
1222   if (! result)
1223     return NULL;
1224
1225   result[0] = string;
1226   fields = 1;
1227   for (t = strchr (string, delim); t; t = strchr (t + 1, delim))
1228     {
1229       result[fields ++] = t + 1;
1230       *t = replacement;
1231     }
1232
1233   if (count)
1234     *count = fields;
1235
1236   return result;
1237 }
1238
1239
1240 /* Tokenize STRING using the set of delimiters in DELIM.  Leading
1241  * spaces and tabs are removed from all tokens.  The caller must xfree
1242  * the result.
1243  *
1244  * Returns: A malloced and NULL delimited array with the tokens.  On
1245  *          memory error NULL is returned and ERRNO is set.
1246  */
1247 char **
1248 strtokenize (const char *string, const char *delim)
1249 {
1250   const char *s;
1251   size_t fields;
1252   size_t bytes, n;
1253   char *buffer;
1254   char *p, *px, *pend;
1255   char **result;
1256
1257   /* Count the number of fields.  */
1258   for (fields = 1, s = strpbrk (string, delim); s; s = strpbrk (s + 1, delim))
1259     fields++;
1260   fields++; /* Add one for the terminating NULL.  */
1261
1262   /* Allocate an array for all fields, a terminating NULL, and space
1263      for a copy of the string.  */
1264   bytes = fields * sizeof *result;
1265   if (bytes / sizeof *result != fields)
1266     {
1267       gpg_err_set_errno (ENOMEM);
1268       return NULL;
1269     }
1270   n = strlen (string) + 1;
1271   bytes += n;
1272   if (bytes < n)
1273     {
1274       gpg_err_set_errno (ENOMEM);
1275       return NULL;
1276     }
1277   result = xtrymalloc (bytes);
1278   if (!result)
1279     return NULL;
1280   buffer = (char*)(result + fields);
1281
1282   /* Copy and parse the string.  */
1283   strcpy (buffer, string);
1284   for (n = 0, p = buffer; (pend = strpbrk (p, delim)); p = pend + 1)
1285     {
1286       *pend = 0;
1287       while (spacep (p))
1288         p++;
1289       for (px = pend - 1; px >= p && spacep (px); px--)
1290         *px = 0;
1291       result[n++] = p;
1292     }
1293   while (spacep (p))
1294     p++;
1295   for (px = p + strlen (p) - 1; px >= p && spacep (px); px--)
1296     *px = 0;
1297   result[n++] = p;
1298   result[n] = NULL;
1299
1300   assert ((char*)(result + n + 1) == buffer);
1301
1302   return result;
1303 }