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
 468    Temp.append(Str, OldPos, string::npos);
 469    return Temp;
 470 }
 471 string SubstVar(string Str,const struct SubstVar *Vars)
 472 {
 473    for (; Vars->Subst != 0; Vars++)
 474       Str = SubstVar(Str,Vars->Subst,*Vars->Contents);
 475    return Str;
 476 }
 477                                                                         /*}}}*/
 478 // OutputInDepth - return a string with separator multiplied with depth /*{{{*/
 479 // ---------------------------------------------------------------------
 480 /* Returns a string with the supplied separator depth + 1 times in it */
 481 std::string OutputInDepth(const unsigned long Depth, const char* Separator)
 482 {
 483    std::string output = "";
 484    for(unsigned long d=Depth+1; d > 0; d--)
 485       output.append(Separator);
 486    return output;
 487 }
 488                                                                         /*}}}*/
 489 // URItoFileName - Convert the uri into a unique file name              /*{{{*/
 490 // ---------------------------------------------------------------------
 491 /* This converts a URI into a safe filename. It quotes all unsafe characters
 492    and converts / to _ and removes the scheme identifier. The resulting
 493    file name should be unique and never occur again for a different file */
 494 string URItoFileName(const string &URI)
 495 {
 496    // Nuke 'sensitive' items
 497    ::URI U(URI);
 498    U.User.clear();
 499    U.Password.clear();
 500    U.Access.clear();
 501
 502    // "\x00-\x20{}|\\\\^\\[\\]<>\"\x7F-\xFF";
 503    string NewURI = QuoteString(U,"\\|{}[]<>\"^~_=!@#$%^&*");
 504    replace(NewURI.begin(),NewURI.end(),'/','_');
 505    return NewURI;
 506 }
 507                                                                         /*}}}*/
 508 // Base64Encode - Base64 Encoding routine for short strings             /*{{{*/
 509 // ---------------------------------------------------------------------
 510 /* This routine performs a base64 transformation on a string. It was ripped
 511    from wget and then patched and bug fixed.
 512
 513    This spec can be found in rfc2045 */
 514 string Base64Encode(const string &S)
 515 {
 516    // Conversion table.
 517    static char tbl[64] = {'A','B','C','D','E','F','G','H',
 518                           'I','J','K','L','M','N','O','P',
 519                           'Q','R','S','T','U','V','W','X',
 520                           'Y','Z','a','b','c','d','e','f',
 521                           'g','h','i','j','k','l','m','n',
 522                           'o','p','q','r','s','t','u','v',
 523                           'w','x','y','z','0','1','2','3',
 524                           '4','5','6','7','8','9','+','/'};
 525
 526    // Pre-allocate some space
 527    string Final;
 528    Final.reserve((4*S.length() + 2)/3 + 2);
 529
 530    /* Transform the 3x8 bits to 4x6 bits, as required by
 531       base64.  */
 532    for (string::const_iterator I = S.begin(); I < S.end(); I += 3)
 533    {
 534       char Bits[3] = {0,0,0};
 535       Bits[0] = I[0];
 536       if (I + 1 < S.end())
 537          Bits[1] = I[1];
 538       if (I + 2 < S.end())
 539          Bits[2] = I[2];
 540
 541       Final += tbl[Bits[0] >> 2];
 542       Final += tbl[((Bits[0] & 3) << 4) + (Bits[1] >> 4)];
 543
 544       if (I + 1 >= S.end())
 545          break;
 546
 547       Final += tbl[((Bits[1] & 0xf) << 2) + (Bits[2] >> 6)];
 548
 549       if (I + 2 >= S.end())
 550          break;
 551
 552       Final += tbl[Bits[2] & 0x3f];
 553    }
 554
 555    /* Apply the padding elements, this tells how many bytes the remote
 556       end should discard */
 557    if (S.length() % 3 == 2)
 558       Final += '=';
 559    if (S.length() % 3 == 1)
 560       Final += "==";
 561
 562    return Final;
 563 }
 564                                                                         /*}}}*/
 565 // stringcmp - Arbitrary string compare                                 /*{{{*/
 566 // ---------------------------------------------------------------------
 567 /* This safely compares two non-null terminated strings of arbitrary
 568    length */
 569 int stringcmp(const char *A,const char *AEnd,const char *B,const char *BEnd)
 570 {
 571    for (; A != AEnd && B != BEnd; A++, B++)
 572       if (*A != *B)
 573          break;
 574
 575    if (A == AEnd && B == BEnd)
 576       return 0;
 577    if (A == AEnd)
 578       return 1;
 579    if (B == BEnd)
 580       return -1;
 581    if (*A < *B)
 582       return -1;
 583    return 1;
 584 }
 585
 586 #if __GNUC__ >= 3
 587 int stringcmp(string::const_iterator A,string::const_iterator AEnd,
 588               const char *B,const char *BEnd)
 589 {
 590    for (; A != AEnd && B != BEnd; A++, B++)
 591       if (*A != *B)
 592          break;
 593
 594    if (A == AEnd && B == BEnd)
 595       return 0;
 596    if (A == AEnd)
 597       return 1;
 598    if (B == BEnd)
 599       return -1;
 600    if (*A < *B)
 601       return -1;
 602    return 1;
 603 }
 604 int stringcmp(string::const_iterator A,string::const_iterator AEnd,
 605               string::const_iterator B,string::const_iterator BEnd)
 606 {
 607    for (; A != AEnd && B != BEnd; A++, B++)
 608       if (*A != *B)
 609          break;
 610
 611    if (A == AEnd && B == BEnd)
 612       return 0;
 613    if (A == AEnd)
 614       return 1;
 615    if (B == BEnd)
 616       return -1;
 617    if (*A < *B)
 618       return -1;
 619    return 1;
 620 }
 621 #endif
 622                                                                         /*}}}*/
 623 // stringcasecmp - Arbitrary case insensitive string compare            /*{{{*/
 624 // ---------------------------------------------------------------------
 625 /* */
 626 int stringcasecmp(const char *A,const char *AEnd,const char *B,const char *BEnd)
 627 {
 628    for (; A != AEnd && B != BEnd; A++, B++)
 629       if (tolower_ascii(*A) != tolower_ascii(*B))
 630          break;
 631
 632    if (A == AEnd && B == BEnd)
 633       return 0;
 634    if (A == AEnd)
 635       return 1;
 636    if (B == BEnd)
 637       return -1;
 638    if (tolower_ascii(*A) < tolower_ascii(*B))
 639       return -1;
 640    return 1;
 641 }
 642 #if __GNUC__ >= 3
 643 int stringcasecmp(string::const_iterator A,string::const_iterator AEnd,
 644                   const char *B,const char *BEnd)
 645 {
 646    for (; A != AEnd && B != BEnd; A++, B++)
 647       if (tolower_ascii(*A) != tolower_ascii(*B))
 648          break;
 649
 650    if (A == AEnd && B == BEnd)
 651       return 0;
 652    if (A == AEnd)
 653       return 1;
 654    if (B == BEnd)
 655       return -1;
 656    if (tolower_ascii(*A) < tolower_ascii(*B))
 657       return -1;
 658    return 1;
 659 }
 660 int stringcasecmp(string::const_iterator A,string::const_iterator AEnd,
 661                   string::const_iterator B,string::const_iterator BEnd)
 662 {
 663    for (; A != AEnd && B != BEnd; A++, B++)
 664       if (tolower_ascii(*A) != tolower_ascii(*B))
 665          break;
 666
 667    if (A == AEnd && B == BEnd)
 668       return 0;
 669    if (A == AEnd)
 670       return 1;
 671    if (B == BEnd)
 672       return -1;
 673    if (tolower_ascii(*A) < tolower_ascii(*B))
 674       return -1;
 675    return 1;
 676 }
 677 #endif
 678                                                                         /*}}}*/
 679 // LookupTag - Lookup the value of a tag in a taged string              /*{{{*/
 680 // ---------------------------------------------------------------------
 681 /* The format is like those used in package files and the method
 682    communication system */
 683 string LookupTag(const string &Message,const char *Tag,const char *Default)
 684 {
 685    // Look for a matching tag.
 686    int Length = strlen(Tag);
 687    for (string::const_iterator I = Message.begin(); I + Length < Message.end(); ++I)
 688    {
 689       // Found the tag
 690       if (I[Length] == ':' && stringcasecmp(I,I+Length,Tag) == 0)
 691       {
 692          // Find the end of line and strip the leading/trailing spaces
 693          string::const_iterator J;
 694          I += Length + 1;
 695          for (; isspace_ascii(*I) != 0 && I < Message.end(); ++I);
 696          for (J = I; *J != '\n' && J < Message.end(); ++J);
 697          for (; J > I && isspace_ascii(J[-1]) != 0; --J);
 698
 699          return string(I,J);
 700       }
 701
 702       for (; *I != '\n' && I < Message.end(); ++I);
 703    }
 704
 705    // Failed to find a match
 706    if (Default == 0)
 707       return string();
 708    return Default;
 709 }
 710                                                                         /*}}}*/
 711 // StringToBool - Converts a string into a boolean                      /*{{{*/
 712 // ---------------------------------------------------------------------
 713 /* This inspects the string to see if it is true or if it is false and
 714    then returns the result. Several varients on true/false are checked. */
 715 int StringToBool(const string &Text,int Default)
 716 {
 717    char *ParseEnd;
 718    int Res = strtol(Text.c_str(),&ParseEnd,0);
 719    // ensure that the entire string was converted by strtol to avoid
 720    // failures on "apt-cache show -a 0ad" where the "0" is converted
 721    const char *TextEnd = Text.c_str()+Text.size();
 722    if (ParseEnd == TextEnd && Res >= 0 && Res <= 1)
 723       return Res;
 724
 725    // Check for positives
 726    if (strcasecmp(Text.c_str(),"no") == 0 ||
 727        strcasecmp(Text.c_str(),"false") == 0 ||
 728        strcasecmp(Text.c_str(),"without") == 0 ||
 729        strcasecmp(Text.c_str(),"off") == 0 ||
 730        strcasecmp(Text.c_str(),"disable") == 0)
 731       return 0;
 732
 733    // Check for negatives
 734    if (strcasecmp(Text.c_str(),"yes") == 0 ||
 735        strcasecmp(Text.c_str(),"true") == 0 ||
 736        strcasecmp(Text.c_str(),"with") == 0 ||
 737        strcasecmp(Text.c_str(),"on") == 0 ||
 738        strcasecmp(Text.c_str(),"enable") == 0)
 739       return 1;
 740
 741    return Default;
 742 }
 743                                                                         /*}}}*/
 744 // TimeRFC1123 - Convert a time_t into RFC1123 format                   /*{{{*/
 745 // ---------------------------------------------------------------------
 746 /* This converts a time_t into a string time representation that is
 747    year 2000 complient and timezone neutral */
 748 string TimeRFC1123(time_t Date)
 749 {
 750    struct tm Conv;
 751    if (gmtime_r(&Date, &Conv) == NULL)
 752       return "";
 753
 754    char Buf[300];
 755    const char *Day[] = {"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
 756    const char *Month[] = {"Jan","Feb","Mar","Apr","May","Jun","Jul",
 757                           "Aug","Sep","Oct","Nov","Dec"};
 758
 759    snprintf(Buf, sizeof(Buf), "%s, %02i %s %i %02i:%02i:%02i GMT",Day[Conv.tm_wday],
 760            Conv.tm_mday,Month[Conv.tm_mon],Conv.tm_year+1900,Conv.tm_hour,
 761            Conv.tm_min,Conv.tm_sec);
 762    return Buf;
 763 }
 764                                                                         /*}}}*/
 765 // ReadMessages - Read messages from the FD                             /*{{{*/
 766 // ---------------------------------------------------------------------
 767 /* This pulls full messages from the input FD into the message buffer.
 768    It assumes that messages will not pause during transit so no
 769    fancy buffering is used.
 770
 771    In particular: this reads blocks from the input until it believes
 772    that it's run out of input text.  Each block is terminated by a
 773    double newline ('\n' followed by '\n').
 774  */
 775 bool ReadMessages(int Fd, vector<string> &List)
 776 {
 777    char Buffer[64000];
 778    // Represents any left-over from the previous iteration of the
 779    // parse loop.  (i.e., if a message is split across the end
 780    // of the buffer, it goes here)
 781    string PartialMessage;
 782
 783    do {
 784       int const Res = read(Fd, Buffer, sizeof(Buffer));
 785       if (Res < 0 && errno == EINTR)
 786          continue;
 787
 788       // process we read from has died
 789       if (Res == 0)
 790          return false;
 791
 792       // No data
 793 #if EAGAIN != EWOULDBLOCK
 794       if (Res < 0 && (errno == EAGAIN || errno == EWOULDBLOCK))
 795 #else
 796       if (Res < 0 && errno == EAGAIN)
 797 #endif
 798          return true;
 799       if (Res < 0)
 800          return false;
 801
 802       // extract the message(s) from the buffer
 803       char const *Start = Buffer;
 804       char const * const End = Buffer + Res;
 805
 806       char const * NL = (char const *) memchr(Start, '\n', End - Start);
 807       if (NL == NULL)
 808       {
 809          // end of buffer: store what we have so far and read new data in
 810          PartialMessage.append(Start, End - Start);
 811          Start = End;
 812       }
 813       else
 814          ++NL;
 815
 816       if (PartialMessage.empty() == false && Start < End)
 817       {
 818          // if we start with a new line, see if the partial message we have ended with one
 819          // so that we properly detect records ending between two read() runs
 820          // cases are: \n|\n  ,  \r\n|\r\n  and  \r\n\r|\n
 821          // the case \r|\n\r\n is handled by the usual double-newline handling
 822          if ((NL - Start) == 1 || ((NL - Start) == 2 && *Start == '\r'))
 823          {
 824             if (APT::String::Endswith(PartialMessage, "\n") || APT::String::Endswith(PartialMessage, "\r\n\r"))
 825             {
 826                PartialMessage.erase(PartialMessage.find_last_not_of("\r\n") + 1);
 827                List.push_back(PartialMessage);
 828                PartialMessage.clear();
 829                while (NL < End && (*NL == '\n' || *NL == '\r')) ++NL;
 830                Start = NL;
 831             }
 832          }
 833       }
 834
 835       while (Start < End) {
 836          char const * NL2 = (char const *) memchr(NL, '\n', End - NL);
 837          if (NL2 == NULL)
 838          {
 839             // end of buffer: store what we have so far and read new data in
 840             PartialMessage.append(Start, End - Start);
 841             break;
 842          }
 843          ++NL2;
 844
 845          // did we find a double newline?
 846          if ((NL2 - NL) == 1 || ((NL2 - NL) == 2 && *NL == '\r'))
 847          {
 848             PartialMessage.append(Start, NL2 - Start);
 849             PartialMessage.erase(PartialMessage.find_last_not_of("\r\n") + 1);
 850             List.push_back(PartialMessage);
 851             PartialMessage.clear();
 852             while (NL2 < End && (*NL2 == '\n' || *NL2 == '\r')) ++NL2;
 853             Start = NL2;
 854          }
 855          NL = NL2;
 856       }
 857
 858       // we have read at least one complete message and nothing left
 859       if (PartialMessage.empty() == true)
 860          return true;
 861
 862       if (WaitFd(Fd) == false)
 863          return false;
 864    } while (true);
 865 }
 866                                                                         /*}}}*/
 867 // MonthConv - Converts a month string into a number                    /*{{{*/
 868 // ---------------------------------------------------------------------
 869 /* This was lifted from the boa webserver which lifted it from 'wn-v1.07'
 870    Made it a bit more robust with a few tolower_ascii though. */
 871 static int MonthConv(char *Month)
 872 {
 873    switch (tolower_ascii(*Month))
 874    {
 875       case 'a':
 876       return tolower_ascii(Month[1]) == 'p'?3:7;
 877       case 'd':
 878       return 11;
 879       case 'f':
 880       return 1;
 881       case 'j':
 882       if (tolower_ascii(Month[1]) == 'a')
 883          return 0;
 884       return tolower_ascii(Month[2]) == 'n'?5:6;
 885       case 'm':
 886       return tolower_ascii(Month[2]) == 'r'?2:4;
 887       case 'n':
 888       return 10;
 889       case 'o':
 890       return 9;
 891       case 's':
 892       return 8;
 893
 894       // Pretend it is January..
 895       default:
 896       return 0;
 897    }
 898 }
 899                                                                         /*}}}*/
 900 // timegm - Internal timegm if the gnu version is not available         /*{{{*/
 901 // ---------------------------------------------------------------------
 902 /* Converts struct tm to time_t, assuming the data in tm is UTC rather
 903    than local timezone (mktime assumes the latter).
 904
 905    This function is a nonstandard GNU extension that is also present on
 906    the BSDs and maybe other systems. For others we follow the advice of
 907    the manpage of timegm and use his portable replacement. */
 908 #ifndef HAVE_TIMEGM
 909 static time_t timegm(struct tm *t)
 910 {
 911    char *tz = getenv("TZ");
 912    setenv("TZ", "", 1);
 913    tzset();
 914    time_t ret = mktime(t);
 915    if (tz)
 916       setenv("TZ", tz, 1);
 917    else
 918       unsetenv("TZ");
 919    tzset();
 920    return ret;
 921 }
 922 #endif
 923                                                                         /*}}}*/
 924 // FullDateToTime - Converts a HTTP1.1 full date strings into a time_t  /*{{{*/
 925 // ---------------------------------------------------------------------
 926 /* tries to parses a full date as specified in RFC2616 Section 3.3.1
 927    with one exception: All timezones (%Z) are accepted but the protocol
 928    says that it MUST be GMT, but this one is equal to UTC which we will
 929    encounter from time to time (e.g. in Release files) so we accept all
 930    here and just assume it is GMT (or UTC) later on */
 931 bool RFC1123StrToTime(const char* const str,time_t &time)
 932 {
 933    struct tm Tm;
 934    setlocale (LC_ALL,"C");
 935    bool const invalid =
 936    // Sun, 06 Nov 1994 08:49:37 GMT  ; RFC 822, updated by RFC 1123
 937       (strptime(str, "%a, %d %b %Y %H:%M:%S %Z", &Tm) == NULL &&
 938    // Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036
 939        strptime(str, "%A, %d-%b-%y %H:%M:%S %Z", &Tm) == NULL &&
 940    // Sun Nov  6 08:49:37 1994       ; ANSI C's asctime() format
 941        strptime(str, "%a %b %d %H:%M:%S %Y", &Tm) == NULL);
 942    setlocale (LC_ALL,"");
 943    if (invalid == true)
 944       return false;
 945
 946    time = timegm(&Tm);
 947    return true;
 948 }
 949                                                                         /*}}}*/
 950 // FTPMDTMStrToTime - Converts a ftp modification date into a time_t    /*{{{*/
 951 // ---------------------------------------------------------------------
 952 /* */
 953 bool FTPMDTMStrToTime(const char* const str,time_t &time)
 954 {
 955    struct tm Tm;
 956    // MDTM includes no whitespaces but recommend and ignored by strptime
 957    if (strptime(str, "%Y %m %d %H %M %S", &Tm) == NULL)
 958       return false;
 959
 960    time = timegm(&Tm);
 961    return true;
 962 }
 963                                                                         /*}}}*/
 964 // StrToTime - Converts a string into a time_t                          /*{{{*/
 965 // ---------------------------------------------------------------------
 966 /* This handles all 3 popular time formats including RFC 1123, RFC 1036
 967    and the C library asctime format. It requires the GNU library function
 968    'timegm' to convert a struct tm in UTC to a time_t. For some bizzar
 969    reason the C library does not provide any such function :< This also
 970    handles the weird, but unambiguous FTP time format*/
 971 bool StrToTime(const string &Val,time_t &Result)
 972 {
 973    struct tm Tm;
 974    char Month[10];
 975
 976    // Skip the day of the week
 977    const char *I = strchr(Val.c_str(), ' ');
 978
 979    // Handle RFC 1123 time
 980    Month[0] = 0;
 981    if (sscanf(I," %2d %3s %4d %2d:%2d:%2d GMT",&Tm.tm_mday,Month,&Tm.tm_year,
 982               &Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec) != 6)
 983    {
 984       // Handle RFC 1036 time
 985       if (sscanf(I," %2d-%3s-%3d %2d:%2d:%2d GMT",&Tm.tm_mday,Month,
 986                  &Tm.tm_year,&Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec) == 6)
 987          Tm.tm_year += 1900;
 988       else
 989       {
 990          // asctime format
 991          if (sscanf(I," %3s %2d %2d:%2d:%2d %4d",Month,&Tm.tm_mday,
 992                     &Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec,&Tm.tm_year) != 6)
 993          {
 994             // 'ftp' time
 995             if (sscanf(Val.c_str(),"%4d%2d%2d%2d%2d%2d",&Tm.tm_year,&Tm.tm_mon,
 996                        &Tm.tm_mday,&Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec) != 6)
 997                return false;
 998             Tm.tm_mon--;
 999          }
1000       }
1001    }
1002
1003    Tm.tm_isdst = 0;
1004    if (Month[0] != 0)
1005       Tm.tm_mon = MonthConv(Month);
1006    else
1007       Tm.tm_mon = 0; // we don't have a month, so pick something
1008    Tm.tm_year -= 1900;
1009
1010    // Convert to local time and then to GMT
1011    Result = timegm(&Tm);
1012    return true;
1013 }
1014                                                                         /*}}}*/
1015 // StrToNum - Convert a fixed length string to a number                 /*{{{*/
1016 // ---------------------------------------------------------------------
1017 /* This is used in decoding the crazy fixed length string headers in
1018    tar and ar files. */
1019 bool StrToNum(const char *Str,unsigned long &Res,unsigned Len,unsigned Base)
1020 {
1021    char S[30];
1022    if (Len >= sizeof(S))
1023       return false;
1024    memcpy(S,Str,Len);
1025    S[Len] = 0;
1026
1027    // All spaces is a zero
1028    Res = 0;
1029    unsigned I;
1030    for (I = 0; S[I] == ' '; I++);
1031    if (S[I] == 0)
1032       return true;
1033
1034    char *End;
1035    Res = strtoul(S,&End,Base);
1036    if (End == S)
1037       return false;
1038
1039    return true;
1040 }
1041                                                                         /*}}}*/
1042 // StrToNum - Convert a fixed length string to a number                 /*{{{*/
1043 // ---------------------------------------------------------------------
1044 /* This is used in decoding the crazy fixed length string headers in
1045    tar and ar files. */
1046 bool StrToNum(const char *Str,unsigned long long &Res,unsigned Len,unsigned Base)
1047 {
1048    char S[30];
1049    if (Len >= sizeof(S))
1050       return false;
1051    memcpy(S,Str,Len);
1052    S[Len] = 0;
1053
1054    // All spaces is a zero
1055    Res = 0;
1056    unsigned I;
1057    for (I = 0; S[I] == ' '; I++);
1058    if (S[I] == 0)
1059       return true;
1060
1061    char *End;
1062    Res = strtoull(S,&End,Base);
1063    if (End == S)
1064       return false;
1065
1066    return true;
1067 }
1068                                                                         /*}}}*/
1069
1070 // Base256ToNum - Convert a fixed length binary to a number             /*{{{*/
1071 // ---------------------------------------------------------------------
1072 /* This is used in decoding the 256bit encoded fixed length fields in
1073    tar files */
1074 bool Base256ToNum(const char *Str,unsigned long long &Res,unsigned int Len)
1075 {
1076    if ((Str[0] & 0x80) == 0)
1077       return false;
1078    else
1079    {
1080       Res = Str[0] & 0x7F;
1081       for(unsigned int i = 1; i < Len; ++i)
1082          Res = (Res<<8) + Str[i];
1083       return true;
1084    }
1085 }
1086                                                                         /*}}}*/
1087 // Base256ToNum - Convert a fixed length binary to a number             /*{{{*/
1088 // ---------------------------------------------------------------------
1089 /* This is used in decoding the 256bit encoded fixed length fields in
1090    tar files */
1091 bool Base256ToNum(const char *Str,unsigned long &Res,unsigned int Len)
1092 {
1093    unsigned long long Num;
1094    bool rc;
1095
1096    rc = Base256ToNum(Str, Num, Len);
1097    Res = Num;
1098    if (Res != Num)
1099       return false;
1100
1101    return rc;
1102 }
1103                                                                         /*}}}*/
1104 // HexDigit - Convert a hex character into an integer                   /*{{{*/
1105 // ---------------------------------------------------------------------
1106 /* Helper for Hex2Num */
1107 static int HexDigit(int c)
1108 {
1109    if (c >= '0' && c <= '9')
1110       return c - '0';
1111    if (c >= 'a' && c <= 'f')
1112       return c - 'a' + 10;
1113    if (c >= 'A' && c <= 'F')
1114       return c - 'A' + 10;
1115    return -1;
1116 }
1117                                                                         /*}}}*/
1118 // Hex2Num - Convert a long hex number into a buffer                    /*{{{*/
1119 // ---------------------------------------------------------------------
1120 /* The length of the buffer must be exactly 1/2 the length of the string. */
1121 bool Hex2Num(const string &Str,unsigned char *Num,unsigned int Length)
1122 {
1123    return Hex2Num(APT::StringView(Str), Num, Length);
1124 }
1125
1126 bool Hex2Num(const APT::StringView Str,unsigned char *Num,unsigned int Length)
1127 {
1128    if (Str.length() != Length*2)
1129       return false;
1130
1131    // Convert each digit. We store it in the same order as the string
1132    int J = 0;
1133    for (auto I = Str.begin(); I != Str.end();J++, I += 2)
1134    {
1135       int first_half = HexDigit(I[0]);
1136       int second_half;
1137       if (first_half < 0)
1138          return false;
1139
1140       second_half = HexDigit(I[1]);
1141       if (second_half < 0)
1142          return false;
1143       Num[J] = first_half << 4;
1144       Num[J] += second_half;
1145    }
1146
1147    return true;
1148 }
1149                                                                         /*}}}*/
1150 // TokSplitString - Split a string up by a given token                  /*{{{*/
1151 // ---------------------------------------------------------------------
1152 /* This is intended to be a faster splitter, it does not use dynamic
1153    memories. Input is changed to insert nulls at each token location. */
1154 bool TokSplitString(char Tok,char *Input,char **List,
1155                     unsigned long ListMax)
1156 {
1157    // Strip any leading spaces
1158    char *Start = Input;
1159    char *Stop = Start + strlen(Start);
1160    for (; *Start != 0 && isspace(*Start) != 0; Start++);
1161
1162    unsigned long Count = 0;
1163    char *Pos = Start;
1164    while (Pos != Stop)
1165    {
1166       // Skip to the next Token
1167       for (; Pos != Stop && *Pos != Tok; Pos++);
1168
1169       // Back remove spaces
1170       char *End = Pos;
1171       for (; End > Start && (End[-1] == Tok || isspace(End[-1]) != 0); End--);
1172       *End = 0;
1173
1174       List[Count++] = Start;
1175       if (Count >= ListMax)
1176       {
1177          List[Count-1] = 0;
1178          return false;
1179       }
1180
1181       // Advance pos
1182       for (; Pos != Stop && (*Pos == Tok || isspace(*Pos) != 0 || *Pos == 0); Pos++);
1183       Start = Pos;
1184    }
1185
1186    List[Count] = 0;
1187    return true;
1188 }
1189                                                                         /*}}}*/
1190 // VectorizeString - Split a string up into a vector of strings         /*{{{*/
1191 // ---------------------------------------------------------------------
1192 /* This can be used to split a given string up into a vector, so the
1193    propose is the same as in the method above and this one is a bit slower
1194    also, but the advantage is that we have an iteratable vector */
1195 vector<string> VectorizeString(string const &haystack, char const &split)
1196 {
1197    vector<string> exploded;
1198    if (haystack.empty() == true)
1199       return exploded;
1200    string::const_iterator start = haystack.begin();
1201    string::const_iterator end = start;
1202    do {
1203       for (; end != haystack.end() && *end != split; ++end);
1204       exploded.push_back(string(start, end));
1205       start = end + 1;
1206    } while (end != haystack.end() && (++end) != haystack.end());
1207    return exploded;
1208 }
1209                                                                         /*}}}*/
1210 // StringSplit - split a string into a string vector by token           /*{{{*/
1211 // ---------------------------------------------------------------------
1212 /* See header for details.
1213  */
1214 vector<string> StringSplit(std::string const &s, std::string const &sep,
1215                            unsigned int maxsplit)
1216 {
1217    vector<string> split;
1218    size_t start, pos;
1219
1220    // no seperator given, this is bogus
1221    if(sep.size() == 0)
1222       return split;
1223
1224    start = pos = 0;
1225    while (pos != string::npos)
1226    {
1227       pos = s.find(sep, start);
1228       split.push_back(s.substr(start, pos-start));
1229
1230       // if maxsplit is reached, the remaining string is the last item
1231       if(split.size() >= maxsplit)
1232       {
1233          split[split.size()-1] = s.substr(start);
1234          break;
1235       }
1236       start = pos+sep.size();
1237    }
1238    return split;
1239 }
1240                                                                         /*}}}*/
1241 // RegexChoice - Simple regex list/list matcher                         /*{{{*/
1242 // ---------------------------------------------------------------------
1243 /* */
1244 unsigned long RegexChoice(RxChoiceList *Rxs,const char **ListBegin,
1245                       const char **ListEnd)
1246 {
1247    for (RxChoiceList *R = Rxs; R->Str != 0; R++)
1248       R->Hit = false;
1249
1250    unsigned long Hits = 0;
1251    for (; ListBegin < ListEnd; ++ListBegin)
1252    {
1253       // Check if the name is a regex
1254       const char *I;
1255       bool Regex = true;
1256       for (I = *ListBegin; *I != 0; I++)
1257          if (*I == '.' || *I == '?' || *I == '*' || *I == '|')
1258             break;
1259       if (*I == 0)
1260          Regex = false;
1261
1262       // Compile the regex pattern
1263       regex_t Pattern;
1264       if (Regex == true)
1265          if (regcomp(&Pattern,*ListBegin,REG_EXTENDED | REG_ICASE |
1266                      REG_NOSUB) != 0)
1267             Regex = false;
1268
1269       // Search the list
1270       bool Done = false;
1271       for (RxChoiceList *R = Rxs; R->Str != 0; R++)
1272       {
1273          if (R->Str[0] == 0)
1274             continue;
1275
1276          if (strcasecmp(R->Str,*ListBegin) != 0)
1277          {
1278             if (Regex == false)
1279                continue;
1280             if (regexec(&Pattern,R->Str,0,0,0) != 0)
1281                continue;
1282          }
1283          Done = true;
1284
1285          if (R->Hit == false)
1286             Hits++;
1287
1288          R->Hit = true;
1289       }
1290
1291       if (Regex == true)
1292          regfree(&Pattern);
1293
1294       if (Done == false)
1295          _error->Warning(_("Selection %s not found"),*ListBegin);
1296    }
1297
1298    return Hits;
1299 }
1300                                                                         /*}}}*/
1301 // {str,io}printf - C format string outputter to C++ strings/iostreams  /*{{{*/
1302 // ---------------------------------------------------------------------
1303 /* This is used to make the internationalization strings easier to translate
1304    and to allow reordering of parameters */
1305 static bool iovprintf(ostream &out, const char *format,
1306                       va_list &args, ssize_t &size) {
1307    char *S = (char*)malloc(size);
1308    ssize_t const n = vsnprintf(S, size, format, args);
1309    if (n > -1 && n < size) {
1310       out << S;
1311       free(S);
1312       return true;
1313    } else {
1314       if (n > -1)
1315          size = n + 1;
1316       else
1317          size *= 2;
1318    }
1319    free(S);
1320    return false;
1321 }
1322 void ioprintf(ostream &out,const char *format,...)
1323 {
1324    va_list args;
1325    ssize_t size = 400;
1326    while (true) {
1327       bool ret;
1328       va_start(args,format);
1329       ret = iovprintf(out, format, args, size);
1330       va_end(args);
1331       if (ret == true)
1332          return;
1333    }
1334 }
1335 void strprintf(string &out,const char *format,...)
1336 {
1337    va_list args;
1338    ssize_t size = 400;
1339    std::ostringstream outstr;
1340    while (true) {
1341       bool ret;
1342       va_start(args,format);
1343       ret = iovprintf(outstr, format, args, size);
1344       va_end(args);
1345       if (ret == true)
1346          break;
1347    }
1348    out = outstr.str();
1349 }
1350                                                                         /*}}}*/
1351 // safe_snprintf - Safer snprintf                                       /*{{{*/
1352 // ---------------------------------------------------------------------
1353 /* This is a snprintf that will never (ever) go past 'End' and returns a
1354    pointer to the end of the new string. The returned string is always null
1355    terminated unless Buffer == end. This is a better alterantive to using
1356    consecutive snprintfs. */
1357 char *safe_snprintf(char *Buffer,char *End,const char *Format,...)
1358 {
1359    va_list args;
1360    int Did;
1361
1362    if (End <= Buffer)
1363       return End;
1364    va_start(args,Format);
1365    Did = vsnprintf(Buffer,End - Buffer,Format,args);
1366    va_end(args);
1367
1368    if (Did < 0 || Buffer + Did > End)
1369       return End;
1370    return Buffer + Did;
1371 }
1372                                                                         /*}}}*/
1373 // StripEpoch - Remove the version "epoch" from a version string        /*{{{*/
1374 // ---------------------------------------------------------------------
1375 string StripEpoch(const string &VerStr)
1376 {
1377    size_t i = VerStr.find(":");
1378    if (i == string::npos)
1379       return VerStr;
1380    return VerStr.substr(i+1);
1381 }
1382                                                                         /*}}}*/
1383
1384 // tolower_ascii - tolower() function that ignores the locale           /*{{{*/
1385 // ---------------------------------------------------------------------
1386 /* This little function is the most called method we have and tries
1387    therefore to do the absolut minimum - and is notable faster than
1388    standard tolower/toupper and as a bonus avoids problems with different
1389    locales - we only operate on ascii chars anyway. */
1390 #undef tolower_ascii
1391 int tolower_ascii(int const c) APT_CONST APT_COLD;
1392 int tolower_ascii(int const c)
1393 {
1394    return tolower_ascii_inline(c);
1395 }
1396                                                                         /*}}}*/
1397
1398 // isspace_ascii - isspace() function that ignores the locale           /*{{{*/
1399 // ---------------------------------------------------------------------
1400 /* This little function is one of the most called methods we have and tries
1401    therefore to do the absolut minimum - and is notable faster than
1402    standard isspace() and as a bonus avoids problems with different
1403    locales - we only operate on ascii chars anyway. */
1404 #undef isspace_ascii
1405 int isspace_ascii(int const c) APT_CONST APT_COLD;
1406 int isspace_ascii(int const c)
1407 {
1408    return isspace_ascii_inline(c);
1409 }
1410                                                                         /*}}}*/
1411
1412 // CheckDomainList - See if Host is in a , separate list                /*{{{*/
1413 // ---------------------------------------------------------------------
1414 /* The domain list is a comma separate list of domains that are suffix
1415    matched against the argument */
1416 bool CheckDomainList(const string &Host,const string &List)
1417 {
1418    string::const_iterator Start = List.begin();
1419    for (string::const_iterator Cur = List.begin(); Cur <= List.end(); ++Cur)
1420    {
1421       if (Cur < List.end() && *Cur != ',')
1422          continue;
1423
1424       // Match the end of the string..
1425       if ((Host.size() >= (unsigned)(Cur - Start)) &&
1426           Cur - Start != 0 &&
1427           stringcasecmp(Host.end() - (Cur - Start),Host.end(),Start,Cur) == 0)
1428          return true;
1429
1430       Start = Cur + 1;
1431    }
1432    return false;
1433 }
1434                                                                         /*}}}*/
1435 // strv_length - Return the length of a NULL-terminated string array    /*{{{*/
1436 // ---------------------------------------------------------------------
1437 /* */
1438 size_t strv_length(const char **str_array)
1439 {
1440    size_t i;
1441    for (i=0; str_array[i] != NULL; i++)
1442       /* nothing */
1443       ;
1444    return i;
1445 }
1446                                                                         /*}}}*/
1447 // DeEscapeString - unescape (\0XX and \xXX) from a string              /*{{{*/
1448 // ---------------------------------------------------------------------
1449 /* */
1450 string DeEscapeString(const string &input)
1451 {
1452    char tmp[3];
1453    string::const_iterator it;
1454    string output;
1455    for (it = input.begin(); it != input.end(); ++it)
1456    {
1457       // just copy non-escape chars
1458       if (*it != '\\')
1459       {
1460          output += *it;
1461          continue;
1462       }
1463
1464       // deal with double escape
1465       if (*it == '\\' &&
1466           (it + 1 < input.end()) &&  it[1] == '\\')
1467       {
1468          // copy
1469          output += *it;
1470          // advance iterator one step further
1471          ++it;
1472          continue;
1473       }
1474
1475       // ensure we have a char to read
1476       if (it + 1 == input.end())
1477          continue;
1478
1479       // read it
1480       ++it;
1481       switch (*it)
1482       {
1483          case '0':
1484             if (it + 2 <= input.end()) {
1485                tmp[0] = it[1];
1486                tmp[1] = it[2];
1487                tmp[2] = 0;
1488                output += (char)strtol(tmp, 0, 8);
1489                it += 2;
1490             }
1491             break;
1492          case 'x':
1493             if (it + 2 <= input.end()) {
1494                tmp[0] = it[1];
1495                tmp[1] = it[2];
1496                tmp[2] = 0;
1497                output += (char)strtol(tmp, 0, 16);
1498                it += 2;
1499             }
1500             break;
1501          default:
1502             // FIXME: raise exception here?
1503             break;
1504       }
1505    }
1506    return output;
1507 }
1508                                                                         /*}}}*/
1509 // URI::CopyFrom - Copy from an object                                  /*{{{*/
1510 // ---------------------------------------------------------------------
1511 /* This parses the URI into all of its components */
1512 void URI::CopyFrom(const string &U)
1513 {
1514    string::const_iterator I = U.begin();
1515
1516    // Locate the first colon, this separates the scheme
1517    for (; I < U.end() && *I != ':' ; ++I);
1518    string::const_iterator FirstColon = I;
1519
1520    /* Determine if this is a host type URI with a leading double //
1521       and then search for the first single / */
1522    string::const_iterator SingleSlash = I;
1523    if (I + 3 < U.end() && I[1] == '/' && I[2] == '/')
1524       SingleSlash += 3;
1525
1526    /* Find the / indicating the end of the hostname, ignoring /'s in the
1527       square brackets */
1528    bool InBracket = false;
1529    for (; SingleSlash < U.end() && (*SingleSlash != '/' || InBracket == true); ++SingleSlash)
1530    {
1531       if (*SingleSlash == '[')
1532          InBracket = true;
1533       if (InBracket == true && *SingleSlash == ']')
1534          InBracket = false;
1535    }
1536
1537    if (SingleSlash > U.end())
1538       SingleSlash = U.end();
1539
1540    // We can now write the access and path specifiers
1541    Access.assign(U.begin(),FirstColon);
1542    if (SingleSlash != U.end())
1543       Path.assign(SingleSlash,U.end());
1544    if (Path.empty() == true)
1545       Path = "/";
1546
1547    // Now we attempt to locate a user:pass@host fragment
1548    if (FirstColon + 2 <= U.end() && FirstColon[1] == '/' && FirstColon[2] == '/')
1549       FirstColon += 3;
1550    else
1551       FirstColon += 1;
1552    if (FirstColon >= U.end())
1553       return;
1554
1555    if (FirstColon > SingleSlash)
1556       FirstColon = SingleSlash;
1557
1558    // Find the colon...
1559    I = FirstColon + 1;
1560    if (I > SingleSlash)
1561       I = SingleSlash;
1562    for (; I < SingleSlash && *I != ':'; ++I);
1563    string::const_iterator SecondColon = I;
1564
1565    // Search for the @ after the colon
1566    for (; I < SingleSlash && *I != '@'; ++I);
1567    string::const_iterator At = I;
1568
1569    // Now write the host and user/pass
1570    if (At == SingleSlash)
1571    {
1572       if (FirstColon < SingleSlash)
1573          Host.assign(FirstColon,SingleSlash);
1574    }
1575    else
1576    {
1577       Host.assign(At+1,SingleSlash);
1578       // username and password must be encoded (RFC 3986)
1579       User.assign(DeQuoteString(FirstColon,SecondColon));
1580       if (SecondColon < At)
1581          Password.assign(DeQuoteString(SecondColon+1,At));
1582    }
1583
1584    // Now we parse the RFC 2732 [] hostnames.
1585    unsigned long PortEnd = 0;
1586    InBracket = false;
1587    for (unsigned I = 0; I != Host.length();)
1588    {
1589       if (Host[I] == '[')
1590       {
1591          InBracket = true;
1592          Host.erase(I,1);
1593          continue;
1594       }
1595
1596       if (InBracket == true && Host[I] == ']')
1597       {
1598          InBracket = false;
1599          Host.erase(I,1);
1600          PortEnd = I;
1601          continue;
1602       }
1603       I++;
1604    }
1605
1606    // Tsk, weird.
1607    if (InBracket == true)
1608    {
1609       Host.clear();
1610       return;
1611    }
1612
1613    // Now we parse off a port number from the hostname
1614    Port = 0;
1615    string::size_type Pos = Host.rfind(':');
1616    if (Pos == string::npos || Pos < PortEnd)
1617       return;
1618
1619    Port = atoi(string(Host,Pos+1).c_str());
1620    Host.assign(Host,0,Pos);
1621 }
1622                                                                         /*}}}*/
1623 // URI::operator string - Convert the URI to a string                   /*{{{*/
1624 // ---------------------------------------------------------------------
1625 /* */
1626 URI::operator string()
1627 {
1628    std::stringstream Res;
1629
1630    if (Access.empty() == false)
1631       Res << Access << ':';
1632
1633    if (Host.empty() == false)
1634    {
1635       if (Access.empty() == false)
1636          Res << "//";
1637
1638       if (User.empty() == false)
1639       {
1640          // FIXME: Technically userinfo is permitted even less
1641          // characters than these, but this is not conveniently
1642          // expressed with a blacklist.
1643          Res << QuoteString(User, ":/?#[]@");
1644          if (Password.empty() == false)
1645             Res << ":" << QuoteString(Password, ":/?#[]@");
1646          Res << "@";
1647       }
1648
1649       // Add RFC 2732 escaping characters
1650       if (Access.empty() == false && Host.find_first_of("/:") != string::npos)
1651          Res << '[' << Host << ']';
1652       else
1653          Res << Host;
1654
1655       if (Port != 0)
1656          Res << ':' << Port;
1657    }
1658
1659    if (Path.empty() == false)
1660    {
1661       if (Path[0] != '/')
1662          Res << "/" << Path;
1663       else
1664          Res << Path;
1665    }
1666
1667    return Res.str();
1668 }
1669                                                                         /*}}}*/
1670 // URI::SiteOnly - Return the schema and site for the URI               /*{{{*/
1671 string URI::SiteOnly(const string &URI)
1672 {
1673    ::URI U(URI);
1674    U.User.clear();
1675    U.Password.clear();
1676    U.Path.clear();
1677    return U;
1678 }
1679                                                                         /*}}}*/
1680 // URI::ArchiveOnly - Return the schema, site and cleaned path for the URI /*{{{*/
1681 string URI::ArchiveOnly(const string &URI)
1682 {
1683    ::URI U(URI);
1684    U.User.clear();
1685    U.Password.clear();
1686    if (U.Path.empty() == false && U.Path[U.Path.length() - 1] == '/')
1687       U.Path.erase(U.Path.length() - 1);
1688    return U;
1689 }
1690                                                                         /*}}}*/
1691 // URI::NoUserPassword - Return the schema, site and path for the URI   /*{{{*/
1692 string URI::NoUserPassword(const string &URI)
1693 {
1694    ::URI U(URI);
1695    U.User.clear();
1696    U.Password.clear();
1697    return U;
1698 }
1699                                                                         /*}}}*/