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