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] == '%' || (extra && strchr (extra, str[i])))
1056       j++;
1057   if (die)
1058     ptr = xmalloc (i + 2 * j + 1);
1059   else
1060     {
1061       ptr = xtrymalloc (i + 2 * j + 1);
1062       if (!ptr)
1063         return NULL;
1064     }
1065   i = 0;
1066   while (*str)
1067     {
1068       if (*str == ':')
1069         {
1070           ptr[i++] = '%';
1071           ptr[i++] = '3';
1072           ptr[i++] = 'a';
1073         }
1074       else if (*str == '%')
1075         {
1076           ptr[i++] = '%';
1077           ptr[i++] = '2';
1078           ptr[i++] = '5';
1079         }
1080       else if (extra && strchr (extra, *str))
1081         {
1082           ptr[i++] = '%';
1083           ptr[i++] = tohex_lower ((*str>>4)&15);
1084           ptr[i++] = tohex_lower (*str&15);
1085         }
1086       else
1087         ptr[i++] = *str;
1088       str++;
1089     }
1090   ptr[i] = '\0';
1091
1092   return ptr;
1093 }
1094
1095 /* Percent-escape the string STR by replacing colons with '%3a'.  If
1096    EXTRA is not NULL all characters in EXTRA are also escaped.  This
1097    function terminates the process on memory shortage.  */
1098 char *
1099 percent_escape (const char *str, const char *extra)
1100 {
1101   return do_percent_escape (str, extra, 1);
1102 }
1103
1104 /* Same as percent_escape but return NULL instead of exiting on memory
1105    error. */
1106 char *
1107 try_percent_escape (const char *str, const char *extra)
1108 {
1109   return do_percent_escape (str, extra, 0);
1110 }
1111
1112
1113
1114 static char *
1115 do_strconcat (const char *s1, va_list arg_ptr)
1116 {
1117   const char *argv[48];
1118   size_t argc;
1119   size_t needed;
1120   char *buffer, *p;
1121
1122   argc = 0;
1123   argv[argc++] = s1;
1124   needed = strlen (s1);
1125   while (((argv[argc] = va_arg (arg_ptr, const char *))))
1126     {
1127       needed += strlen (argv[argc]);
1128       if (argc >= DIM (argv)-1)
1129         {
1130           gpg_err_set_errno (EINVAL);
1131           return NULL;
1132         }
1133       argc++;
1134     }
1135   needed++;
1136   buffer = xtrymalloc (needed);
1137   if (buffer)
1138     {
1139       for (p = buffer, argc=0; argv[argc]; argc++)
1140         p = stpcpy (p, argv[argc]);
1141     }
1142   return buffer;
1143 }
1144
1145
1146 /* Concatenate the string S1 with all the following strings up to a
1147    NULL.  Returns a malloced buffer with the new string or NULL on a
1148    malloc error or if too many arguments are given.  */
1149 char *
1150 strconcat (const char *s1, ...)
1151 {
1152   va_list arg_ptr;
1153   char *result;
1154
1155   if (!s1)
1156     result = xtrystrdup ("");
1157   else
1158     {
1159       va_start (arg_ptr, s1);
1160       result = do_strconcat (s1, arg_ptr);
1161       va_end (arg_ptr);
1162     }
1163   return result;
1164 }
1165
1166 /* Same as strconcat but terminate the process with an error message
1167    if something goes wrong.  */
1168 char *
1169 xstrconcat (const char *s1, ...)
1170 {
1171   va_list arg_ptr;
1172   char *result;
1173
1174   if (!s1)
1175     result = xstrdup ("");
1176   else
1177     {
1178       va_start (arg_ptr, s1);
1179       result = do_strconcat (s1, arg_ptr);
1180       va_end (arg_ptr);
1181     }
1182   if (!result)
1183     {
1184       if (errno == EINVAL)
1185         fputs ("\nfatal: too many args for xstrconcat\n", stderr);
1186       else
1187         fputs ("\nfatal: out of memory\n", stderr);
1188       exit (2);
1189     }
1190   return result;
1191 }
1192
1193 /* Split a string into fields at DELIM.  REPLACEMENT is the character
1194    to replace the delimiter with (normally: '\0' so that each field is
1195    NUL terminated).  The caller is responsible for freeing the result.
1196    Note: this function modifies STRING!  If you need the original
1197    value, then you should pass a copy to this function.
1198
1199    If malloc fails, this function returns NULL.  */
1200 char **
1201 strsplit (char *string, char delim, char replacement, int *count)
1202 {
1203   int fields = 1;
1204   char *t;
1205   char **result;
1206
1207   /* First, count the number of fields.  */
1208   for (t = strchr (string, delim); t; t = strchr (t + 1, delim))
1209     fields ++;
1210
1211   result = xtrycalloc ((fields + 1), sizeof (*result));
1212   if (! result)
1213     return NULL;
1214
1215   result[0] = string;
1216   fields = 1;
1217   for (t = strchr (string, delim); t; t = strchr (t + 1, delim))
1218     {
1219       result[fields ++] = t + 1;
1220       *t = replacement;
1221     }
1222
1223   if (count)
1224     *count = fields;
1225
1226   return result;
1227 }
1228
1229
1230 /* Tokenize STRING using the set of delimiters in DELIM.  Leading
1231  * spaces and tabs are removed from all tokens.  The caller must xfree
1232  * the result.
1233  *
1234  * Returns: A malloced and NULL delimited array with the tokens.  On
1235  *          memory error NULL is returned and ERRNO is set.
1236  */
1237 char **
1238 strtokenize (const char *string, const char *delim)
1239 {
1240   const char *s;
1241   size_t fields;
1242   size_t bytes, n;
1243   char *buffer;
1244   char *p, *px, *pend;
1245   char **result;
1246
1247   /* Count the number of fields.  */
1248   for (fields = 1, s = strpbrk (string, delim); s; s = strpbrk (s + 1, delim))
1249     fields++;
1250   fields++; /* Add one for the terminating NULL.  */
1251
1252   /* Allocate an array for all fields, a terminating NULL, and space
1253      for a copy of the string.  */
1254   bytes = fields * sizeof *result;
1255   if (bytes / sizeof *result != fields)
1256     {
1257       gpg_err_set_errno (ENOMEM);
1258       return NULL;
1259     }
1260   n = strlen (string) + 1;
1261   bytes += n;
1262   if (bytes < n)
1263     {
1264       gpg_err_set_errno (ENOMEM);
1265       return NULL;
1266     }
1267   result = xtrymalloc (bytes);
1268   if (!result)
1269     return NULL;
1270   buffer = (char*)(result + fields);
1271
1272   /* Copy and parse the string.  */
1273   strcpy (buffer, string);
1274   for (n = 0, p = buffer; (pend = strpbrk (p, delim)); p = pend + 1)
1275     {
1276       *pend = 0;
1277       while (spacep (p))
1278         p++;
1279       for (px = pend - 1; px >= p && spacep (px); px--)
1280         *px = 0;
1281       result[n++] = p;
1282     }
1283   while (spacep (p))
1284     p++;
1285   for (px = p + strlen (p) - 1; px >= p && spacep (px); px--)
1286     *px = 0;
1287   result[n++] = p;
1288   result[n] = NULL;
1289
1290   assert ((char*)(result + n + 1) == buffer);
1291
1292   return result;
1293 }
1294
1295
1296 /* Split a string into space delimited fields and remove leading and
1297  * trailing spaces from each field.  A pointer to each field is stored
1298  * in ARRAY.  Stop splitting at ARRAYSIZE fields.  The function
1299  * modifies STRING.  The number of parsed fields is returned.
1300  * Example:
1301  *
1302  *   char *fields[2];
1303  *   if (split_fields (string, fields, DIM (fields)) < 2)
1304  *     return  // Not enough args.
1305  *   foo (fields[0]);
1306  *   foo (fields[1]);
1307  */
1308 int
1309 split_fields (char *string, char **array, int arraysize)
1310 {
1311   int n = 0;
1312   char *p, *pend;
1313
1314   for (p = string; *p == ' '; p++)
1315     ;
1316   do
1317     {
1318       if (n == arraysize)
1319         break;
1320       array[n++] = p;
1321       pend = strchr (p, ' ');
1322       if (!pend)
1323         break;
1324       *pend++ = 0;
1325       for (p = pend; *p == ' '; p++)
1326         ;
1327     }
1328   while (*p);
1329
1330   return n;
1331 }
1332
1333
1334 \f
1335 /* Version number parsing.  */
1336
1337 /* This function parses the first portion of the version number S and
1338    stores it in *NUMBER.  On success, this function returns a pointer
1339    into S starting with the first character, which is not part of the
1340    initial number portion; on failure, NULL is returned.  */
1341 static const char*
1342 parse_version_number (const char *s, int *number)
1343 {
1344   int val = 0;
1345
1346   if (*s == '0' && digitp (s+1))
1347     return NULL;  /* Leading zeros are not allowed.  */
1348   for (; digitp (s); s++)
1349     {
1350       val *= 10;
1351       val += *s - '0';
1352     }
1353   *number = val;
1354   return val < 0 ? NULL : s;
1355 }
1356
1357
1358 /* This function breaks up the complete string-representation of the
1359    version number S, which is of the following struture: <major
1360    number>.<minor number>[.<micro number>]<patch level>.  The major,
1361    minor, and micro number components will be stored in *MAJOR, *MINOR
1362    and *MICRO.  If MICRO is not given 0 is used instead.
1363
1364    On success, the last component, the patch level, will be returned;
1365    in failure, NULL will be returned.  */
1366 static const char *
1367 parse_version_string (const char *s, int *major, int *minor, int *micro)
1368 {
1369   s = parse_version_number (s, major);
1370   if (!s || *s != '.')
1371     return NULL;
1372   s++;
1373   s = parse_version_number (s, minor);
1374   if (!s)
1375     return NULL;
1376   if (*s == '.')
1377     {
1378       s++;
1379       s = parse_version_number (s, micro);
1380       if (!s)
1381         return NULL;
1382     }
1383   else
1384     *micro = 0;
1385   return s;  /* Patchlevel.  */
1386 }
1387
1388
1389 /* Compare the version string MY_VERSION to the version string
1390  * REQ_VERSION.  Returns -1, 0, or 1 if MY_VERSION is found,
1391  * respectively, to be less than, to match, or be greater than
1392  * REQ_VERSION.  This function works for three and two part version
1393  * strings; for a two part version string the micro part is assumed to
1394  * be 0.  Patch levels are compared as strings.  If a version number
1395  * is invalid INT_MIN is returned.  If REQ_VERSION is given as NULL
1396  * the function returns 0 if MY_VERSION is parsable version string. */
1397 int
1398 compare_version_strings (const char *my_version, const char *req_version)
1399 {
1400   int my_major, my_minor, my_micro;
1401   int rq_major, rq_minor, rq_micro;
1402   const char *my_patch, *rq_patch;
1403   int result;
1404
1405   if (!my_version)
1406     return INT_MIN;
1407
1408   my_patch = parse_version_string (my_version, &my_major, &my_minor, &my_micro);
1409   if (!my_patch)
1410     return INT_MIN;
1411   if (!req_version)
1412     return 0; /* MY_VERSION can be parsed.  */
1413   rq_patch = parse_version_string (req_version, &rq_major, &rq_minor,&rq_micro);
1414   if (!rq_patch)
1415     return INT_MIN;
1416
1417   if (my_major == rq_major)
1418     {
1419       if (my_minor == rq_minor)
1420         {
1421           if (my_micro == rq_micro)
1422             result = strcmp (my_patch, rq_patch);
1423           else
1424             result = my_micro - rq_micro;
1425         }
1426       else
1427         result = my_minor - rq_minor;
1428     }
1429   else
1430     result = my_major - rq_major;
1431
1432   return !result? 0 : result < 0 ? -1 : 1;
1433 }
1434
1435
1436 \f
1437 /* Format a string so that it fits within about TARGET_COLS columns.
1438    If IN_PLACE is 0, then TEXT is copied to a new buffer, which is
1439    returned.  Otherwise, TEXT is modified in place and returned.
1440    Normally, target_cols will be 72 and max_cols is 80.  */
1441 char *
1442 format_text (char *text, int in_place, int target_cols, int max_cols)
1443 {
1444   const int do_debug = 0;
1445
1446   /* The character under consideration.  */
1447   char *p;
1448   /* The start of the current line.  */
1449   char *line;
1450   /* The last space that we saw.  */
1451   char *last_space = NULL;
1452   int last_space_cols = 0;
1453   int copied_last_space = 0;
1454
1455   if (! in_place)
1456     text = xstrdup (text);
1457
1458   p = line = text;
1459   while (1)
1460     {
1461       /* The number of columns including any trailing space.  */
1462       int cols;
1463
1464       p = p + strcspn (p, "\n ");
1465       if (! p)
1466         /* P now points to the NUL character.  */
1467         p = &text[strlen (text)];
1468
1469       if (*p == '\n')
1470         /* Pass through any newlines.  */
1471         {
1472           p ++;
1473           line = p;
1474           last_space = NULL;
1475           last_space_cols = 0;
1476           copied_last_space = 1;
1477           continue;
1478         }
1479
1480       /* Have a space or a NUL.  Note: we don't count the trailing
1481          space.  */
1482       cols = utf8_charcount (line, (uintptr_t) p - (uintptr_t) line);
1483       if (cols < target_cols)
1484         {
1485           if (! *p)
1486             /* Nothing left to break.  */
1487             break;
1488
1489           last_space = p;
1490           last_space_cols = cols;
1491           p ++;
1492           /* Skip any immediately following spaces.  If we break:
1493              "... foo bar ..." between "foo" and "bar" then we want:
1494              "... foo\nbar ...", which means that the left space has
1495              to be the first space after foo, not the last space
1496              before bar.  */
1497           while (*p == ' ')
1498             p ++;
1499         }
1500       else
1501         {
1502           int cols_with_left_space;
1503           int cols_with_right_space;
1504           int left_penalty;
1505           int right_penalty;
1506
1507           cols_with_left_space = last_space_cols;
1508           cols_with_right_space = cols;
1509
1510           if (do_debug)
1511             log_debug ("Breaking: '%.*s'\n",
1512                        (int) ((uintptr_t) p - (uintptr_t) line), line);
1513
1514           /* The number of columns away from TARGET_COLS.  We prefer
1515              to underflow than to overflow.  */
1516           left_penalty = target_cols - cols_with_left_space;
1517           right_penalty = 2 * (cols_with_right_space - target_cols);
1518
1519           if (cols_with_right_space > max_cols)
1520             /* Add a large penalty for each column that exceeds
1521                max_cols.  */
1522             right_penalty += 4 * (cols_with_right_space - max_cols);
1523
1524           if (do_debug)
1525             log_debug ("Left space => %d cols (penalty: %d); right space => %d cols (penalty: %d)\n",
1526                        cols_with_left_space, left_penalty,
1527                        cols_with_right_space, right_penalty);
1528           if (last_space_cols && left_penalty <= right_penalty)
1529             /* Prefer the left space.  */
1530             {
1531               if (do_debug)
1532                 log_debug ("Breaking at left space.\n");
1533               p = last_space;
1534             }
1535           else
1536             {
1537               if (do_debug)
1538                 log_debug ("Breaking at right space.\n");
1539             }
1540
1541           if (! *p)
1542             break;
1543
1544           *p = '\n';
1545           p ++;
1546           if (*p == ' ')
1547             {
1548               int spaces;
1549               for (spaces = 1; p[spaces] == ' '; spaces ++)
1550                 ;
1551               memmove (p, &p[spaces], strlen (&p[spaces]) + 1);
1552             }
1553           line = p;
1554           last_space = NULL;
1555           last_space_cols = 0;
1556           copied_last_space = 0;
1557         }
1558     }
1559
1560   /* Chop off any trailing space.  */
1561   trim_trailing_chars (text, strlen (text), " ");
1562   /* If we inserted the trailing newline, then remove it.  */
1563   if (! copied_last_space && *text && text[strlen (text) - 1] == '\n')
1564     text[strlen (text) - 1] = '\0';
1565
1566   return text;
1567 }