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 <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    If IN_PLACE is 0, then TEXT is copied to a new buffer, which is
1447    returned.  Otherwise, TEXT is modified in place and returned.
1448    Normally, target_cols will be 72 and max_cols is 80.  */
1449 char *
1450 format_text (char *text, int in_place, 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
1463   if (! in_place)
1464     text = xstrdup (text);
1465
1466   p = line = text;
1467   while (1)
1468     {
1469       /* The number of columns including any trailing space.  */
1470       int cols;
1471
1472       p = p + strcspn (p, "\n ");
1473       if (! p)
1474         /* P now points to the NUL character.  */
1475         p = &text[strlen (text)];
1476
1477       if (*p == '\n')
1478         /* Pass through any newlines.  */
1479         {
1480           p ++;
1481           line = p;
1482           last_space = NULL;
1483           last_space_cols = 0;
1484           copied_last_space = 1;
1485           continue;
1486         }
1487
1488       /* Have a space or a NUL.  Note: we don't count the trailing
1489          space.  */
1490       cols = utf8_charcount (line, (uintptr_t) p - (uintptr_t) line);
1491       if (cols < target_cols)
1492         {
1493           if (! *p)
1494             /* Nothing left to break.  */
1495             break;
1496
1497           last_space = p;
1498           last_space_cols = cols;
1499           p ++;
1500           /* Skip any immediately following spaces.  If we break:
1501              "... foo bar ..." between "foo" and "bar" then we want:
1502              "... foo\nbar ...", which means that the left space has
1503              to be the first space after foo, not the last space
1504              before bar.  */
1505           while (*p == ' ')
1506             p ++;
1507         }
1508       else
1509         {
1510           int cols_with_left_space;
1511           int cols_with_right_space;
1512           int left_penalty;
1513           int right_penalty;
1514
1515           cols_with_left_space = last_space_cols;
1516           cols_with_right_space = cols;
1517
1518           if (do_debug)
1519             log_debug ("Breaking: '%.*s'\n",
1520                        (int) ((uintptr_t) p - (uintptr_t) line), line);
1521
1522           /* The number of columns away from TARGET_COLS.  We prefer
1523              to underflow than to overflow.  */
1524           left_penalty = target_cols - cols_with_left_space;
1525           right_penalty = 2 * (cols_with_right_space - target_cols);
1526
1527           if (cols_with_right_space > max_cols)
1528             /* Add a large penalty for each column that exceeds
1529                max_cols.  */
1530             right_penalty += 4 * (cols_with_right_space - max_cols);
1531
1532           if (do_debug)
1533             log_debug ("Left space => %d cols (penalty: %d); right space => %d cols (penalty: %d)\n",
1534                        cols_with_left_space, left_penalty,
1535                        cols_with_right_space, right_penalty);
1536           if (last_space_cols && left_penalty <= right_penalty)
1537             /* Prefer the left space.  */
1538             {
1539               if (do_debug)
1540                 log_debug ("Breaking at left space.\n");
1541               p = last_space;
1542             }
1543           else
1544             {
1545               if (do_debug)
1546                 log_debug ("Breaking at right space.\n");
1547             }
1548
1549           if (! *p)
1550             break;
1551
1552           *p = '\n';
1553           p ++;
1554           if (*p == ' ')
1555             {
1556               int spaces;
1557               for (spaces = 1; p[spaces] == ' '; spaces ++)
1558                 ;
1559               memmove (p, &p[spaces], strlen (&p[spaces]) + 1);
1560             }
1561           line = p;
1562           last_space = NULL;
1563           last_space_cols = 0;
1564           copied_last_space = 0;
1565         }
1566     }
1567
1568   /* Chop off any trailing space.  */
1569   trim_trailing_chars (text, strlen (text), " ");
1570   /* If we inserted the trailing newline, then remove it.  */
1571   if (! copied_last_space && *text && text[strlen (text) - 1] == '\n')
1572     text[strlen (text) - 1] = '\0';
1573
1574   return text;
1575 }