common: Let format_text return an error.
[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 and/or modify this
10  * part of GnuPG 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 <https://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 #include <limits.h>
53
54 #include "util.h"
55 #include "common-defs.h"
56 #include "utf8conv.h"
57 #include "sysutils.h"
58 #include "stringhelp.h"
59
60 #define tohex_lower(n) ((n) < 10 ? ((n) + '0') : (((n) - 10) + 'a'))
61
62
63 /* Sometimes we want to avoid mixing slashes and backslashes on W32
64    and prefer backslashes.  There is usual no problem with mixing
65    them, however a very few W32 API calls can't grok plain slashes.
66    Printing filenames with mixed slashes also looks a bit strange.
67    This function has no effext on POSIX. */
68 static inline char *
69 change_slashes (char *name)
70 {
71 #ifdef HAVE_DOSISH_SYSTEM
72   char *p;
73
74   if (strchr (name, '\\'))
75     {
76       for (p=name; *p; p++)
77         if (*p == '/')
78           *p = '\\';
79     }
80 #endif /*HAVE_DOSISH_SYSTEM*/
81   return name;
82 }
83
84
85 /*
86  * Check whether STRING starts with KEYWORD.  The keyword is
87  * delimited by end of string, a space or a tab.  Returns NULL if not
88  * found or a pointer into STRING to the next non-space character
89  * after the KEYWORD (which may be end of string).
90  */
91 char *
92 has_leading_keyword (const char *string, const char *keyword)
93 {
94   size_t n = strlen (keyword);
95
96   if (!strncmp (string, keyword, n)
97       && (!string[n] || string[n] == ' ' || string[n] == '\t'))
98     {
99       string += n;
100       while (*string == ' ' || *string == '\t')
101         string++;
102       return (char*)string;
103     }
104   return NULL;
105 }
106
107
108 /*
109  * Look for the substring SUB in buffer and return a pointer to that
110  * substring in BUFFER or NULL if not found.
111  * Comparison is case-insensitive.
112  */
113 const char *
114 memistr (const void *buffer, size_t buflen, const char *sub)
115 {
116   const unsigned char *buf = buffer;
117   const unsigned char *t = (const unsigned char *)buffer;
118   const unsigned char *s = (const unsigned char *)sub;
119   size_t n = buflen;
120
121   for ( ; n ; t++, n-- )
122     {
123       if ( toupper (*t) == toupper (*s) )
124         {
125           for ( buf=t++, buflen = n--, s++;
126                 n && toupper (*t) == toupper (*s); t++, s++, n-- )
127             ;
128           if (!*s)
129             return (const char*)buf;
130           t = buf;
131           s = (const unsigned char *)sub ;
132           n = buflen;
133         }
134     }
135   return NULL;
136 }
137
138 const char *
139 ascii_memistr ( const void *buffer, size_t buflen, const char *sub )
140 {
141   const unsigned char *buf = buffer;
142   const unsigned char *t = (const unsigned char *)buf;
143   const unsigned char *s = (const unsigned char *)sub;
144   size_t n = buflen;
145
146   for ( ; n ; t++, n-- )
147     {
148       if (ascii_toupper (*t) == ascii_toupper (*s) )
149         {
150           for ( buf=t++, buflen = n--, s++;
151                 n && ascii_toupper (*t) == ascii_toupper (*s); t++, s++, n-- )
152             ;
153           if (!*s)
154             return (const char*)buf;
155           t = (const unsigned char *)buf;
156           s = (const unsigned char *)sub ;
157           n = buflen;
158         }
159     }
160   return NULL;
161 }
162
163 /* This function is similar to strncpy().  However it won't copy more
164    than N - 1 characters and makes sure that a '\0' is appended. With
165    N given as 0, nothing will happen.  With DEST given as NULL, memory
166    will be allocated using xmalloc (i.e. if it runs out of core
167    the function terminates).  Returns DES or a pointer to the
168    allocated memory.
169  */
170 char *
171 mem2str( char *dest , const void *src , size_t n )
172 {
173     char *d;
174     const char *s;
175
176     if( n ) {
177         if( !dest )
178             dest = xmalloc( n ) ;
179         d = dest;
180         s = src ;
181         for(n--; n && *s; n-- )
182             *d++ = *s++;
183         *d = '\0' ;
184     }
185
186     return dest ;
187 }
188
189
190 /****************
191  * remove leading and trailing white spaces
192  */
193 char *
194 trim_spaces( char *str )
195 {
196     char *string, *p, *mark;
197
198     string = str;
199     /* find first non space character */
200     for( p=string; *p && isspace( *(byte*)p ) ; p++ )
201         ;
202     /* move characters */
203     for( (mark = NULL); (*string = *p); string++, p++ )
204         if( isspace( *(byte*)p ) ) {
205             if( !mark )
206                 mark = string ;
207         }
208         else
209             mark = NULL ;
210     if( mark )
211         *mark = '\0' ;  /* remove trailing spaces */
212
213     return str ;
214 }
215
216 /****************
217  * remove trailing white spaces
218  */
219 char *
220 trim_trailing_spaces( char *string )
221 {
222     char *p, *mark;
223
224     for( mark = NULL, p = string; *p; p++ ) {
225         if( isspace( *(byte*)p ) ) {
226             if( !mark )
227                 mark = p;
228         }
229         else
230             mark = NULL;
231     }
232     if( mark )
233         *mark = '\0' ;
234
235     return string ;
236 }
237
238
239 unsigned
240 trim_trailing_chars( byte *line, unsigned len, const char *trimchars )
241 {
242     byte *p, *mark;
243     unsigned n;
244
245     for(mark=NULL, p=line, n=0; n < len; n++, p++ ) {
246         if( strchr(trimchars, *p ) ) {
247             if( !mark )
248                 mark = p;
249         }
250         else
251             mark = NULL;
252     }
253
254     if( mark ) {
255         *mark = 0;
256         return mark - line;
257     }
258     return len;
259 }
260
261 /****************
262  * remove trailing white spaces and return the length of the buffer
263  */
264 unsigned
265 trim_trailing_ws( byte *line, unsigned len )
266 {
267     return trim_trailing_chars( line, len, " \t\r\n" );
268 }
269
270 size_t
271 length_sans_trailing_chars (const unsigned char *line, size_t len,
272                             const char *trimchars )
273 {
274   const unsigned char *p, *mark;
275   size_t n;
276
277   for( mark=NULL, p=line, n=0; n < len; n++, p++ )
278     {
279       if (strchr (trimchars, *p ))
280         {
281           if( !mark )
282             mark = p;
283         }
284       else
285         mark = NULL;
286     }
287
288   if (mark)
289     return mark - line;
290   return len;
291 }
292
293 /*
294  *  Return the length of line ignoring trailing white-space.
295  */
296 size_t
297 length_sans_trailing_ws (const unsigned char *line, size_t len)
298 {
299   return length_sans_trailing_chars (line, len, " \t\r\n");
300 }
301
302
303
304 /*
305  * Extract from a given path the filename component.  This function
306  * terminates the process on memory shortage.
307  */
308 char *
309 make_basename(const char *filepath, const char *inputpath)
310 {
311 #ifdef __riscos__
312     return riscos_make_basename(filepath, inputpath);
313 #else
314     char *p;
315
316     (void)inputpath; /* Only required for riscos.  */
317
318     if ( !(p=strrchr(filepath, '/')) )
319 #ifdef HAVE_DOSISH_SYSTEM
320         if ( !(p=strrchr(filepath, '\\')) )
321 #endif
322 #ifdef HAVE_DRIVE_LETTERS
323             if ( !(p=strrchr(filepath, ':')) )
324 #endif
325               {
326                 return xstrdup(filepath);
327               }
328
329     return xstrdup(p+1);
330 #endif
331 }
332
333
334
335 /*
336  * Extract from a given filename the path prepended to it.  If there
337  * isn't a path prepended to the filename, a dot is returned ('.').
338  * This function terminates the process on memory shortage.
339  */
340 char *
341 make_dirname(const char *filepath)
342 {
343     char *dirname;
344     int  dirname_length;
345     char *p;
346
347     if ( !(p=strrchr(filepath, '/')) )
348 #ifdef HAVE_DOSISH_SYSTEM
349         if ( !(p=strrchr(filepath, '\\')) )
350 #endif
351 #ifdef HAVE_DRIVE_LETTERS
352             if ( !(p=strrchr(filepath, ':')) )
353 #endif
354               {
355                 return xstrdup(".");
356               }
357
358     dirname_length = p-filepath;
359     dirname = xmalloc(dirname_length+1);
360     strncpy(dirname, filepath, dirname_length);
361     dirname[dirname_length] = 0;
362
363     return dirname;
364 }
365
366
367 \f
368 static char *
369 get_pwdir (int xmode, const char *name)
370 {
371   char *result = NULL;
372 #ifdef HAVE_PWD_H
373   struct passwd *pwd = NULL;
374
375   if (name)
376     {
377 #ifdef HAVE_GETPWNAM
378       /* Fixme: We should use getpwnam_r if available.  */
379       pwd = getpwnam (name);
380 #endif
381     }
382   else
383     {
384 #ifdef HAVE_GETPWUID
385       /* Fixme: We should use getpwuid_r if available.  */
386       pwd = getpwuid (getuid());
387 #endif
388     }
389   if (pwd)
390     {
391       if (xmode)
392         result = xstrdup (pwd->pw_dir);
393       else
394         result = xtrystrdup (pwd->pw_dir);
395     }
396 #else /*!HAVE_PWD_H*/
397   /* No support at all.  */
398   (void)xmode;
399   (void)name;
400 #endif /*HAVE_PWD_H*/
401   return result;
402 }
403
404
405 /* xmode 0 := Return NULL on error
406          1 := Terminate on error
407          2 := Make sure that name is absolute; return NULL on error
408          3 := Make sure that name is absolute; terminate on error
409  */
410 static char *
411 do_make_filename (int xmode, const char *first_part, va_list arg_ptr)
412 {
413   const char *argv[32];
414   int argc;
415   size_t n;
416   int skip = 1;
417   char *home_buffer = NULL;
418   char *name, *home, *p;
419   int want_abs;
420
421   want_abs = !!(xmode & 2);
422   xmode &= 1;
423
424   n = strlen (first_part) + 1;
425   argc = 0;
426   while ( (argv[argc] = va_arg (arg_ptr, const char *)) )
427     {
428       n += strlen (argv[argc]) + 1;
429       if (argc >= DIM (argv)-1)
430         {
431           if (xmode)
432             BUG ();
433           gpg_err_set_errno (EINVAL);
434           return NULL;
435         }
436       argc++;
437     }
438   n++;
439
440   home = NULL;
441   if (*first_part == '~')
442     {
443       if (first_part[1] == '/' || !first_part[1])
444         {
445           /* This is the "~/" or "~" case.  */
446           home = getenv("HOME");
447           if (!home)
448             home = home_buffer = get_pwdir (xmode, NULL);
449           if (home && *home)
450             n += strlen (home);
451         }
452       else
453         {
454           /* This is the "~username/" or "~username" case.  */
455           char *user;
456
457           if (xmode)
458             user = xstrdup (first_part+1);
459           else
460             {
461               user = xtrystrdup (first_part+1);
462               if (!user)
463                 return NULL;
464             }
465           p = strchr (user, '/');
466           if (p)
467             *p = 0;
468           skip = 1 + strlen (user);
469
470           home = home_buffer = get_pwdir (xmode, user);
471           xfree (user);
472           if (home)
473             n += strlen (home);
474           else
475             skip = 1;
476         }
477     }
478
479   if (xmode)
480     name = xmalloc (n);
481   else
482     {
483       name = xtrymalloc (n);
484       if (!name)
485         {
486           xfree (home_buffer);
487           return NULL;
488         }
489     }
490
491   if (home)
492     p = stpcpy (stpcpy (name, home), first_part + skip);
493   else
494     p = stpcpy (name, first_part);
495
496   xfree (home_buffer);
497   for (argc=0; argv[argc]; argc++)
498     {
499       /* Avoid a leading double slash if the first part was "/".  */
500       if (!argc && name[0] == '/' && !name[1])
501         p = stpcpy (p, argv[argc]);
502       else
503         p = stpcpy (stpcpy (p, "/"), argv[argc]);
504     }
505
506   if (want_abs)
507     {
508 #ifdef HAVE_DRIVE_LETTERS
509       p = strchr (name, ':');
510       if (p)
511         p++;
512       else
513         p = name;
514 #else
515       p = name;
516 #endif
517       if (*p != '/'
518 #ifdef HAVE_DRIVE_LETTERS
519           && *p != '\\'
520 #endif
521           )
522         {
523           home = gnupg_getcwd ();
524           if (!home)
525             {
526               if (xmode)
527                 {
528                   fprintf (stderr, "\nfatal: getcwd failed: %s\n",
529                            strerror (errno));
530                   exit(2);
531                 }
532               xfree (name);
533               return NULL;
534             }
535           n = strlen (home) + 1 + strlen (name) + 1;
536           if (xmode)
537             home_buffer = xmalloc (n);
538           else
539             {
540               home_buffer = xtrymalloc (n);
541               if (!home_buffer)
542                 {
543                   xfree (home);
544                   xfree (name);
545                   return NULL;
546                 }
547             }
548           if (p == name)
549             p = home_buffer;
550           else /* Windows case.  */
551             {
552               memcpy (home_buffer, p, p - name + 1);
553               p = home_buffer + (p - name + 1);
554             }
555
556           /* Avoid a leading double slash if the cwd is "/".  */
557           if (home[0] == '/' && !home[1])
558             strcpy (stpcpy (p, "/"), name);
559           else
560             strcpy (stpcpy (stpcpy (p, home), "/"), name);
561
562           xfree (home);
563           xfree (name);
564           name = home_buffer;
565           /* Let's do a simple compression to catch the most common
566              case of using "." for gpg's --homedir option.  */
567           n = strlen (name);
568           if (n > 2 && name[n-2] == '/' && name[n-1] == '.')
569             name[n-2] = 0;
570         }
571     }
572   return change_slashes (name);
573 }
574
575 /* Construct a filename from the NULL terminated list of parts.  Tilde
576    expansion is done for the first argument.  This function terminates
577    the process on memory shortage. */
578 char *
579 make_filename (const char *first_part, ... )
580 {
581   va_list arg_ptr;
582   char *result;
583
584   va_start (arg_ptr, first_part);
585   result = do_make_filename (1, first_part, arg_ptr);
586   va_end (arg_ptr);
587   return result;
588 }
589
590 /* Construct a filename from the NULL terminated list of parts.  Tilde
591    expansion is done for the first argument.  This function may return
592    NULL on error. */
593 char *
594 make_filename_try (const char *first_part, ... )
595 {
596   va_list arg_ptr;
597   char *result;
598
599   va_start (arg_ptr, first_part);
600   result = do_make_filename (0, first_part, arg_ptr);
601   va_end (arg_ptr);
602   return result;
603 }
604
605 /* Construct an absolute filename from the NULL terminated list of
606    parts.  Tilde expansion is done for the first argument.  This
607    function terminates the process on memory shortage. */
608 char *
609 make_absfilename (const char *first_part, ... )
610 {
611   va_list arg_ptr;
612   char *result;
613
614   va_start (arg_ptr, first_part);
615   result = do_make_filename (3, first_part, arg_ptr);
616   va_end (arg_ptr);
617   return result;
618 }
619
620 /* Construct an absolute filename from the NULL terminated list of
621    parts.  Tilde expansion is done for the first argument.  This
622    function may return NULL on error. */
623 char *
624 make_absfilename_try (const char *first_part, ... )
625 {
626   va_list arg_ptr;
627   char *result;
628
629   va_start (arg_ptr, first_part);
630   result = do_make_filename (2, first_part, arg_ptr);
631   va_end (arg_ptr);
632   return result;
633 }
634
635
636 \f
637 /* Compare whether the filenames are identical.  This is a
638    special version of strcmp() taking the semantics of filenames in
639    account.  Note that this function works only on the supplied names
640    without considering any context like the current directory.  See
641    also same_file_p(). */
642 int
643 compare_filenames (const char *a, const char *b)
644 {
645 #ifdef HAVE_DOSISH_SYSTEM
646   for ( ; *a && *b; a++, b++ )
647     {
648       if (*a != *b
649           && (toupper (*(const unsigned char*)a)
650               != toupper (*(const unsigned char*)b) )
651           && !((*a == '/' && *b == '\\') || (*a == '\\' && *b == '/')))
652         break;
653     }
654   if ((*a == '/' && *b == '\\') || (*a == '\\' && *b == '/'))
655     return 0;
656   else
657     return (toupper (*(const unsigned char*)a)
658             - toupper (*(const unsigned char*)b));
659 #else
660     return strcmp(a,b);
661 #endif
662 }
663
664
665 /* Convert a base-10 number in STRING into a 64 bit unsigned int
666  * value.  Leading white spaces are skipped but no error checking is
667  * done.  Thus it is similar to atoi(). */
668 uint64_t
669 string_to_u64 (const char *string)
670 {
671   uint64_t val = 0;
672
673   while (spacep (string))
674     string++;
675   for (; digitp (string); string++)
676     {
677       val *= 10;
678       val += *string - '0';
679     }
680   return val;
681 }
682
683
684 /* Convert 2 hex characters at S to a byte value.  Return this value
685    or -1 if there is an error. */
686 int
687 hextobyte (const char *s)
688 {
689   int c;
690
691   if ( *s >= '0' && *s <= '9' )
692     c = 16 * (*s - '0');
693   else if ( *s >= 'A' && *s <= 'F' )
694     c = 16 * (10 + *s - 'A');
695   else if ( *s >= 'a' && *s <= 'f' )
696     c = 16 * (10 + *s - 'a');
697   else
698     return -1;
699   s++;
700   if ( *s >= '0' && *s <= '9' )
701     c += *s - '0';
702   else if ( *s >= 'A' && *s <= 'F' )
703     c += 10 + *s - 'A';
704   else if ( *s >= 'a' && *s <= 'f' )
705     c += 10 + *s - 'a';
706   else
707     return -1;
708   return c;
709 }
710
711 /* Given a string containing an UTF-8 encoded text, return the number
712    of characters in this string.  It differs from strlen in that it
713    only counts complete UTF-8 characters.  SIZE is the maximum length
714    of the string in bytes.  If SIZE is -1, then a NUL character is
715    taken to be the end of the string.  Note, that this function does
716    not take combined characters into account.  */
717 size_t
718 utf8_charcount (const char *s, int len)
719 {
720   size_t n;
721
722   if (len == 0)
723     return 0;
724
725   for (n=0; *s; s++)
726     {
727       if ( (*s&0xc0) != 0x80 ) /* Exclude continuation bytes: 10xxxxxx */
728         n++;
729
730       if (len != -1)
731         {
732           len --;
733           if (len == 0)
734             break;
735         }
736     }
737
738   return n;
739 }
740
741
742 /****************************************************
743  **********  W32 specific functions  ****************
744  ****************************************************/
745
746 #ifdef HAVE_W32_SYSTEM
747 const char *
748 w32_strerror (int ec)
749 {
750   static char strerr[256];
751
752   if (ec == -1)
753     ec = (int)GetLastError ();
754 #ifdef HAVE_W32CE_SYSTEM
755   /* There is only a wchar_t FormatMessage.  It does not make much
756      sense to play the conversion game; we print only the code.  */
757   snprintf (strerr, sizeof strerr, "ec=%d", (int)GetLastError ());
758 #else
759   FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, NULL, ec,
760                  MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
761                  strerr, DIM (strerr)-1, NULL);
762 #endif
763   return strerr;
764 }
765 #endif /*HAVE_W32_SYSTEM*/
766
767
768 /****************************************************
769  ******** Locale insensitive ctype functions ********
770  ****************************************************/
771 /* FIXME: replace them by a table lookup and macros */
772 int
773 ascii_isupper (int c)
774 {
775     return c >= 'A' && c <= 'Z';
776 }
777
778 int
779 ascii_islower (int c)
780 {
781     return c >= 'a' && c <= 'z';
782 }
783
784 int
785 ascii_toupper (int c)
786 {
787     if (c >= 'a' && c <= 'z')
788         c &= ~0x20;
789     return c;
790 }
791
792 int
793 ascii_tolower (int c)
794 {
795     if (c >= 'A' && c <= 'Z')
796         c |= 0x20;
797     return c;
798 }
799
800 /* Lowercase all ASCII characters in S.  */
801 char *
802 ascii_strlwr (char *s)
803 {
804   char *p = s;
805
806   for (p=s; *p; p++ )
807     if (isascii (*p) && *p >= 'A' && *p <= 'Z')
808       *p |= 0x20;
809
810   return s;
811 }
812
813 int
814 ascii_strcasecmp( const char *a, const char *b )
815 {
816     if (a == b)
817         return 0;
818
819     for (; *a && *b; a++, b++) {
820         if (*a != *b && ascii_toupper(*a) != ascii_toupper(*b))
821             break;
822     }
823     return *a == *b? 0 : (ascii_toupper (*a) - ascii_toupper (*b));
824 }
825
826 int
827 ascii_strncasecmp (const char *a, const char *b, size_t n)
828 {
829   const unsigned char *p1 = (const unsigned char *)a;
830   const unsigned char *p2 = (const unsigned char *)b;
831   unsigned char c1, c2;
832
833   if (p1 == p2 || !n )
834     return 0;
835
836   do
837     {
838       c1 = ascii_tolower (*p1);
839       c2 = ascii_tolower (*p2);
840
841       if ( !--n || c1 == '\0')
842         break;
843
844       ++p1;
845       ++p2;
846     }
847   while (c1 == c2);
848
849   return c1 - c2;
850 }
851
852
853 int
854 ascii_memcasecmp (const void *a_arg, const void *b_arg, size_t n )
855 {
856   const char *a = a_arg;
857   const char *b = b_arg;
858
859   if (a == b)
860     return 0;
861   for ( ; n; n--, a++, b++ )
862     {
863       if( *a != *b  && ascii_toupper (*a) != ascii_toupper (*b) )
864         return *a == *b? 0 : (ascii_toupper (*a) - ascii_toupper (*b));
865     }
866   return 0;
867 }
868
869 int
870 ascii_strcmp( const char *a, const char *b )
871 {
872     if (a == b)
873         return 0;
874
875     for (; *a && *b; a++, b++) {
876         if (*a != *b )
877             break;
878     }
879     return *a == *b? 0 : (*(signed char *)a - *(signed char *)b);
880 }
881
882
883 void *
884 ascii_memcasemem (const void *haystack, size_t nhaystack,
885                   const void *needle, size_t nneedle)
886 {
887
888   if (!nneedle)
889     return (void*)haystack; /* finding an empty needle is really easy */
890   if (nneedle <= nhaystack)
891     {
892       const char *a = haystack;
893       const char *b = a + nhaystack - nneedle;
894
895       for (; a <= b; a++)
896         {
897           if ( !ascii_memcasecmp (a, needle, nneedle) )
898             return (void *)a;
899         }
900     }
901   return NULL;
902 }
903
904 /*********************************************
905  ********** missing string functions *********
906  *********************************************/
907
908 #ifndef HAVE_STPCPY
909 char *
910 stpcpy(char *a,const char *b)
911 {
912     while( *b )
913         *a++ = *b++;
914     *a = 0;
915
916     return (char*)a;
917 }
918 #endif
919
920 #ifndef HAVE_STRPBRK
921 /* Find the first occurrence in S of any character in ACCEPT.
922    Code taken from glibc-2.6/string/strpbrk.c (LGPLv2.1+) and modified. */
923 char *
924 strpbrk (const char *s, const char *accept)
925 {
926   while (*s != '\0')
927     {
928       const char *a = accept;
929       while (*a != '\0')
930         if (*a++ == *s)
931           return (char *) s;
932       ++s;
933     }
934
935   return NULL;
936 }
937 #endif /*!HAVE_STRPBRK*/
938
939
940 #ifndef HAVE_STRSEP
941 /* Code taken from glibc-2.2.1/sysdeps/generic/strsep.c. */
942 char *
943 strsep (char **stringp, const char *delim)
944 {
945   char *begin, *end;
946
947   begin = *stringp;
948   if (begin == NULL)
949     return NULL;
950
951   /* A frequent case is when the delimiter string contains only one
952      character.  Here we don't need to call the expensive 'strpbrk'
953      function and instead work using 'strchr'.  */
954   if (delim[0] == '\0' || delim[1] == '\0')
955     {
956       char ch = delim[0];
957
958       if (ch == '\0')
959         end = NULL;
960       else
961         {
962           if (*begin == ch)
963             end = begin;
964           else if (*begin == '\0')
965             end = NULL;
966           else
967             end = strchr (begin + 1, ch);
968         }
969     }
970   else
971     /* Find the end of the token.  */
972     end = strpbrk (begin, delim);
973
974   if (end)
975     {
976       /* Terminate the token and set *STRINGP past NUL character.  */
977       *end++ = '\0';
978       *stringp = end;
979     }
980   else
981     /* No more delimiters; this is the last token.  */
982     *stringp = NULL;
983
984   return begin;
985 }
986 #endif /*HAVE_STRSEP*/
987
988
989 #ifndef HAVE_STRLWR
990 char *
991 strlwr(char *s)
992 {
993     char *p;
994     for(p=s; *p; p++ )
995         *p = tolower(*p);
996     return s;
997 }
998 #endif
999
1000
1001 #ifndef HAVE_STRCASECMP
1002 int
1003 strcasecmp( const char *a, const char *b )
1004 {
1005     for( ; *a && *b; a++, b++ ) {
1006         if( *a != *b && toupper(*a) != toupper(*b) )
1007             break;
1008     }
1009     return *(const byte*)a - *(const byte*)b;
1010 }
1011 #endif
1012
1013
1014 /****************
1015  * mingw32/cpd has a memicmp()
1016  */
1017 #ifndef HAVE_MEMICMP
1018 int
1019 memicmp( const char *a, const char *b, size_t n )
1020 {
1021     for( ; n; n--, a++, b++ )
1022         if( *a != *b  && toupper(*(const byte*)a) != toupper(*(const byte*)b) )
1023             return *(const byte *)a - *(const byte*)b;
1024     return 0;
1025 }
1026 #endif
1027
1028
1029 #ifndef HAVE_MEMRCHR
1030 void *
1031 memrchr (const void *buffer, int c, size_t n)
1032 {
1033   const unsigned char *p = buffer;
1034
1035   for (p += n; n ; n--)
1036     if (*--p == c)
1037       return (void *)p;
1038   return NULL;
1039 }
1040 #endif /*HAVE_MEMRCHR*/
1041
1042 \f
1043 /* Percent-escape the string STR by replacing colons with '%3a'.  If
1044    EXTRA is not NULL all characters in EXTRA are also escaped.  */
1045 static char *
1046 do_percent_escape (const char *str, const char *extra, int die)
1047 {
1048   int i, j;
1049   char *ptr;
1050
1051   if (!str)
1052     return NULL;
1053
1054   for (i=j=0; str[i]; i++)
1055     if (str[i] == ':' || str[i] == '%' || str[i] == '\n'
1056         || (extra && strchr (extra, str[i])))
1057       j++;
1058   if (die)
1059     ptr = xmalloc (i + 2 * j + 1);
1060   else
1061     {
1062       ptr = xtrymalloc (i + 2 * j + 1);
1063       if (!ptr)
1064         return NULL;
1065     }
1066   i = 0;
1067   while (*str)
1068     {
1069       if (*str == ':')
1070         {
1071           ptr[i++] = '%';
1072           ptr[i++] = '3';
1073           ptr[i++] = 'a';
1074         }
1075       else if (*str == '%')
1076         {
1077           ptr[i++] = '%';
1078           ptr[i++] = '2';
1079           ptr[i++] = '5';
1080         }
1081       else if (*str == '\n')
1082         {
1083           /* The newline is problematic in a line-based format.  */
1084           ptr[i++] = '%';
1085           ptr[i++] = '0';
1086           ptr[i++] = 'a';
1087         }
1088       else if (extra && strchr (extra, *str))
1089         {
1090           ptr[i++] = '%';
1091           ptr[i++] = tohex_lower ((*str>>4)&15);
1092           ptr[i++] = tohex_lower (*str&15);
1093         }
1094       else
1095         ptr[i++] = *str;
1096       str++;
1097     }
1098   ptr[i] = '\0';
1099
1100   return ptr;
1101 }
1102
1103 /* Percent-escape the string STR by replacing colons with '%3a'.  If
1104    EXTRA is not NULL all characters in EXTRA are also escaped.  This
1105    function terminates the process on memory shortage.  */
1106 char *
1107 percent_escape (const char *str, const char *extra)
1108 {
1109   return do_percent_escape (str, extra, 1);
1110 }
1111
1112 /* Same as percent_escape but return NULL instead of exiting on memory
1113    error. */
1114 char *
1115 try_percent_escape (const char *str, const char *extra)
1116 {
1117   return do_percent_escape (str, extra, 0);
1118 }
1119
1120
1121
1122 static char *
1123 do_strconcat (const char *s1, va_list arg_ptr)
1124 {
1125   const char *argv[48];
1126   size_t argc;
1127   size_t needed;
1128   char *buffer, *p;
1129
1130   argc = 0;
1131   argv[argc++] = s1;
1132   needed = strlen (s1);
1133   while (((argv[argc] = va_arg (arg_ptr, const char *))))
1134     {
1135       needed += strlen (argv[argc]);
1136       if (argc >= DIM (argv)-1)
1137         {
1138           gpg_err_set_errno (EINVAL);
1139           return NULL;
1140         }
1141       argc++;
1142     }
1143   needed++;
1144   buffer = xtrymalloc (needed);
1145   if (buffer)
1146     {
1147       for (p = buffer, argc=0; argv[argc]; argc++)
1148         p = stpcpy (p, argv[argc]);
1149     }
1150   return buffer;
1151 }
1152
1153
1154 /* Concatenate the string S1 with all the following strings up to a
1155    NULL.  Returns a malloced buffer with the new string or NULL on a
1156    malloc error or if too many arguments are given.  */
1157 char *
1158 strconcat (const char *s1, ...)
1159 {
1160   va_list arg_ptr;
1161   char *result;
1162
1163   if (!s1)
1164     result = xtrystrdup ("");
1165   else
1166     {
1167       va_start (arg_ptr, s1);
1168       result = do_strconcat (s1, arg_ptr);
1169       va_end (arg_ptr);
1170     }
1171   return result;
1172 }
1173
1174 /* Same as strconcat but terminate the process with an error message
1175    if something goes wrong.  */
1176 char *
1177 xstrconcat (const char *s1, ...)
1178 {
1179   va_list arg_ptr;
1180   char *result;
1181
1182   if (!s1)
1183     result = xstrdup ("");
1184   else
1185     {
1186       va_start (arg_ptr, s1);
1187       result = do_strconcat (s1, arg_ptr);
1188       va_end (arg_ptr);
1189     }
1190   if (!result)
1191     {
1192       if (errno == EINVAL)
1193         fputs ("\nfatal: too many args for xstrconcat\n", stderr);
1194       else
1195         fputs ("\nfatal: out of memory\n", stderr);
1196       exit (2);
1197     }
1198   return result;
1199 }
1200
1201 /* Split a string into fields at DELIM.  REPLACEMENT is the character
1202    to replace the delimiter with (normally: '\0' so that each field is
1203    NUL terminated).  The caller is responsible for freeing the result.
1204    Note: this function modifies STRING!  If you need the original
1205    value, then you should pass a copy to this function.
1206
1207    If malloc fails, this function returns NULL.  */
1208 char **
1209 strsplit (char *string, char delim, char replacement, int *count)
1210 {
1211   int fields = 1;
1212   char *t;
1213   char **result;
1214
1215   /* First, count the number of fields.  */
1216   for (t = strchr (string, delim); t; t = strchr (t + 1, delim))
1217     fields ++;
1218
1219   result = xtrycalloc ((fields + 1), sizeof (*result));
1220   if (! result)
1221     return NULL;
1222
1223   result[0] = string;
1224   fields = 1;
1225   for (t = strchr (string, delim); t; t = strchr (t + 1, delim))
1226     {
1227       result[fields ++] = t + 1;
1228       *t = replacement;
1229     }
1230
1231   if (count)
1232     *count = fields;
1233
1234   return result;
1235 }
1236
1237
1238 /* Tokenize STRING using the set of delimiters in DELIM.  Leading
1239  * spaces and tabs are removed from all tokens.  The caller must xfree
1240  * the result.
1241  *
1242  * Returns: A malloced and NULL delimited array with the tokens.  On
1243  *          memory error NULL is returned and ERRNO is set.
1244  */
1245 char **
1246 strtokenize (const char *string, const char *delim)
1247 {
1248   const char *s;
1249   size_t fields;
1250   size_t bytes, n;
1251   char *buffer;
1252   char *p, *px, *pend;
1253   char **result;
1254
1255   /* Count the number of fields.  */
1256   for (fields = 1, s = strpbrk (string, delim); s; s = strpbrk (s + 1, delim))
1257     fields++;
1258   fields++; /* Add one for the terminating NULL.  */
1259
1260   /* Allocate an array for all fields, a terminating NULL, and space
1261      for a copy of the string.  */
1262   bytes = fields * sizeof *result;
1263   if (bytes / sizeof *result != fields)
1264     {
1265       gpg_err_set_errno (ENOMEM);
1266       return NULL;
1267     }
1268   n = strlen (string) + 1;
1269   bytes += n;
1270   if (bytes < n)
1271     {
1272       gpg_err_set_errno (ENOMEM);
1273       return NULL;
1274     }
1275   result = xtrymalloc (bytes);
1276   if (!result)
1277     return NULL;
1278   buffer = (char*)(result + fields);
1279
1280   /* Copy and parse the string.  */
1281   strcpy (buffer, string);
1282   for (n = 0, p = buffer; (pend = strpbrk (p, delim)); p = pend + 1)
1283     {
1284       *pend = 0;
1285       while (spacep (p))
1286         p++;
1287       for (px = pend - 1; px >= p && spacep (px); px--)
1288         *px = 0;
1289       result[n++] = p;
1290     }
1291   while (spacep (p))
1292     p++;
1293   for (px = p + strlen (p) - 1; px >= p && spacep (px); px--)
1294     *px = 0;
1295   result[n++] = p;
1296   result[n] = NULL;
1297
1298   assert ((char*)(result + n + 1) == buffer);
1299
1300   return result;
1301 }
1302
1303
1304 /* Split a string into space delimited fields and remove leading and
1305  * trailing spaces from each field.  A pointer to each field is stored
1306  * in ARRAY.  Stop splitting at ARRAYSIZE fields.  The function
1307  * modifies STRING.  The number of parsed fields is returned.
1308  * Example:
1309  *
1310  *   char *fields[2];
1311  *   if (split_fields (string, fields, DIM (fields)) < 2)
1312  *     return  // Not enough args.
1313  *   foo (fields[0]);
1314  *   foo (fields[1]);
1315  */
1316 int
1317 split_fields (char *string, char **array, int arraysize)
1318 {
1319   int n = 0;
1320   char *p, *pend;
1321
1322   for (p = string; *p == ' '; p++)
1323     ;
1324   do
1325     {
1326       if (n == arraysize)
1327         break;
1328       array[n++] = p;
1329       pend = strchr (p, ' ');
1330       if (!pend)
1331         break;
1332       *pend++ = 0;
1333       for (p = pend; *p == ' '; p++)
1334         ;
1335     }
1336   while (*p);
1337
1338   return n;
1339 }
1340
1341
1342 \f
1343 /* Version number parsing.  */
1344
1345 /* This function parses the first portion of the version number S and
1346    stores it in *NUMBER.  On success, this function returns a pointer
1347    into S starting with the first character, which is not part of the
1348    initial number portion; on failure, NULL is returned.  */
1349 static const char*
1350 parse_version_number (const char *s, int *number)
1351 {
1352   int val = 0;
1353
1354   if (*s == '0' && digitp (s+1))
1355     return NULL;  /* Leading zeros are not allowed.  */
1356   for (; digitp (s); s++)
1357     {
1358       val *= 10;
1359       val += *s - '0';
1360     }
1361   *number = val;
1362   return val < 0 ? NULL : s;
1363 }
1364
1365
1366 /* This function breaks up the complete string-representation of the
1367    version number S, which is of the following struture: <major
1368    number>.<minor number>[.<micro number>]<patch level>.  The major,
1369    minor, and micro number components will be stored in *MAJOR, *MINOR
1370    and *MICRO.  If MICRO is not given 0 is used instead.
1371
1372    On success, the last component, the patch level, will be returned;
1373    in failure, NULL will be returned.  */
1374 static const char *
1375 parse_version_string (const char *s, int *major, int *minor, int *micro)
1376 {
1377   s = parse_version_number (s, major);
1378   if (!s || *s != '.')
1379     return NULL;
1380   s++;
1381   s = parse_version_number (s, minor);
1382   if (!s)
1383     return NULL;
1384   if (*s == '.')
1385     {
1386       s++;
1387       s = parse_version_number (s, micro);
1388       if (!s)
1389         return NULL;
1390     }
1391   else
1392     *micro = 0;
1393   return s;  /* Patchlevel.  */
1394 }
1395
1396
1397 /* Compare the version string MY_VERSION to the version string
1398  * REQ_VERSION.  Returns -1, 0, or 1 if MY_VERSION is found,
1399  * respectively, to be less than, to match, or be greater than
1400  * REQ_VERSION.  This function works for three and two part version
1401  * strings; for a two part version string the micro part is assumed to
1402  * be 0.  Patch levels are compared as strings.  If a version number
1403  * is invalid INT_MIN is returned.  If REQ_VERSION is given as NULL
1404  * the function returns 0 if MY_VERSION is parsable version string. */
1405 int
1406 compare_version_strings (const char *my_version, const char *req_version)
1407 {
1408   int my_major, my_minor, my_micro;
1409   int rq_major, rq_minor, rq_micro;
1410   const char *my_patch, *rq_patch;
1411   int result;
1412
1413   if (!my_version)
1414     return INT_MIN;
1415
1416   my_patch = parse_version_string (my_version, &my_major, &my_minor, &my_micro);
1417   if (!my_patch)
1418     return INT_MIN;
1419   if (!req_version)
1420     return 0; /* MY_VERSION can be parsed.  */
1421   rq_patch = parse_version_string (req_version, &rq_major, &rq_minor,&rq_micro);
1422   if (!rq_patch)
1423     return INT_MIN;
1424
1425   if (my_major == rq_major)
1426     {
1427       if (my_minor == rq_minor)
1428         {
1429           if (my_micro == rq_micro)
1430             result = strcmp (my_patch, rq_patch);
1431           else
1432             result = my_micro - rq_micro;
1433         }
1434       else
1435         result = my_minor - rq_minor;
1436     }
1437   else
1438     result = my_major - rq_major;
1439
1440   return !result? 0 : result < 0 ? -1 : 1;
1441 }
1442
1443
1444 \f
1445 /* Format a string so that it fits within about TARGET_COLS columns.
1446  * TEXT_IN is copied to a new buffer, which is returned.  Normally,
1447  * target_cols will be 72 and max_cols is 80.  On error NULL is
1448  * returned and ERRNO is set. */
1449 char *
1450 format_text (const char *text_in, int target_cols, int max_cols)
1451 {
1452   /* const int do_debug = 0; */
1453
1454   /* The character under consideration.  */
1455   char *p;
1456   /* The start of the current line.  */
1457   char *line;
1458   /* The last space that we saw.  */
1459   char *last_space = NULL;
1460   int last_space_cols = 0;
1461   int copied_last_space = 0;
1462   char *text;
1463
1464   text = xtrystrdup (text_in);
1465   if (!text)
1466     return NULL;
1467
1468   p = line = text;
1469   while (1)
1470     {
1471       /* The number of columns including any trailing space.  */
1472       int cols;
1473
1474       p = p + strcspn (p, "\n ");
1475       if (! p)
1476         /* P now points to the NUL character.  */
1477         p = &text[strlen (text)];
1478
1479       if (*p == '\n')
1480         /* Pass through any newlines.  */
1481         {
1482           p ++;
1483           line = p;
1484           last_space = NULL;
1485           last_space_cols = 0;
1486           copied_last_space = 1;
1487           continue;
1488         }
1489
1490       /* Have a space or a NUL.  Note: we don't count the trailing
1491          space.  */
1492       cols = utf8_charcount (line, (uintptr_t) p - (uintptr_t) line);
1493       if (cols < target_cols)
1494         {
1495           if (! *p)
1496             /* Nothing left to break.  */
1497             break;
1498
1499           last_space = p;
1500           last_space_cols = cols;
1501           p ++;
1502           /* Skip any immediately following spaces.  If we break:
1503              "... foo bar ..." between "foo" and "bar" then we want:
1504              "... foo\nbar ...", which means that the left space has
1505              to be the first space after foo, not the last space
1506              before bar.  */
1507           while (*p == ' ')
1508             p ++;
1509         }
1510       else
1511         {
1512           int cols_with_left_space;
1513           int cols_with_right_space;
1514           int left_penalty;
1515           int right_penalty;
1516
1517           cols_with_left_space = last_space_cols;
1518           cols_with_right_space = cols;
1519
1520           /* if (do_debug) */
1521           /*   log_debug ("Breaking: '%.*s'\n", */
1522           /*              (int) ((uintptr_t) p - (uintptr_t) line), line); */
1523
1524           /* The number of columns away from TARGET_COLS.  We prefer
1525              to underflow than to overflow.  */
1526           left_penalty = target_cols - cols_with_left_space;
1527           right_penalty = 2 * (cols_with_right_space - target_cols);
1528
1529           if (cols_with_right_space > max_cols)
1530             /* Add a large penalty for each column that exceeds
1531                max_cols.  */
1532             right_penalty += 4 * (cols_with_right_space - max_cols);
1533
1534           /* if (do_debug) */
1535           /*   log_debug ("Left space => %d cols (penalty: %d); " */
1536           /*              "right space => %d cols (penalty: %d)\n", */
1537           /*              cols_with_left_space, left_penalty, */
1538           /*              cols_with_right_space, right_penalty); */
1539           if (last_space_cols && left_penalty <= right_penalty)
1540             {
1541               /* Prefer the left space.  */
1542               /* if (do_debug) */
1543               /*   log_debug ("Breaking at left space.\n"); */
1544               p = last_space;
1545             }
1546           else
1547             {
1548               /* if (do_debug) */
1549               /*   log_debug ("Breaking at right space.\n"); */
1550             }
1551
1552           if (! *p)
1553             break;
1554
1555           *p = '\n';
1556           p ++;
1557           if (*p == ' ')
1558             {
1559               int spaces;
1560               for (spaces = 1; p[spaces] == ' '; spaces ++)
1561                 ;
1562               memmove (p, &p[spaces], strlen (&p[spaces]) + 1);
1563             }
1564           line = p;
1565           last_space = NULL;
1566           last_space_cols = 0;
1567           copied_last_space = 0;
1568         }
1569     }
1570
1571   /* Chop off any trailing space.  */
1572   trim_trailing_chars (text, strlen (text), " ");
1573   /* If we inserted the trailing newline, then remove it.  */
1574   if (! copied_last_space && *text && text[strlen (text) - 1] == '\n')
1575     text[strlen (text) - 1] = '\0';
1576
1577   return text;
1578 }