apt-pkg/contrib/strutl.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: strutl.cc,v 1.48 2003/07/18 14:15:11 mdz Exp $
   4 /* ######################################################################
   5
   6    String Util - Some useful string functions.
   7
   8    These have been collected from here and there to do all sorts of useful
   9    things to strings. They are useful in file parsers, URI handlers and
  10    especially in APT methods.
  11
  12    This source is placed in the Public Domain, do with it what you will
  13    It was originally written by Jason Gunthorpe <jgg@gpu.srv.ualberta.ca>
  14
  15    ##################################################################### */
  16                                                                         /*}}}*/
  17 // Includes                                                             /*{{{*/
  18 #include <config.h>
  19
  20 #include <apt-pkg/strutl.h>
  21 #include <apt-pkg/fileutl.h>
  22 #include <apt-pkg/error.h>
  23
  24 #include <stddef.h>
  25 #include <stdlib.h>
  26 #include <time.h>
  27 #include <string>
  28 #include <vector>
  29 #include <ctype.h>
  30 #include <string.h>
  31 #include <sstream>
  32 #include <stdio.h>
  33 #include <algorithm>
  34 #include <unistd.h>
  35 #include <regex.h>
  36 #include <errno.h>
  37 #include <stdarg.h>
  38 #include <iconv.h>
  39
  40 #include <apti18n.h>
  41                                                                         /*}}}*/
  42 using namespace std;
  43
  44 // Strip - Remove white space from the front and back of a string       /*{{{*/
  45 // ---------------------------------------------------------------------
  46 namespace APT {
  47    namespace String {
  48 std::string Strip(const std::string &str)
  49 {
  50    // ensure we have at least one character
  51    if (str.empty() == true)
  52       return str;
  53
  54    char const * const s = str.c_str();
  55    size_t start = 0;
  56    for (; isspace(s[start]) != 0; ++start)
  57       ; // find the first not-space
  58
  59    // string contains only whitespaces
  60    if (s[start] == '\0')
  61       return "";
  62
  63    size_t end = str.length() - 1;
  64    for (; isspace(s[end]) != 0; --end)
  65       ; // find the last not-space
  66
  67    return str.substr(start, end - start + 1);
  68 }
  69
  70 bool Endswith(const std::string &s, const std::string &end)
  71 {
  72    if (end.size() > s.size())
  73       return false;
  74    return (s.substr(s.size() - end.size(), s.size()) == end);
  75 }
  76
  77 bool Startswith(const std::string &s, const std::string &start)
  78 {
  79    if (start.size() > s.size())
  80       return false;
  81    return (s.substr(0, start.size()) == start);
  82 }
  83
  84 }
  85 }
  86                                                                         /*}}}*/
  87 // UTF8ToCodeset - Convert some UTF-8 string for some codeset           /*{{{*/
  88 // ---------------------------------------------------------------------
  89 /* This is handy to use before display some information for enduser  */
  90 bool UTF8ToCodeset(const char *codeset, const string &orig, string *dest)
  91 {
  92   iconv_t cd;
  93   const char *inbuf;
  94   char *inptr, *outbuf;
  95   size_t insize, bufsize;
  96   dest->clear();
  97
  98   cd = iconv_open(codeset, "UTF-8");
  99   if (cd == (iconv_t)(-1)) {
 100      // Something went wrong
 101      if (errno == EINVAL)
 102         _error->Error("conversion from 'UTF-8' to '%s' not available",
 103                codeset);
 104      else
 105         perror("iconv_open");
 106
 107      return false;
 108   }
 109
 110   insize = bufsize = orig.size();
 111   inbuf = orig.data();
 112   inptr = (char *)inbuf;
 113   outbuf = new char[bufsize];
 114   size_t lastError = -1;
 115
 116   while (insize != 0)
 117   {
 118      char *outptr = outbuf;
 119      size_t outsize = bufsize;
 120      size_t const err = iconv(cd, &inptr, &insize, &outptr, &outsize);
 121      dest->append(outbuf, outptr - outbuf);
 122      if (err == (size_t)(-1))
 123      {
 124         switch (errno)
 125         {
 126         case EILSEQ:
 127            insize--;
 128            inptr++;
 129            // replace a series of unknown multibytes with a single "?"
 130            if (lastError != insize) {
 131               lastError = insize - 1;
 132               dest->append("?");
 133            }
 134            break;
 135         case EINVAL:
 136            insize = 0;
 137            break;
 138         case E2BIG:
 139            if (outptr == outbuf)
 140            {
 141               bufsize *= 2;
 142               delete[] outbuf;
 143               outbuf = new char[bufsize];
 144            }
 145            break;
 146         }
 147      }
 148   }
 149
 150   delete[] outbuf;
 151
 152   iconv_close(cd);
 153
 154   return true;
 155 }
 156                                                                         /*}}}*/
 157 // strstrip - Remove white space from the front and back of a string    /*{{{*/
 158 // ---------------------------------------------------------------------
 159 /* This is handy to use when parsing a file. It also removes \n's left
 160    over from fgets and company */
 161 char *_strstrip(char *String)
 162 {
 163    for (;*String != 0 && (*String == ' ' || *String == '\t'); String++);
 164
 165    if (*String == 0)
 166       return String;
 167    return _strrstrip(String);
 168 }
 169                                                                         /*}}}*/
 170 // strrstrip - Remove white space from the back of a string     /*{{{*/
 171 // ---------------------------------------------------------------------
 172 char *_strrstrip(char *String)
 173 {
 174    char *End = String + strlen(String) - 1;
 175    for (;End != String - 1 && (*End == ' ' || *End == '\t' || *End == '\n' ||
 176                                *End == '\r'); End--);
 177    End++;
 178    *End = 0;
 179    return String;
 180 }
 181                                                                         /*}}}*/
 182 // strtabexpand - Converts tabs into 8 spaces                           /*{{{*/
 183 // ---------------------------------------------------------------------
 184 /* */
 185 char *_strtabexpand(char *String,size_t Len)
 186 {
 187    for (char *I = String; I != I + Len && *I != 0; I++)
 188    {
 189       if (*I != '\t')
 190          continue;
 191       if (I + 8 > String + Len)
 192       {
 193          *I = 0;
 194          return String;
 195       }
 196
 197       /* Assume the start of the string is 0 and find the next 8 char
 198          division */
 199       int Len;
 200       if (String == I)
 201          Len = 1;
 202       else
 203          Len = 8 - ((String - I) % 8);
 204       Len -= 2;
 205       if (Len <= 0)
 206       {
 207          *I = ' ';
 208          continue;
 209       }
 210
 211       memmove(I + Len,I + 1,strlen(I) + 1);
 212       for (char *J = I; J + Len != I; *I = ' ', I++);
 213    }
 214    return String;
 215 }
 216                                                                         /*}}}*/
 217 // ParseQuoteWord - Parse a single word out of a string                 /*{{{*/
 218 // ---------------------------------------------------------------------
 219 /* This grabs a single word, converts any % escaped characters to their
 220    proper values and advances the pointer. Double quotes are understood
 221    and striped out as well. This is for URI/URL parsing. It also can
 222    understand [] brackets.*/
 223 bool ParseQuoteWord(const char *&String,string &Res)
 224 {
 225    // Skip leading whitespace
 226    const char *C = String;
 227    for (;*C != 0 && *C == ' '; C++);
 228    if (*C == 0)
 229       return false;
 230
 231    // Jump to the next word
 232    for (;*C != 0 && isspace(*C) == 0; C++)
 233    {
 234       if (*C == '"')
 235       {
 236          C = strchr(C + 1, '"');
 237          if (C == NULL)
 238             return false;
 239       }
 240       if (*C == '[')
 241       {
 242          C = strchr(C + 1, ']');
 243          if (C == NULL)
 244             return false;
 245       }
 246    }
 247
 248    // Now de-quote characters
 249    char Buffer[1024];
 250    char Tmp[3];
 251    const char *Start = String;
 252    char *I;
 253    for (I = Buffer; I < Buffer + sizeof(Buffer) && Start != C; I++)
 254    {
 255       if (*Start == '%' && Start + 2 < C &&
 256           isxdigit(Start[1]) && isxdigit(Start[2]))
 257       {
 258          Tmp[0] = Start[1];
 259          Tmp[1] = Start[2];
 260          Tmp[2] = 0;
 261          *I = (char)strtol(Tmp,0,16);
 262          Start += 3;
 263          continue;
 264       }
 265       if (*Start != '"')
 266          *I = *Start;
 267       else
 268          I--;
 269       Start++;
 270    }
 271    *I = 0;
 272    Res = Buffer;
 273
 274    // Skip ending white space
 275    for (;*C != 0 && isspace(*C) != 0; C++);
 276    String = C;
 277    return true;
 278 }
 279                                                                         /*}}}*/
 280 // ParseCWord - Parses a string like a C "" expression                  /*{{{*/
 281 // ---------------------------------------------------------------------
 282 /* This expects a series of space separated strings enclosed in ""'s.
 283    It concatenates the ""'s into a single string. */
 284 bool ParseCWord(const char *&String,string &Res)
 285 {
 286    // Skip leading whitespace
 287    const char *C = String;
 288    for (;*C != 0 && *C == ' '; C++);
 289    if (*C == 0)
 290       return false;
 291
 292    char Buffer[1024];
 293    char *Buf = Buffer;
 294    if (strlen(String) >= sizeof(Buffer))
 295        return false;
 296
 297    for (; *C != 0; C++)
 298    {
 299       if (*C == '"')
 300       {
 301          for (C++; *C != 0 && *C != '"'; C++)
 302             *Buf++ = *C;
 303
 304          if (*C == 0)
 305             return false;
 306
 307          continue;
 308       }
 309
 310       if (C != String && isspace(*C) != 0 && isspace(C[-1]) != 0)
 311          continue;
 312       if (isspace(*C) == 0)
 313          return false;
 314       *Buf++ = ' ';
 315    }
 316    *Buf = 0;
 317    Res = Buffer;
 318    String = C;
 319    return true;
 320 }
 321                                                                         /*}}}*/
 322 // QuoteString - Convert a string into quoted from                      /*{{{*/
 323 // ---------------------------------------------------------------------
 324 /* */
 325 string QuoteString(const string &Str, const char *Bad)
 326 {
 327    std::stringstream Res;
 328    for (string::const_iterator I = Str.begin(); I != Str.end(); ++I)
 329    {
 330       if (strchr(Bad,*I) != 0 || isprint(*I) == 0 ||
 331           *I == 0x25 || // percent '%' char
 332           *I <= 0x20 || *I >= 0x7F) // control chars
 333       {
 334          ioprintf(Res, "%%%02hhx", *I);
 335       }
 336       else
 337          Res << *I;
 338    }
 339    return Res.str();
 340 }
 341                                                                         /*}}}*/
 342 // DeQuoteString - Convert a string from quoted from                    /*{{{*/
 343 // ---------------------------------------------------------------------
 344 /* This undoes QuoteString */
 345 string DeQuoteString(const string &Str)
 346 {
 347    return DeQuoteString(Str.begin(),Str.end());
 348 }
 349 string DeQuoteString(string::const_iterator const &begin,
 350                         string::const_iterator const &end)
 351 {
 352    string Res;
 353    for (string::const_iterator I = begin; I != end; ++I)
 354    {
 355       if (*I == '%' && I + 2 < end &&
 356           isxdigit(I[1]) && isxdigit(I[2]))
 357       {
 358          char Tmp[3];
 359          Tmp[0] = I[1];
 360          Tmp[1] = I[2];
 361          Tmp[2] = 0;
 362          Res += (char)strtol(Tmp,0,16);
 363          I += 2;
 364          continue;
 365       }
 366       else
 367          Res += *I;
 368    }
 369    return Res;
 370 }
 371
 372                                                                         /*}}}*/
 373 // SizeToStr - Convert a long into a human readable size                /*{{{*/
 374 // ---------------------------------------------------------------------
 375 /* A max of 4 digits are shown before conversion to the next highest unit.
 376    The max length of the string will be 5 chars unless the size is > 10
 377    YottaBytes (E24) */
 378 string SizeToStr(double Size)
 379 {
 380    double ASize;
 381    if (Size >= 0)
 382       ASize = Size;
 383    else
 384       ASize = -1*Size;
 385
 386    /* bytes, KiloBytes, MegaBytes, GigaBytes, TeraBytes, PetaBytes,
 387       ExaBytes, ZettaBytes, YottaBytes */
 388    char Ext[] = {'\0','k','M','G','T','P','E','Z','Y'};
 389    int I = 0;
 390    while (I <= 8)
 391    {
 392       if (ASize < 100 && I != 0)
 393       {
 394          std::string S;
 395          strprintf(S, "%'.1f %c", ASize, Ext[I]);
 396          return S;
 397       }
 398
 399       if (ASize < 10000)
 400       {
 401          std::string S;
 402          strprintf(S, "%'.0f %c", ASize, Ext[I]);
 403          return S;
 404       }
 405       ASize /= 1000.0;
 406       I++;
 407    }
 408    return "";
 409 }
 410                                                                         /*}}}*/
 411 // TimeToStr - Convert the time into a string                           /*{{{*/
 412 // ---------------------------------------------------------------------
 413 /* Converts a number of seconds to a hms format */
 414 string TimeToStr(unsigned long Sec)
 415 {
 416    std::string S;
 417    if (Sec > 60*60*24)
 418    {
 419       //TRANSLATOR: d means days, h means hours, min means minutes, s means seconds
 420       strprintf(S,_("%lid %lih %limin %lis"),Sec/60/60/24,(Sec/60/60) % 24,(Sec/60) % 60,Sec % 60);
 421    }
 422    else if (Sec > 60*60)
 423    {
 424       //TRANSLATOR: h means hours, min means minutes, s means seconds
 425       strprintf(S,_("%lih %limin %lis"),Sec/60/60,(Sec/60) % 60,Sec % 60);
 426    }
 427    else if (Sec > 60)
 428    {
 429       //TRANSLATOR: min means minutes, s means seconds
 430       strprintf(S,_("%limin %lis"),Sec/60,Sec % 60);
 431    }
 432    else
 433    {
 434       //TRANSLATOR: s means seconds
 435       strprintf(S,_("%lis"),Sec);
 436    }
 437    return S;
 438 }
 439                                                                         /*}}}*/
 440 // SubstVar - Substitute a string for another string                    /*{{{*/
 441 // ---------------------------------------------------------------------
 442 /* This replaces all occurrences of Subst with Contents in Str. */
 443 string SubstVar(const string &Str,const string &Subst,const string &Contents)
 444 {
 445    if (Subst.empty() == true)
 446       return Str;
 447
 448    string::size_type Pos = 0;
 449    string::size_type OldPos = 0;
 450    string Temp;
 451
 452    while (OldPos < Str.length() &&
 453           (Pos = Str.find(Subst,OldPos)) != string::npos)
 454    {
 455       if (OldPos != Pos)
 456          Temp.append(Str, OldPos, Pos - OldPos);
 457       if (Contents.empty() == false)
 458          Temp.append(Contents);
 459       OldPos = Pos + Subst.length();
 460    }
 461
 462    if (OldPos == 0)
 463       return Str;
 464
 465    if (OldPos >= Str.length())
 466       return Temp;
 467    return Temp + string(Str,OldPos);
 468 }
 469 string SubstVar(string Str,const struct SubstVar *Vars)
 470 {
 471    for (; Vars->Subst != 0; Vars++)
 472       Str = SubstVar(Str,Vars->Subst,*Vars->Contents);
 473    return Str;
 474 }
 475                                                                         /*}}}*/
 476 // OutputInDepth - return a string with separator multiplied with depth /*{{{*/
 477 // ---------------------------------------------------------------------
 478 /* Returns a string with the supplied separator depth + 1 times in it */
 479 std::string OutputInDepth(const unsigned long Depth, const char* Separator)
 480 {
 481    std::string output = "";
 482    for(unsigned long d=Depth+1; d > 0; d--)
 483       output.append(Separator);
 484    return output;
 485 }
 486                                                                         /*}}}*/
 487 // URItoFileName - Convert the uri into a unique file name              /*{{{*/
 488 // ---------------------------------------------------------------------
 489 /* This converts a URI into a safe filename. It quotes all unsafe characters
 490    and converts / to _ and removes the scheme identifier. The resulting
 491    file name should be unique and never occur again for a different file */
 492 string URItoFileName(const string &URI)
 493 {
 494    // Nuke 'sensitive' items
 495    ::URI U(URI);
 496    U.User.clear();
 497    U.Password.clear();
 498    U.Access.clear();
 499
 500    // "\x00-\x20{}|\\\\^\\[\\]<>\"\x7F-\xFF";
 501    string NewURI = QuoteString(U,"\\|{}[]<>\"^~_=!@#$%^&*");
 502    replace(NewURI.begin(),NewURI.end(),'/','_');
 503    return NewURI;
 504 }
 505                                                                         /*}}}*/
 506 // Base64Encode - Base64 Encoding routine for short strings             /*{{{*/
 507 // ---------------------------------------------------------------------
 508 /* This routine performs a base64 transformation on a string. It was ripped
 509    from wget and then patched and bug fixed.
 510
 511    This spec can be found in rfc2045 */
 512 string Base64Encode(const string &S)
 513 {
 514    // Conversion table.
 515    static char tbl[64] = {'A','B','C','D','E','F','G','H',
 516                           'I','J','K','L','M','N','O','P',
 517                           'Q','R','S','T','U','V','W','X',
 518                           'Y','Z','a','b','c','d','e','f',
 519                           'g','h','i','j','k','l','m','n',
 520                           'o','p','q','r','s','t','u','v',
 521                           'w','x','y','z','0','1','2','3',
 522                           '4','5','6','7','8','9','+','/'};
 523
 524    // Pre-allocate some space
 525    string Final;
 526    Final.reserve((4*S.length() + 2)/3 + 2);
 527
 528    /* Transform the 3x8 bits to 4x6 bits, as required by
 529       base64.  */
 530    for (string::const_iterator I = S.begin(); I < S.end(); I += 3)
 531    {
 532       char Bits[3] = {0,0,0};
 533       Bits[0] = I[0];
 534       if (I + 1 < S.end())
 535          Bits[1] = I[1];
 536       if (I + 2 < S.end())
 537          Bits[2] = I[2];
 538
 539       Final += tbl[Bits[0] >> 2];
 540       Final += tbl[((Bits[0] & 3) << 4) + (Bits[1] >> 4)];
 541
 542       if (I + 1 >= S.end())
 543          break;
 544
 545       Final += tbl[((Bits[1] & 0xf) << 2) + (Bits[2] >> 6)];
 546
 547       if (I + 2 >= S.end())
 548          break;
 549
 550       Final += tbl[Bits[2] & 0x3f];
 551    }
 552
 553    /* Apply the padding elements, this tells how many bytes the remote
 554       end should discard */
 555    if (S.length() % 3 == 2)
 556       Final += '=';
 557    if (S.length() % 3 == 1)
 558       Final += "==";
 559
 560    return Final;
 561 }
 562                                                                         /*}}}*/
 563 // stringcmp - Arbitrary string compare                                 /*{{{*/
 564 // ---------------------------------------------------------------------
 565 /* This safely compares two non-null terminated strings of arbitrary
 566    length */
 567 int stringcmp(const char *A,const char *AEnd,const char *B,const char *BEnd)
 568 {
 569    for (; A != AEnd && B != BEnd; A++, B++)
 570       if (*A != *B)
 571          break;
 572
 573    if (A == AEnd && B == BEnd)
 574       return 0;
 575    if (A == AEnd)
 576       return 1;
 577    if (B == BEnd)
 578       return -1;
 579    if (*A < *B)
 580       return -1;
 581    return 1;
 582 }
 583
 584 #if __GNUC__ >= 3
 585 int stringcmp(string::const_iterator A,string::const_iterator AEnd,
 586               const char *B,const char *BEnd)
 587 {
 588    for (; A != AEnd && B != BEnd; A++, B++)
 589       if (*A != *B)
 590          break;
 591
 592    if (A == AEnd && B == BEnd)
 593       return 0;
 594    if (A == AEnd)
 595       return 1;
 596    if (B == BEnd)
 597       return -1;
 598    if (*A < *B)
 599       return -1;
 600    return 1;
 601 }
 602 int stringcmp(string::const_iterator A,string::const_iterator AEnd,
 603               string::const_iterator B,string::const_iterator BEnd)
 604 {
 605    for (; A != AEnd && B != BEnd; A++, B++)
 606       if (*A != *B)
 607          break;
 608
 609    if (A == AEnd && B == BEnd)
 610       return 0;
 611    if (A == AEnd)
 612       return 1;
 613    if (B == BEnd)
 614       return -1;
 615    if (*A < *B)
 616       return -1;
 617    return 1;
 618 }
 619 #endif
 620                                                                         /*}}}*/
 621 // stringcasecmp - Arbitrary case insensitive string compare            /*{{{*/
 622 // ---------------------------------------------------------------------
 623 /* */
 624 int stringcasecmp(const char *A,const char *AEnd,const char *B,const char *BEnd)
 625 {
 626    for (; A != AEnd && B != BEnd; A++, B++)
 627       if (tolower_ascii(*A) != tolower_ascii(*B))
 628          break;
 629
 630    if (A == AEnd && B == BEnd)
 631       return 0;
 632    if (A == AEnd)
 633       return 1;
 634    if (B == BEnd)
 635       return -1;
 636    if (tolower_ascii(*A) < tolower_ascii(*B))
 637       return -1;
 638    return 1;
 639 }
 640 #if __GNUC__ >= 3
 641 int stringcasecmp(string::const_iterator A,string::const_iterator AEnd,
 642                   const char *B,const char *BEnd)
 643 {
 644    for (; A != AEnd && B != BEnd; A++, B++)
 645       if (tolower_ascii(*A) != tolower_ascii(*B))
 646          break;
 647
 648    if (A == AEnd && B == BEnd)
 649       return 0;
 650    if (A == AEnd)
 651       return 1;
 652    if (B == BEnd)
 653       return -1;
 654    if (tolower_ascii(*A) < tolower_ascii(*B))
 655       return -1;
 656    return 1;
 657 }
 658 int stringcasecmp(string::const_iterator A,string::const_iterator AEnd,
 659                   string::const_iterator B,string::const_iterator BEnd)
 660 {
 661    for (; A != AEnd && B != BEnd; A++, B++)
 662       if (tolower_ascii(*A) != tolower_ascii(*B))
 663          break;
 664
 665    if (A == AEnd && B == BEnd)
 666       return 0;
 667    if (A == AEnd)
 668       return 1;
 669    if (B == BEnd)
 670       return -1;
 671    if (tolower_ascii(*A) < tolower_ascii(*B))
 672       return -1;
 673    return 1;
 674 }
 675 #endif
 676                                                                         /*}}}*/
 677 // LookupTag - Lookup the value of a tag in a taged string              /*{{{*/
 678 // ---------------------------------------------------------------------
 679 /* The format is like those used in package files and the method
 680    communication system */
 681 string LookupTag(const string &Message,const char *Tag,const char *Default)
 682 {
 683    // Look for a matching tag.
 684    int Length = strlen(Tag);
 685    for (string::const_iterator I = Message.begin(); I + Length < Message.end(); ++I)
 686    {
 687       // Found the tag
 688       if (I[Length] == ':' && stringcasecmp(I,I+Length,Tag) == 0)
 689       {
 690          // Find the end of line and strip the leading/trailing spaces
 691          string::const_iterator J;
 692          I += Length + 1;
 693          for (; isspace_ascii(*I) != 0 && I < Message.end(); ++I);
 694          for (J = I; *J != '\n' && J < Message.end(); ++J);
 695          for (; J > I && isspace_ascii(J[-1]) != 0; --J);
 696
 697          return string(I,J);
 698       }
 699
 700       for (; *I != '\n' && I < Message.end(); ++I);
 701    }
 702
 703    // Failed to find a match
 704    if (Default == 0)
 705       return string();
 706    return Default;
 707 }
 708                                                                         /*}}}*/
 709 // StringToBool - Converts a string into a boolean                      /*{{{*/
 710 // ---------------------------------------------------------------------
 711 /* This inspects the string to see if it is true or if it is false and
 712    then returns the result. Several varients on true/false are checked. */
 713 int StringToBool(const string &Text,int Default)
 714 {
 715    char *ParseEnd;
 716    int Res = strtol(Text.c_str(),&ParseEnd,0);
 717    // ensure that the entire string was converted by strtol to avoid
 718    // failures on "apt-cache show -a 0ad" where the "0" is converted
 719    const char *TextEnd = Text.c_str()+Text.size();
 720    if (ParseEnd == TextEnd && Res >= 0 && Res <= 1)
 721       return Res;
 722
 723    // Check for positives
 724    if (strcasecmp(Text.c_str(),"no") == 0 ||
 725        strcasecmp(Text.c_str(),"false") == 0 ||
 726        strcasecmp(Text.c_str(),"without") == 0 ||
 727        strcasecmp(Text.c_str(),"off") == 0 ||
 728        strcasecmp(Text.c_str(),"disable") == 0)
 729       return 0;
 730
 731    // Check for negatives
 732    if (strcasecmp(Text.c_str(),"yes") == 0 ||
 733        strcasecmp(Text.c_str(),"true") == 0 ||
 734        strcasecmp(Text.c_str(),"with") == 0 ||
 735        strcasecmp(Text.c_str(),"on") == 0 ||
 736        strcasecmp(Text.c_str(),"enable") == 0)
 737       return 1;
 738
 739    return Default;
 740 }
 741                                                                         /*}}}*/
 742 // TimeRFC1123 - Convert a time_t into RFC1123 format                   /*{{{*/
 743 // ---------------------------------------------------------------------
 744 /* This converts a time_t into a string time representation that is
 745    year 2000 complient and timezone neutral */
 746 string TimeRFC1123(time_t Date)
 747 {
 748    struct tm Conv;
 749    if (gmtime_r(&Date, &Conv) == NULL)
 750       return "";
 751
 752    char Buf[300];
 753    const char *Day[] = {"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
 754    const char *Month[] = {"Jan","Feb","Mar","Apr","May","Jun","Jul",
 755                           "Aug","Sep","Oct","Nov","Dec"};
 756
 757    snprintf(Buf, sizeof(Buf), "%s, %02i %s %i %02i:%02i:%02i GMT",Day[Conv.tm_wday],
 758            Conv.tm_mday,Month[Conv.tm_mon],Conv.tm_year+1900,Conv.tm_hour,
 759            Conv.tm_min,Conv.tm_sec);
 760    return Buf;
 761 }
 762                                                                         /*}}}*/
 763 // ReadMessages - Read messages from the FD                             /*{{{*/
 764 // ---------------------------------------------------------------------
 765 /* This pulls full messages from the input FD into the message buffer.
 766    It assumes that messages will not pause during transit so no
 767    fancy buffering is used.
 768
 769    In particular: this reads blocks from the input until it believes
 770    that it's run out of input text.  Each block is terminated by a
 771    double newline ('\n' followed by '\n').
 772  */
 773 bool ReadMessages(int Fd, vector<string> &List)
 774 {
 775    char Buffer[64000];
 776    // Represents any left-over from the previous iteration of the
 777    // parse loop.  (i.e., if a message is split across the end
 778    // of the buffer, it goes here)
 779    string PartialMessage;
 780
 781    do {
 782       int const Res = read(Fd, Buffer, sizeof(Buffer));
 783       if (Res < 0 && errno == EINTR)
 784          continue;
 785
 786       // process we read from has died
 787       if (Res == 0)
 788          return false;
 789
 790       // No data
 791       if (Res < 0 && (errno == EAGAIN || errno == EWOULDBLOCK))
 792          return true;
 793       if (Res < 0)
 794          return false;
 795
 796       // extract the message(s) from the buffer
 797       char const *Start = Buffer;
 798       char const * const End = Buffer + Res;
 799
 800       char const * NL = (char const *) memchr(Start, '\n', End - Start);
 801       if (NL == NULL)
 802       {
 803          // end of buffer: store what we have so far and read new data in
 804          PartialMessage.append(Start, End - Start);
 805          Start = End;
 806       }
 807       else
 808          ++NL;
 809
 810       if (PartialMessage.empty() == false && Start < End)
 811       {
 812          // if we start with a new line, see if the partial message we have ended with one
 813          // so that we properly detect records ending between two read() runs
 814          // cases are: \n|\n  ,  \r\n|\r\n  and  \r\n\r|\n
 815          // the case \r|\n\r\n is handled by the usual double-newline handling
 816          if ((NL - Start) == 1 || ((NL - Start) == 2 && *Start == '\r'))
 817          {
 818             if (APT::String::Endswith(PartialMessage, "\n") || APT::String::Endswith(PartialMessage, "\r\n\r"))
 819             {
 820                PartialMessage.erase(PartialMessage.find_last_not_of("\r\n") + 1);
 821                List.push_back(PartialMessage);
 822                PartialMessage.clear();
 823                while (NL < End && (*NL == '\n' || *NL == '\r')) ++NL;
 824                Start = NL;
 825             }
 826          }
 827       }
 828
 829       while (Start < End) {
 830          char const * NL2 = (char const *) memchr(NL, '\n', End - NL);
 831          if (NL2 == NULL)
 832          {
 833             // end of buffer: store what we have so far and read new data in
 834             PartialMessage.append(Start, End - Start);
 835             break;
 836          }
 837          ++NL2;
 838
 839          // did we find a double newline?
 840          if ((NL2 - NL) == 1 || ((NL2 - NL) == 2 && *NL == '\r'))
 841          {
 842             PartialMessage.append(Start, NL2 - Start);
 843             PartialMessage.erase(PartialMessage.find_last_not_of("\r\n") + 1);
 844             List.push_back(PartialMessage);
 845             PartialMessage.clear();
 846             while (NL2 < End && (*NL2 == '\n' || *NL2 == '\r')) ++NL2;
 847             Start = NL2;
 848          }
 849          NL = NL2;
 850       }
 851
 852       // we have read at least one complete message and nothing left
 853       if (PartialMessage.empty() == true)
 854          return true;
 855
 856       if (WaitFd(Fd) == false)
 857          return false;
 858    } while (true);
 859 }
 860                                                                         /*}}}*/
 861 // MonthConv - Converts a month string into a number                    /*{{{*/
 862 // ---------------------------------------------------------------------
 863 /* This was lifted from the boa webserver which lifted it from 'wn-v1.07'
 864    Made it a bit more robust with a few tolower_ascii though. */
 865 static int MonthConv(char *Month)
 866 {
 867    switch (tolower_ascii(*Month))
 868    {
 869       case 'a':
 870       return tolower_ascii(Month[1]) == 'p'?3:7;
 871       case 'd':
 872       return 11;
 873       case 'f':
 874       return 1;
 875       case 'j':
 876       if (tolower_ascii(Month[1]) == 'a')
 877          return 0;
 878       return tolower_ascii(Month[2]) == 'n'?5:6;
 879       case 'm':
 880       return tolower_ascii(Month[2]) == 'r'?2:4;
 881       case 'n':
 882       return 10;
 883       case 'o':
 884       return 9;
 885       case 's':
 886       return 8;
 887
 888       // Pretend it is January..
 889       default:
 890       return 0;
 891    }
 892 }
 893                                                                         /*}}}*/
 894 // timegm - Internal timegm if the gnu version is not available         /*{{{*/
 895 // ---------------------------------------------------------------------
 896 /* Converts struct tm to time_t, assuming the data in tm is UTC rather
 897    than local timezone (mktime assumes the latter).
 898
 899    This function is a nonstandard GNU extension that is also present on
 900    the BSDs and maybe other systems. For others we follow the advice of
 901    the manpage of timegm and use his portable replacement. */
 902 #ifndef HAVE_TIMEGM
 903 static time_t timegm(struct tm *t)
 904 {
 905    char *tz = getenv("TZ");
 906    setenv("TZ", "", 1);
 907    tzset();
 908    time_t ret = mktime(t);
 909    if (tz)
 910       setenv("TZ", tz, 1);
 911    else
 912       unsetenv("TZ");
 913    tzset();
 914    return ret;
 915 }
 916 #endif
 917                                                                         /*}}}*/
 918 // FullDateToTime - Converts a HTTP1.1 full date strings into a time_t  /*{{{*/
 919 // ---------------------------------------------------------------------
 920 /* tries to parses a full date as specified in RFC2616 Section 3.3.1
 921    with one exception: All timezones (%Z) are accepted but the protocol
 922    says that it MUST be GMT, but this one is equal to UTC which we will
 923    encounter from time to time (e.g. in Release files) so we accept all
 924    here and just assume it is GMT (or UTC) later on */
 925 bool RFC1123StrToTime(const char* const str,time_t &time)
 926 {
 927    struct tm Tm;
 928    setlocale (LC_ALL,"C");
 929    bool const invalid =
 930    // Sun, 06 Nov 1994 08:49:37 GMT  ; RFC 822, updated by RFC 1123
 931       (strptime(str, "%a, %d %b %Y %H:%M:%S %Z", &Tm) == NULL &&
 932    // Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036
 933        strptime(str, "%A, %d-%b-%y %H:%M:%S %Z", &Tm) == NULL &&
 934    // Sun Nov  6 08:49:37 1994       ; ANSI C's asctime() format
 935        strptime(str, "%a %b %d %H:%M:%S %Y", &Tm) == NULL);
 936    setlocale (LC_ALL,"");
 937    if (invalid == true)
 938       return false;
 939
 940    time = timegm(&Tm);
 941    return true;
 942 }
 943                                                                         /*}}}*/
 944 // FTPMDTMStrToTime - Converts a ftp modification date into a time_t    /*{{{*/
 945 // ---------------------------------------------------------------------
 946 /* */
 947 bool FTPMDTMStrToTime(const char* const str,time_t &time)
 948 {
 949    struct tm Tm;
 950    // MDTM includes no whitespaces but recommend and ignored by strptime
 951    if (strptime(str, "%Y %m %d %H %M %S", &Tm) == NULL)
 952       return false;
 953
 954    time = timegm(&Tm);
 955    return true;
 956 }
 957                                                                         /*}}}*/
 958 // StrToTime - Converts a string into a time_t                          /*{{{*/
 959 // ---------------------------------------------------------------------
 960 /* This handles all 3 popular time formats including RFC 1123, RFC 1036
 961    and the C library asctime format. It requires the GNU library function
 962    'timegm' to convert a struct tm in UTC to a time_t. For some bizzar
 963    reason the C library does not provide any such function :< This also
 964    handles the weird, but unambiguous FTP time format*/
 965 bool StrToTime(const string &Val,time_t &Result)
 966 {
 967    struct tm Tm;
 968    char Month[10];
 969
 970    // Skip the day of the week
 971    const char *I = strchr(Val.c_str(), ' ');
 972
 973    // Handle RFC 1123 time
 974    Month[0] = 0;
 975    if (sscanf(I," %2d %3s %4d %2d:%2d:%2d GMT",&Tm.tm_mday,Month,&Tm.tm_year,
 976               &Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec) != 6)
 977    {
 978       // Handle RFC 1036 time
 979       if (sscanf(I," %2d-%3s-%3d %2d:%2d:%2d GMT",&Tm.tm_mday,Month,
 980                  &Tm.tm_year,&Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec) == 6)
 981          Tm.tm_year += 1900;
 982       else
 983       {
 984          // asctime format
 985          if (sscanf(I," %3s %2d %2d:%2d:%2d %4d",Month,&Tm.tm_mday,
 986                     &Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec,&Tm.tm_year) != 6)
 987          {
 988             // 'ftp' time
 989             if (sscanf(Val.c_str(),"%4d%2d%2d%2d%2d%2d",&Tm.tm_year,&Tm.tm_mon,
 990                        &Tm.tm_mday,&Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec) != 6)
 991                return false;
 992             Tm.tm_mon--;
 993          }
 994       }
 995    }
 996
 997    Tm.tm_isdst = 0;
 998    if (Month[0] != 0)
 999       Tm.tm_mon = MonthConv(Month);
1000    else
1001       Tm.tm_mon = 0; // we don't have a month, so pick something
1002    Tm.tm_year -= 1900;
1003
1004    // Convert to local time and then to GMT
1005    Result = timegm(&Tm);
1006    return true;
1007 }
1008                                                                         /*}}}*/
1009 // StrToNum - Convert a fixed length string to a number                 /*{{{*/
1010 // ---------------------------------------------------------------------
1011 /* This is used in decoding the crazy fixed length string headers in
1012    tar and ar files. */
1013 bool StrToNum(const char *Str,unsigned long &Res,unsigned Len,unsigned Base)
1014 {
1015    char S[30];
1016    if (Len >= sizeof(S))
1017       return false;
1018    memcpy(S,Str,Len);
1019    S[Len] = 0;
1020
1021    // All spaces is a zero
1022    Res = 0;
1023    unsigned I;
1024    for (I = 0; S[I] == ' '; I++);
1025    if (S[I] == 0)
1026       return true;
1027
1028    char *End;
1029    Res = strtoul(S,&End,Base);
1030    if (End == S)
1031       return false;
1032
1033    return true;
1034 }
1035                                                                         /*}}}*/
1036 // StrToNum - Convert a fixed length string to a number                 /*{{{*/
1037 // ---------------------------------------------------------------------
1038 /* This is used in decoding the crazy fixed length string headers in
1039    tar and ar files. */
1040 bool StrToNum(const char *Str,unsigned long long &Res,unsigned Len,unsigned Base)
1041 {
1042    char S[30];
1043    if (Len >= sizeof(S))
1044       return false;
1045    memcpy(S,Str,Len);
1046    S[Len] = 0;
1047
1048    // All spaces is a zero
1049    Res = 0;
1050    unsigned I;
1051    for (I = 0; S[I] == ' '; I++);
1052    if (S[I] == 0)
1053       return true;
1054
1055    char *End;
1056    Res = strtoull(S,&End,Base);
1057    if (End == S)
1058       return false;
1059
1060    return true;
1061 }
1062                                                                         /*}}}*/
1063
1064 // Base256ToNum - Convert a fixed length binary to a number             /*{{{*/
1065 // ---------------------------------------------------------------------
1066 /* This is used in decoding the 256bit encoded fixed length fields in
1067    tar files */
1068 bool Base256ToNum(const char *Str,unsigned long long &Res,unsigned int Len)
1069 {
1070    if ((Str[0] & 0x80) == 0)
1071       return false;
1072    else
1073    {
1074       Res = Str[0] & 0x7F;
1075       for(unsigned int i = 1; i < Len; ++i)
1076          Res = (Res<<8) + Str[i];
1077       return true;
1078    }
1079 }
1080                                                                         /*}}}*/
1081 // Base256ToNum - Convert a fixed length binary to a number             /*{{{*/
1082 // ---------------------------------------------------------------------
1083 /* This is used in decoding the 256bit encoded fixed length fields in
1084    tar files */
1085 bool Base256ToNum(const char *Str,unsigned long &Res,unsigned int Len)
1086 {
1087    unsigned long long Num;
1088    bool rc;
1089
1090    rc = Base256ToNum(Str, Num, Len);
1091    Res = Num;
1092    if (Res != Num)
1093       return false;
1094
1095    return rc;
1096 }
1097                                                                         /*}}}*/
1098 // HexDigit - Convert a hex character into an integer                   /*{{{*/
1099 // ---------------------------------------------------------------------
1100 /* Helper for Hex2Num */
1101 static int HexDigit(int c)
1102 {
1103    if (c >= '0' && c <= '9')
1104       return c - '0';
1105    if (c >= 'a' && c <= 'f')
1106       return c - 'a' + 10;
1107    if (c >= 'A' && c <= 'F')
1108       return c - 'A' + 10;
1109    return -1;
1110 }
1111                                                                         /*}}}*/
1112 // Hex2Num - Convert a long hex number into a buffer                    /*{{{*/
1113 // ---------------------------------------------------------------------
1114 /* The length of the buffer must be exactly 1/2 the length of the string. */
1115 bool Hex2Num(const string &Str,unsigned char *Num,unsigned int Length)
1116 {
1117    return Hex2Num(APT::StringView(Str), Num, Length);
1118 }
1119
1120 bool Hex2Num(const APT::StringView Str,unsigned char *Num,unsigned int Length)
1121 {
1122    if (Str.length() != Length*2)
1123       return false;
1124
1125    // Convert each digit. We store it in the same order as the string
1126    int J = 0;
1127    for (auto I = Str.begin(); I != Str.end();J++, I += 2)
1128    {
1129       int first_half = HexDigit(I[0]);
1130       int second_half;
1131       if (first_half < 0)
1132          return false;
1133
1134       second_half = HexDigit(I[1]);
1135       if (second_half < 0)
1136          return false;
1137       Num[J] = first_half << 4;
1138       Num[J] += second_half;
1139    }
1140
1141    return true;
1142 }
1143                                                                         /*}}}*/
1144 // TokSplitString - Split a string up by a given token                  /*{{{*/
1145 // ---------------------------------------------------------------------
1146 /* This is intended to be a faster splitter, it does not use dynamic
1147    memories. Input is changed to insert nulls at each token location. */
1148 bool TokSplitString(char Tok,char *Input,char **List,
1149                     unsigned long ListMax)
1150 {
1151    // Strip any leading spaces
1152    char *Start = Input;
1153    char *Stop = Start + strlen(Start);
1154    for (; *Start != 0 && isspace(*Start) != 0; Start++);
1155
1156    unsigned long Count = 0;
1157    char *Pos = Start;
1158    while (Pos != Stop)
1159    {
1160       // Skip to the next Token
1161       for (; Pos != Stop && *Pos != Tok; Pos++);
1162
1163       // Back remove spaces
1164       char *End = Pos;
1165       for (; End > Start && (End[-1] == Tok || isspace(End[-1]) != 0); End--);
1166       *End = 0;
1167
1168       List[Count++] = Start;
1169       if (Count >= ListMax)
1170       {
1171          List[Count-1] = 0;
1172          return false;
1173       }
1174
1175       // Advance pos
1176       for (; Pos != Stop && (*Pos == Tok || isspace(*Pos) != 0 || *Pos == 0); Pos++);
1177       Start = Pos;
1178    }
1179
1180    List[Count] = 0;
1181    return true;
1182 }
1183                                                                         /*}}}*/
1184 // VectorizeString - Split a string up into a vector of strings         /*{{{*/
1185 // ---------------------------------------------------------------------
1186 /* This can be used to split a given string up into a vector, so the
1187    propose is the same as in the method above and this one is a bit slower
1188    also, but the advantage is that we have an iteratable vector */
1189 vector<string> VectorizeString(string const &haystack, char const &split)
1190 {
1191    vector<string> exploded;
1192    if (haystack.empty() == true)
1193       return exploded;
1194    string::const_iterator start = haystack.begin();
1195    string::const_iterator end = start;
1196    do {
1197       for (; end != haystack.end() && *end != split; ++end);
1198       exploded.push_back(string(start, end));
1199       start = end + 1;
1200    } while (end != haystack.end() && (++end) != haystack.end());
1201    return exploded;
1202 }
1203                                                                         /*}}}*/
1204 // StringSplit - split a string into a string vector by token           /*{{{*/
1205 // ---------------------------------------------------------------------
1206 /* See header for details.
1207  */
1208 vector<string> StringSplit(std::string const &s, std::string const &sep,
1209                            unsigned int maxsplit)
1210 {
1211    vector<string> split;
1212    size_t start, pos;
1213
1214    // no seperator given, this is bogus
1215    if(sep.size() == 0)
1216       return split;
1217
1218    start = pos = 0;
1219    while (pos != string::npos)
1220    {
1221       pos = s.find(sep, start);
1222       split.push_back(s.substr(start, pos-start));
1223
1224       // if maxsplit is reached, the remaining string is the last item
1225       if(split.size() >= maxsplit)
1226       {
1227          split[split.size()-1] = s.substr(start);
1228          break;
1229       }
1230       start = pos+sep.size();
1231    }
1232    return split;
1233 }
1234                                                                         /*}}}*/
1235 // RegexChoice - Simple regex list/list matcher                         /*{{{*/
1236 // ---------------------------------------------------------------------
1237 /* */
1238 unsigned long RegexChoice(RxChoiceList *Rxs,const char **ListBegin,
1239                       const char **ListEnd)
1240 {
1241    for (RxChoiceList *R = Rxs; R->Str != 0; R++)
1242       R->Hit = false;
1243
1244    unsigned long Hits = 0;
1245    for (; ListBegin < ListEnd; ++ListBegin)
1246    {
1247       // Check if the name is a regex
1248       const char *I;
1249       bool Regex = true;
1250       for (I = *ListBegin; *I != 0; I++)
1251          if (*I == '.' || *I == '?' || *I == '*' || *I == '|')
1252             break;
1253       if (*I == 0)
1254          Regex = false;
1255
1256       // Compile the regex pattern
1257       regex_t Pattern;
1258       if (Regex == true)
1259          if (regcomp(&Pattern,*ListBegin,REG_EXTENDED | REG_ICASE |
1260                      REG_NOSUB) != 0)
1261             Regex = false;
1262
1263       // Search the list
1264       bool Done = false;
1265       for (RxChoiceList *R = Rxs; R->Str != 0; R++)
1266       {
1267          if (R->Str[0] == 0)
1268             continue;
1269
1270          if (strcasecmp(R->Str,*ListBegin) != 0)
1271          {
1272             if (Regex == false)
1273                continue;
1274             if (regexec(&Pattern,R->Str,0,0,0) != 0)
1275                continue;
1276          }
1277          Done = true;
1278
1279          if (R->Hit == false)
1280             Hits++;
1281
1282          R->Hit = true;
1283       }
1284
1285       if (Regex == true)
1286          regfree(&Pattern);
1287
1288       if (Done == false)
1289          _error->Warning(_("Selection %s not found"),*ListBegin);
1290    }
1291
1292    return Hits;
1293 }
1294                                                                         /*}}}*/
1295 // {str,io}printf - C format string outputter to C++ strings/iostreams  /*{{{*/
1296 // ---------------------------------------------------------------------
1297 /* This is used to make the internationalization strings easier to translate
1298    and to allow reordering of parameters */
1299 static bool iovprintf(ostream &out, const char *format,
1300                       va_list &args, ssize_t &size) {
1301    char *S = (char*)malloc(size);
1302    ssize_t const n = vsnprintf(S, size, format, args);
1303    if (n > -1 && n < size) {
1304       out << S;
1305       free(S);
1306       return true;
1307    } else {
1308       if (n > -1)
1309          size = n + 1;
1310       else
1311          size *= 2;
1312    }
1313    free(S);
1314    return false;
1315 }
1316 void ioprintf(ostream &out,const char *format,...)
1317 {
1318    va_list args;
1319    ssize_t size = 400;
1320    while (true) {
1321       bool ret;
1322       va_start(args,format);
1323       ret = iovprintf(out, format, args, size);
1324       va_end(args);
1325       if (ret == true)
1326          return;
1327    }
1328 }
1329 void strprintf(string &out,const char *format,...)
1330 {
1331    va_list args;
1332    ssize_t size = 400;
1333    std::ostringstream outstr;
1334    while (true) {
1335       bool ret;
1336       va_start(args,format);
1337       ret = iovprintf(outstr, format, args, size);
1338       va_end(args);
1339       if (ret == true)
1340          break;
1341    }
1342    out = outstr.str();
1343 }
1344                                                                         /*}}}*/
1345 // safe_snprintf - Safer snprintf                                       /*{{{*/
1346 // ---------------------------------------------------------------------
1347 /* This is a snprintf that will never (ever) go past 'End' and returns a
1348    pointer to the end of the new string. The returned string is always null
1349    terminated unless Buffer == end. This is a better alterantive to using
1350    consecutive snprintfs. */
1351 char *safe_snprintf(char *Buffer,char *End,const char *Format,...)
1352 {
1353    va_list args;
1354    int Did;
1355
1356    if (End <= Buffer)
1357       return End;
1358    va_start(args,Format);
1359    Did = vsnprintf(Buffer,End - Buffer,Format,args);
1360    va_end(args);
1361
1362    if (Did < 0 || Buffer + Did > End)
1363       return End;
1364    return Buffer + Did;
1365 }
1366                                                                         /*}}}*/
1367 // StripEpoch - Remove the version "epoch" from a version string        /*{{{*/
1368 // ---------------------------------------------------------------------
1369 string StripEpoch(const string &VerStr)
1370 {
1371    size_t i = VerStr.find(":");
1372    if (i == string::npos)
1373       return VerStr;
1374    return VerStr.substr(i+1);
1375 }
1376                                                                         /*}}}*/
1377
1378 // tolower_ascii - tolower() function that ignores the locale           /*{{{*/
1379 // ---------------------------------------------------------------------
1380 /* This little function is the most called method we have and tries
1381    therefore to do the absolut minimum - and is notable faster than
1382    standard tolower/toupper and as a bonus avoids problems with different
1383    locales - we only operate on ascii chars anyway. */
1384 #undef tolower_ascii
1385 int tolower_ascii(int const c) APT_CONST APT_COLD;
1386 int tolower_ascii(int const c)
1387 {
1388    return tolower_ascii_inline(c);
1389 }
1390                                                                         /*}}}*/
1391
1392 // isspace_ascii - isspace() function that ignores the locale           /*{{{*/
1393 // ---------------------------------------------------------------------
1394 /* This little function is one of the most called methods we have and tries
1395    therefore to do the absolut minimum - and is notable faster than
1396    standard isspace() and as a bonus avoids problems with different
1397    locales - we only operate on ascii chars anyway. */
1398 #undef isspace_ascii
1399 int isspace_ascii(int const c) APT_CONST APT_COLD;
1400 int isspace_ascii(int const c)
1401 {
1402    return isspace_ascii_inline(c);
1403 }
1404                                                                         /*}}}*/
1405
1406 // CheckDomainList - See if Host is in a , separate list                /*{{{*/
1407 // ---------------------------------------------------------------------
1408 /* The domain list is a comma separate list of domains that are suffix
1409    matched against the argument */
1410 bool CheckDomainList(const string &Host,const string &List)
1411 {
1412    string::const_iterator Start = List.begin();
1413    for (string::const_iterator Cur = List.begin(); Cur <= List.end(); ++Cur)
1414    {
1415       if (Cur < List.end() && *Cur != ',')
1416          continue;
1417
1418       // Match the end of the string..
1419       if ((Host.size() >= (unsigned)(Cur - Start)) &&
1420           Cur - Start != 0 &&
1421           stringcasecmp(Host.end() - (Cur - Start),Host.end(),Start,Cur) == 0)
1422          return true;
1423
1424       Start = Cur + 1;
1425    }
1426    return false;
1427 }
1428                                                                         /*}}}*/
1429 // strv_length - Return the length of a NULL-terminated string array    /*{{{*/
1430 // ---------------------------------------------------------------------
1431 /* */
1432 size_t strv_length(const char **str_array)
1433 {
1434    size_t i;
1435    for (i=0; str_array[i] != NULL; i++)
1436       /* nothing */
1437       ;
1438    return i;
1439 }
1440                                                                         /*}}}*/
1441 // DeEscapeString - unescape (\0XX and \xXX) from a string              /*{{{*/
1442 // ---------------------------------------------------------------------
1443 /* */
1444 string DeEscapeString(const string &input)
1445 {
1446    char tmp[3];
1447    string::const_iterator it;
1448    string output;
1449    for (it = input.begin(); it != input.end(); ++it)
1450    {
1451       // just copy non-escape chars
1452       if (*it != '\\')
1453       {
1454          output += *it;
1455          continue;
1456       }
1457
1458       // deal with double escape
1459       if (*it == '\\' &&
1460           (it + 1 < input.end()) &&  it[1] == '\\')
1461       {
1462          // copy
1463          output += *it;
1464          // advance iterator one step further
1465          ++it;
1466          continue;
1467       }
1468
1469       // ensure we have a char to read
1470       if (it + 1 == input.end())
1471          continue;
1472
1473       // read it
1474       ++it;
1475       switch (*it)
1476       {
1477          case '0':
1478             if (it + 2 <= input.end()) {
1479                tmp[0] = it[1];
1480                tmp[1] = it[2];
1481                tmp[2] = 0;
1482                output += (char)strtol(tmp, 0, 8);
1483                it += 2;
1484             }
1485             break;
1486          case 'x':
1487             if (it + 2 <= input.end()) {
1488                tmp[0] = it[1];
1489                tmp[1] = it[2];
1490                tmp[2] = 0;
1491                output += (char)strtol(tmp, 0, 16);
1492                it += 2;
1493             }
1494             break;
1495          default:
1496             // FIXME: raise exception here?
1497             break;
1498       }
1499    }
1500    return output;
1501 }
1502                                                                         /*}}}*/
1503 // URI::CopyFrom - Copy from an object                                  /*{{{*/
1504 // ---------------------------------------------------------------------
1505 /* This parses the URI into all of its components */
1506 void URI::CopyFrom(const string &U)
1507 {
1508    string::const_iterator I = U.begin();
1509
1510    // Locate the first colon, this separates the scheme
1511    for (; I < U.end() && *I != ':' ; ++I);
1512    string::const_iterator FirstColon = I;
1513
1514    /* Determine if this is a host type URI with a leading double //
1515       and then search for the first single / */
1516    string::const_iterator SingleSlash = I;
1517    if (I + 3 < U.end() && I[1] == '/' && I[2] == '/')
1518       SingleSlash += 3;
1519
1520    /* Find the / indicating the end of the hostname, ignoring /'s in the
1521       square brackets */
1522    bool InBracket = false;
1523    for (; SingleSlash < U.end() && (*SingleSlash != '/' || InBracket == true); ++SingleSlash)
1524    {
1525       if (*SingleSlash == '[')
1526          InBracket = true;
1527       if (InBracket == true && *SingleSlash == ']')
1528          InBracket = false;
1529    }
1530
1531    if (SingleSlash > U.end())
1532       SingleSlash = U.end();
1533
1534    // We can now write the access and path specifiers
1535    Access.assign(U.begin(),FirstColon);
1536    if (SingleSlash != U.end())
1537       Path.assign(SingleSlash,U.end());
1538    if (Path.empty() == true)
1539       Path = "/";
1540
1541    // Now we attempt to locate a user:pass@host fragment
1542    if (FirstColon + 2 <= U.end() && FirstColon[1] == '/' && FirstColon[2] == '/')
1543       FirstColon += 3;
1544    else
1545       FirstColon += 1;
1546    if (FirstColon >= U.end())
1547       return;
1548
1549    if (FirstColon > SingleSlash)
1550       FirstColon = SingleSlash;
1551
1552    // Find the colon...
1553    I = FirstColon + 1;
1554    if (I > SingleSlash)
1555       I = SingleSlash;
1556    for (; I < SingleSlash && *I != ':'; ++I);
1557    string::const_iterator SecondColon = I;
1558
1559    // Search for the @ after the colon
1560    for (; I < SingleSlash && *I != '@'; ++I);
1561    string::const_iterator At = I;
1562
1563    // Now write the host and user/pass
1564    if (At == SingleSlash)
1565    {
1566       if (FirstColon < SingleSlash)
1567          Host.assign(FirstColon,SingleSlash);
1568    }
1569    else
1570    {
1571       Host.assign(At+1,SingleSlash);
1572       // username and password must be encoded (RFC 3986)
1573       User.assign(DeQuoteString(FirstColon,SecondColon));
1574       if (SecondColon < At)
1575          Password.assign(DeQuoteString(SecondColon+1,At));
1576    }
1577
1578    // Now we parse the RFC 2732 [] hostnames.
1579    unsigned long PortEnd = 0;
1580    InBracket = false;
1581    for (unsigned I = 0; I != Host.length();)
1582    {
1583       if (Host[I] == '[')
1584       {
1585          InBracket = true;
1586          Host.erase(I,1);
1587          continue;
1588       }
1589
1590       if (InBracket == true && Host[I] == ']')
1591       {
1592          InBracket = false;
1593          Host.erase(I,1);
1594          PortEnd = I;
1595          continue;
1596       }
1597       I++;
1598    }
1599
1600    // Tsk, weird.
1601    if (InBracket == true)
1602    {
1603       Host.clear();
1604       return;
1605    }
1606
1607    // Now we parse off a port number from the hostname
1608    Port = 0;
1609    string::size_type Pos = Host.rfind(':');
1610    if (Pos == string::npos || Pos < PortEnd)
1611       return;
1612
1613    Port = atoi(string(Host,Pos+1).c_str());
1614    Host.assign(Host,0,Pos);
1615 }
1616                                                                         /*}}}*/
1617 // URI::operator string - Convert the URI to a string                   /*{{{*/
1618 // ---------------------------------------------------------------------
1619 /* */
1620 URI::operator string()
1621 {
1622    std::stringstream Res;
1623
1624    if (Access.empty() == false)
1625       Res << Access << ':';
1626
1627    if (Host.empty() == false)
1628    {
1629       if (Access.empty() == false)
1630          Res << "//";
1631
1632       if (User.empty() == false)
1633       {
1634          // FIXME: Technically userinfo is permitted even less
1635          // characters than these, but this is not conveniently
1636          // expressed with a blacklist.
1637          Res << QuoteString(User, ":/?#[]@");
1638          if (Password.empty() == false)
1639             Res << ":" << QuoteString(Password, ":/?#[]@");
1640          Res << "@";
1641       }
1642
1643       // Add RFC 2732 escaping characters
1644       if (Access.empty() == false && Host.find_first_of("/:") != string::npos)
1645          Res << '[' << Host << ']';
1646       else
1647          Res << Host;
1648
1649       if (Port != 0)
1650          Res << ':' << Port;
1651    }
1652
1653    if (Path.empty() == false)
1654    {
1655       if (Path[0] != '/')
1656          Res << "/" << Path;
1657       else
1658          Res << Path;
1659    }
1660
1661    return Res.str();
1662 }
1663                                                                         /*}}}*/
1664 // URI::SiteOnly - Return the schema and site for the URI               /*{{{*/
1665 string URI::SiteOnly(const string &URI)
1666 {
1667    ::URI U(URI);
1668    U.User.clear();
1669    U.Password.clear();
1670    U.Path.clear();
1671    return U;
1672 }
1673                                                                         /*}}}*/
1674 // URI::ArchiveOnly - Return the schema, site and cleaned path for the URI /*{{{*/
1675 string URI::ArchiveOnly(const string &URI)
1676 {
1677    ::URI U(URI);
1678    U.User.clear();
1679    U.Password.clear();
1680    if (U.Path.empty() == false && U.Path[U.Path.length() - 1] == '/')
1681       U.Path.erase(U.Path.length() - 1);
1682    return U;
1683 }
1684                                                                         /*}}}*/
1685 // URI::NoUserPassword - Return the schema, site and path for the URI   /*{{{*/
1686 string URI::NoUserPassword(const string &URI)
1687 {
1688    ::URI U(URI);
1689    U.User.clear();
1690    U.Password.clear();
1691    return U;
1692 }
1693                                                                         /*}}}*/