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    auto const &posix = std::locale("C.UTF-8");
 938    ss.imbue(posix);
 939    ss >> weekday;
 940    // we only superficially check weekday, mostly to avoid accepting localized
 941    // weekdays here and take only its length to decide which datetime format we
 942    // encounter here. The date isn't stored.
 943    std::transform(weekday.begin(), weekday.end(), weekday.begin(), ::tolower);
 944    std::array<char const * const, 7> c_weekdays = {{ "sun", "mon", "tue", "wed", "thu", "fri", "sat" }};
 945    if (std::find(c_weekdays.begin(), c_weekdays.end(), weekday.substr(0,3)) == c_weekdays.end())
 946       return false;
 947
 948    switch (weekday.length())
 949    {
 950    case 4:
 951       // Sun, 06 Nov 1994 08:49:37 GMT ; RFC 822, updated by RFC 1123
 952       if (weekday[3] != ',')
 953          return false;
 954       ss >> day >> month >> year >> timespec >> zone;
 955       break;
 956    case 3:
 957       // Sun Nov  6 08:49:37 1994 ; ANSI C's asctime() format
 958       ss >> month >> day >> timespec >> year;
 959       zone = "UTC";
 960       break;
 961    case 0:
 962    case 1:
 963    case 2:
 964       return false;
 965    default:
 966       // Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036
 967       if (weekday[weekday.length() - 1] != ',')
 968          return false;
 969       ss >> datespec >> timespec >> zone;
 970       auto const expldate = VectorizeString(datespec, '-');
 971       if (expldate.size() != 3)
 972          return false;
 973       try {
 974          size_t pos;
 975          day = std::stoi(expldate[0], &pos);
 976          if (pos != expldate[0].length())
 977             return false;
 978          year = 1900 + std::stoi(expldate[2], &pos);
 979          if (pos != expldate[2].length())
 980             return false;
 981          strprintf(datespec, "%.4d-%.2d-%.2d", year, MonthConv(expldate[1].c_str()) + 1, day);
 982       } catch (...) {
 983          return false;
 984       }
 985       break;
 986    }
 987
 988    if (ss.fail() || ss.bad() || !ss.eof())
 989       return false;
 990
 991    if (zone != "GMT" && zone != "UTC" && zone != "Z") // RFC 822
 992    {
 993       // numeric timezones as a should of RFC 1123 and generally preferred
 994       try {
 995          size_t pos;
 996          auto const z = std::stoi(zone, &pos);
 997          if (z != 0 || pos != zone.length())
 998             return false;
 999       } catch (...) {
1000          return false;
1001       }
1002    }
1003
1004    if (datespec.empty())
1005    {
1006       if (month.empty())
1007          return false;
1008       strprintf(datespec, "%.4d-%.2d-%.2d", year, MonthConv(month.c_str()) + 1, day);
1009    }
1010
1011    std::string const datetime = datespec + ' ' + timespec;
1012    struct tm Tm;
1013    if (strptime(datetime.c_str(), "%Y-%m-%d %H:%M:%S", &Tm) == nullptr)
1014       return false;
1015    time = timegm(&Tm);
1016    return true;
1017 }
1018                                                                         /*}}}*/
1019 // FTPMDTMStrToTime - Converts a ftp modification date into a time_t    /*{{{*/
1020 // ---------------------------------------------------------------------
1021 /* */
1022 bool FTPMDTMStrToTime(const char* const str,time_t &time)
1023 {
1024    struct tm Tm;
1025    // MDTM includes no whitespaces but recommend and ignored by strptime
1026    if (strptime(str, "%Y %m %d %H %M %S", &Tm) == NULL)
1027       return false;
1028
1029    time = timegm(&Tm);
1030    return true;
1031 }
1032                                                                         /*}}}*/
1033 // StrToTime - Converts a string into a time_t                          /*{{{*/
1034 // ---------------------------------------------------------------------
1035 /* This handles all 3 popular time formats including RFC 1123, RFC 1036
1036    and the C library asctime format. It requires the GNU library function
1037    'timegm' to convert a struct tm in UTC to a time_t. For some bizzar
1038    reason the C library does not provide any such function :< This also
1039    handles the weird, but unambiguous FTP time format*/
1040 bool StrToTime(const string &Val,time_t &Result)
1041 {
1042    struct tm Tm;
1043    char Month[10];
1044
1045    // Skip the day of the week
1046    const char *I = strchr(Val.c_str(), ' ');
1047
1048    // Handle RFC 1123 time
1049    Month[0] = 0;
1050    if (sscanf(I," %2d %3s %4d %2d:%2d:%2d GMT",&Tm.tm_mday,Month,&Tm.tm_year,
1051               &Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec) != 6)
1052    {
1053       // Handle RFC 1036 time
1054       if (sscanf(I," %2d-%3s-%3d %2d:%2d:%2d GMT",&Tm.tm_mday,Month,
1055                  &Tm.tm_year,&Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec) == 6)
1056          Tm.tm_year += 1900;
1057       else
1058       {
1059          // asctime format
1060          if (sscanf(I," %3s %2d %2d:%2d:%2d %4d",Month,&Tm.tm_mday,
1061                     &Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec,&Tm.tm_year) != 6)
1062          {
1063             // 'ftp' time
1064             if (sscanf(Val.c_str(),"%4d%2d%2d%2d%2d%2d",&Tm.tm_year,&Tm.tm_mon,
1065                        &Tm.tm_mday,&Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec) != 6)
1066                return false;
1067             Tm.tm_mon--;
1068          }
1069       }
1070    }
1071
1072    Tm.tm_isdst = 0;
1073    if (Month[0] != 0)
1074       Tm.tm_mon = MonthConv(Month);
1075    else
1076       Tm.tm_mon = 0; // we don't have a month, so pick something
1077    Tm.tm_year -= 1900;
1078
1079    // Convert to local time and then to GMT
1080    Result = timegm(&Tm);
1081    return true;
1082 }
1083                                                                         /*}}}*/
1084 // StrToNum - Convert a fixed length string to a number                 /*{{{*/
1085 // ---------------------------------------------------------------------
1086 /* This is used in decoding the crazy fixed length string headers in
1087    tar and ar files. */
1088 bool StrToNum(const char *Str,unsigned long &Res,unsigned Len,unsigned Base)
1089 {
1090    char S[30];
1091    if (Len >= sizeof(S))
1092       return false;
1093    memcpy(S,Str,Len);
1094    S[Len] = 0;
1095
1096    // All spaces is a zero
1097    Res = 0;
1098    unsigned I;
1099    for (I = 0; S[I] == ' '; I++);
1100    if (S[I] == 0)
1101       return true;
1102
1103    char *End;
1104    Res = strtoul(S,&End,Base);
1105    if (End == S)
1106       return false;
1107
1108    return true;
1109 }
1110                                                                         /*}}}*/
1111 // StrToNum - Convert a fixed length string to a number                 /*{{{*/
1112 // ---------------------------------------------------------------------
1113 /* This is used in decoding the crazy fixed length string headers in
1114    tar and ar files. */
1115 bool StrToNum(const char *Str,unsigned long long &Res,unsigned Len,unsigned Base)
1116 {
1117    char S[30];
1118    if (Len >= sizeof(S))
1119       return false;
1120    memcpy(S,Str,Len);
1121    S[Len] = 0;
1122
1123    // All spaces is a zero
1124    Res = 0;
1125    unsigned I;
1126    for (I = 0; S[I] == ' '; I++);
1127    if (S[I] == 0)
1128       return true;
1129
1130    char *End;
1131    Res = strtoull(S,&End,Base);
1132    if (End == S)
1133       return false;
1134
1135    return true;
1136 }
1137                                                                         /*}}}*/
1138
1139 // Base256ToNum - Convert a fixed length binary to a number             /*{{{*/
1140 // ---------------------------------------------------------------------
1141 /* This is used in decoding the 256bit encoded fixed length fields in
1142    tar files */
1143 bool Base256ToNum(const char *Str,unsigned long long &Res,unsigned int Len)
1144 {
1145    if ((Str[0] & 0x80) == 0)
1146       return false;
1147    else
1148    {
1149       Res = Str[0] & 0x7F;
1150       for(unsigned int i = 1; i < Len; ++i)
1151          Res = (Res<<8) + Str[i];
1152       return true;
1153    }
1154 }
1155                                                                         /*}}}*/
1156 // Base256ToNum - Convert a fixed length binary to a number             /*{{{*/
1157 // ---------------------------------------------------------------------
1158 /* This is used in decoding the 256bit encoded fixed length fields in
1159    tar files */
1160 bool Base256ToNum(const char *Str,unsigned long &Res,unsigned int Len)
1161 {
1162    unsigned long long Num;
1163    bool rc;
1164
1165    rc = Base256ToNum(Str, Num, Len);
1166    Res = Num;
1167    if (Res != Num)
1168       return false;
1169
1170    return rc;
1171 }
1172                                                                         /*}}}*/
1173 // HexDigit - Convert a hex character into an integer                   /*{{{*/
1174 // ---------------------------------------------------------------------
1175 /* Helper for Hex2Num */
1176 static int HexDigit(int c)
1177 {
1178    if (c >= '0' && c <= '9')
1179       return c - '0';
1180    if (c >= 'a' && c <= 'f')
1181       return c - 'a' + 10;
1182    if (c >= 'A' && c <= 'F')
1183       return c - 'A' + 10;
1184    return -1;
1185 }
1186                                                                         /*}}}*/
1187 // Hex2Num - Convert a long hex number into a buffer                    /*{{{*/
1188 // ---------------------------------------------------------------------
1189 /* The length of the buffer must be exactly 1/2 the length of the string. */
1190 bool Hex2Num(const string &Str,unsigned char *Num,unsigned int Length)
1191 {
1192    return Hex2Num(APT::StringView(Str), Num, Length);
1193 }
1194
1195 bool Hex2Num(const APT::StringView Str,unsigned char *Num,unsigned int Length)
1196 {
1197    if (Str.length() != Length*2)
1198       return false;
1199
1200    // Convert each digit. We store it in the same order as the string
1201    int J = 0;
1202    for (auto I = Str.begin(); I != Str.end();J++, I += 2)
1203    {
1204       int first_half = HexDigit(I[0]);
1205       int second_half;
1206       if (first_half < 0)
1207          return false;
1208
1209       second_half = HexDigit(I[1]);
1210       if (second_half < 0)
1211          return false;
1212       Num[J] = first_half << 4;
1213       Num[J] += second_half;
1214    }
1215
1216    return true;
1217 }
1218                                                                         /*}}}*/
1219 // TokSplitString - Split a string up by a given token                  /*{{{*/
1220 // ---------------------------------------------------------------------
1221 /* This is intended to be a faster splitter, it does not use dynamic
1222    memories. Input is changed to insert nulls at each token location. */
1223 bool TokSplitString(char Tok,char *Input,char **List,
1224                     unsigned long ListMax)
1225 {
1226    // Strip any leading spaces
1227    char *Start = Input;
1228    char *Stop = Start + strlen(Start);
1229    for (; *Start != 0 && isspace(*Start) != 0; Start++);
1230
1231    unsigned long Count = 0;
1232    char *Pos = Start;
1233    while (Pos != Stop)
1234    {
1235       // Skip to the next Token
1236       for (; Pos != Stop && *Pos != Tok; Pos++);
1237
1238       // Back remove spaces
1239       char *End = Pos;
1240       for (; End > Start && (End[-1] == Tok || isspace(End[-1]) != 0); End--);
1241       *End = 0;
1242
1243       List[Count++] = Start;
1244       if (Count >= ListMax)
1245       {
1246          List[Count-1] = 0;
1247          return false;
1248       }
1249
1250       // Advance pos
1251       for (; Pos != Stop && (*Pos == Tok || isspace(*Pos) != 0 || *Pos == 0); Pos++);
1252       Start = Pos;
1253    }
1254
1255    List[Count] = 0;
1256    return true;
1257 }
1258                                                                         /*}}}*/
1259 // VectorizeString - Split a string up into a vector of strings         /*{{{*/
1260 // ---------------------------------------------------------------------
1261 /* This can be used to split a given string up into a vector, so the
1262    propose is the same as in the method above and this one is a bit slower
1263    also, but the advantage is that we have an iteratable vector */
1264 vector<string> VectorizeString(string const &haystack, char const &split)
1265 {
1266    vector<string> exploded;
1267    if (haystack.empty() == true)
1268       return exploded;
1269    string::const_iterator start = haystack.begin();
1270    string::const_iterator end = start;
1271    do {
1272       for (; end != haystack.end() && *end != split; ++end);
1273       exploded.push_back(string(start, end));
1274       start = end + 1;
1275    } while (end != haystack.end() && (++end) != haystack.end());
1276    return exploded;
1277 }
1278                                                                         /*}}}*/
1279 // StringSplit - split a string into a string vector by token           /*{{{*/
1280 // ---------------------------------------------------------------------
1281 /* See header for details.
1282  */
1283 vector<string> StringSplit(std::string const &s, std::string const &sep,
1284                            unsigned int maxsplit)
1285 {
1286    vector<string> split;
1287    size_t start, pos;
1288
1289    // no separator given, this is bogus
1290    if(sep.size() == 0)
1291       return split;
1292
1293    start = pos = 0;
1294    while (pos != string::npos)
1295    {
1296       pos = s.find(sep, start);
1297       split.push_back(s.substr(start, pos-start));
1298
1299       // if maxsplit is reached, the remaining string is the last item
1300       if(split.size() >= maxsplit)
1301       {
1302          split[split.size()-1] = s.substr(start);
1303          break;
1304       }
1305       start = pos+sep.size();
1306    }
1307    return split;
1308 }
1309                                                                         /*}}}*/
1310 // RegexChoice - Simple regex list/list matcher                         /*{{{*/
1311 // ---------------------------------------------------------------------
1312 /* */
1313 unsigned long RegexChoice(RxChoiceList *Rxs,const char **ListBegin,
1314                       const char **ListEnd)
1315 {
1316    for (RxChoiceList *R = Rxs; R->Str != 0; R++)
1317       R->Hit = false;
1318
1319    unsigned long Hits = 0;
1320    for (; ListBegin < ListEnd; ++ListBegin)
1321    {
1322       // Check if the name is a regex
1323       const char *I;
1324       bool Regex = true;
1325       for (I = *ListBegin; *I != 0; I++)
1326          if (*I == '.' || *I == '?' || *I == '*' || *I == '|')
1327             break;
1328       if (*I == 0)
1329          Regex = false;
1330
1331       // Compile the regex pattern
1332       regex_t Pattern;
1333       if (Regex == true)
1334          if (regcomp(&Pattern,*ListBegin,REG_EXTENDED | REG_ICASE |
1335                      REG_NOSUB) != 0)
1336             Regex = false;
1337
1338       // Search the list
1339       bool Done = false;
1340       for (RxChoiceList *R = Rxs; R->Str != 0; R++)
1341       {
1342          if (R->Str[0] == 0)
1343             continue;
1344
1345          if (strcasecmp(R->Str,*ListBegin) != 0)
1346          {
1347             if (Regex == false)
1348                continue;
1349             if (regexec(&Pattern,R->Str,0,0,0) != 0)
1350                continue;
1351          }
1352          Done = true;
1353
1354          if (R->Hit == false)
1355             Hits++;
1356
1357          R->Hit = true;
1358       }
1359
1360       if (Regex == true)
1361          regfree(&Pattern);
1362
1363       if (Done == false)
1364          _error->Warning(_("Selection %s not found"),*ListBegin);
1365    }
1366
1367    return Hits;
1368 }
1369                                                                         /*}}}*/
1370 // {str,io}printf - C format string outputter to C++ strings/iostreams  /*{{{*/
1371 // ---------------------------------------------------------------------
1372 /* This is used to make the internationalization strings easier to translate
1373    and to allow reordering of parameters */
1374 static bool iovprintf(ostream &out, const char *format,
1375                       va_list &args, ssize_t &size) {
1376    char *S = (char*)malloc(size);
1377    ssize_t const n = vsnprintf(S, size, format, args);
1378    if (n > -1 && n < size) {
1379       out << S;
1380       free(S);
1381       return true;
1382    } else {
1383       if (n > -1)
1384          size = n + 1;
1385       else
1386          size *= 2;
1387    }
1388    free(S);
1389    return false;
1390 }
1391 void ioprintf(ostream &out,const char *format,...)
1392 {
1393    va_list args;
1394    ssize_t size = 400;
1395    while (true) {
1396       bool ret;
1397       va_start(args,format);
1398       ret = iovprintf(out, format, args, size);
1399       va_end(args);
1400       if (ret == true)
1401          return;
1402    }
1403 }
1404 void strprintf(string &out,const char *format,...)
1405 {
1406    va_list args;
1407    ssize_t size = 400;
1408    std::ostringstream outstr;
1409    while (true) {
1410       bool ret;
1411       va_start(args,format);
1412       ret = iovprintf(outstr, format, args, size);
1413       va_end(args);
1414       if (ret == true)
1415          break;
1416    }
1417    out = outstr.str();
1418 }
1419                                                                         /*}}}*/
1420 // safe_snprintf - Safer snprintf                                       /*{{{*/
1421 // ---------------------------------------------------------------------
1422 /* This is a snprintf that will never (ever) go past 'End' and returns a
1423    pointer to the end of the new string. The returned string is always null
1424    terminated unless Buffer == end. This is a better alterantive to using
1425    consecutive snprintfs. */
1426 char *safe_snprintf(char *Buffer,char *End,const char *Format,...)
1427 {
1428    va_list args;
1429    int Did;
1430
1431    if (End <= Buffer)
1432       return End;
1433    va_start(args,Format);
1434    Did = vsnprintf(Buffer,End - Buffer,Format,args);
1435    va_end(args);
1436
1437    if (Did < 0 || Buffer + Did > End)
1438       return End;
1439    return Buffer + Did;
1440 }
1441                                                                         /*}}}*/
1442 // StripEpoch - Remove the version "epoch" from a version string        /*{{{*/
1443 // ---------------------------------------------------------------------
1444 string StripEpoch(const string &VerStr)
1445 {
1446    size_t i = VerStr.find(":");
1447    if (i == string::npos)
1448       return VerStr;
1449    return VerStr.substr(i+1);
1450 }
1451                                                                         /*}}}*/
1452
1453 // tolower_ascii - tolower() function that ignores the locale           /*{{{*/
1454 // ---------------------------------------------------------------------
1455 /* This little function is the most called method we have and tries
1456    therefore to do the absolut minimum - and is notable faster than
1457    standard tolower/toupper and as a bonus avoids problems with different
1458    locales - we only operate on ascii chars anyway. */
1459 #undef tolower_ascii
1460 int tolower_ascii(int const c) APT_CONST APT_COLD;
1461 int tolower_ascii(int const c)
1462 {
1463    return tolower_ascii_inline(c);
1464 }
1465                                                                         /*}}}*/
1466
1467 // isspace_ascii - isspace() function that ignores the locale           /*{{{*/
1468 // ---------------------------------------------------------------------
1469 /* This little function is one of the most called methods we have and tries
1470    therefore to do the absolut minimum - and is notable faster than
1471    standard isspace() and as a bonus avoids problems with different
1472    locales - we only operate on ascii chars anyway. */
1473 #undef isspace_ascii
1474 int isspace_ascii(int const c) APT_CONST APT_COLD;
1475 int isspace_ascii(int const c)
1476 {
1477    return isspace_ascii_inline(c);
1478 }
1479                                                                         /*}}}*/
1480
1481 // CheckDomainList - See if Host is in a , separate list                /*{{{*/
1482 // ---------------------------------------------------------------------
1483 /* The domain list is a comma separate list of domains that are suffix
1484    matched against the argument */
1485 bool CheckDomainList(const string &Host,const string &List)
1486 {
1487    string::const_iterator Start = List.begin();
1488    for (string::const_iterator Cur = List.begin(); Cur <= List.end(); ++Cur)
1489    {
1490       if (Cur < List.end() && *Cur != ',')
1491          continue;
1492
1493       // Match the end of the string..
1494       if ((Host.size() >= (unsigned)(Cur - Start)) &&
1495           Cur - Start != 0 &&
1496           stringcasecmp(Host.end() - (Cur - Start),Host.end(),Start,Cur) == 0)
1497          return true;
1498
1499       Start = Cur + 1;
1500    }
1501    return false;
1502 }
1503                                                                         /*}}}*/
1504 // strv_length - Return the length of a NULL-terminated string array    /*{{{*/
1505 // ---------------------------------------------------------------------
1506 /* */
1507 size_t strv_length(const char **str_array)
1508 {
1509    size_t i;
1510    for (i=0; str_array[i] != NULL; i++)
1511       /* nothing */
1512       ;
1513    return i;
1514 }
1515                                                                         /*}}}*/
1516 // DeEscapeString - unescape (\0XX and \xXX) from a string              /*{{{*/
1517 // ---------------------------------------------------------------------
1518 /* */
1519 string DeEscapeString(const string &input)
1520 {
1521    char tmp[3];
1522    string::const_iterator it;
1523    string output;
1524    for (it = input.begin(); it != input.end(); ++it)
1525    {
1526       // just copy non-escape chars
1527       if (*it != '\\')
1528       {
1529          output += *it;
1530          continue;
1531       }
1532
1533       // deal with double escape
1534       if (*it == '\\' &&
1535           (it + 1 < input.end()) &&  it[1] == '\\')
1536       {
1537          // copy
1538          output += *it;
1539          // advance iterator one step further
1540          ++it;
1541          continue;
1542       }
1543
1544       // ensure we have a char to read
1545       if (it + 1 == input.end())
1546          continue;
1547
1548       // read it
1549       ++it;
1550       switch (*it)
1551       {
1552          case '0':
1553             if (it + 2 <= input.end()) {
1554                tmp[0] = it[1];
1555                tmp[1] = it[2];
1556                tmp[2] = 0;
1557                output += (char)strtol(tmp, 0, 8);
1558                it += 2;
1559             }
1560             break;
1561          case 'x':
1562             if (it + 2 <= input.end()) {
1563                tmp[0] = it[1];
1564                tmp[1] = it[2];
1565                tmp[2] = 0;
1566                output += (char)strtol(tmp, 0, 16);
1567                it += 2;
1568             }
1569             break;
1570          default:
1571             // FIXME: raise exception here?
1572             break;
1573       }
1574    }
1575    return output;
1576 }
1577                                                                         /*}}}*/
1578 // URI::CopyFrom - Copy from an object                                  /*{{{*/
1579 // ---------------------------------------------------------------------
1580 /* This parses the URI into all of its components */
1581 void URI::CopyFrom(const string &U)
1582 {
1583    string::const_iterator I = U.begin();
1584
1585    // Locate the first colon, this separates the scheme
1586    for (; I < U.end() && *I != ':' ; ++I);
1587    string::const_iterator FirstColon = I;
1588
1589    /* Determine if this is a host type URI with a leading double //
1590       and then search for the first single / */
1591    string::const_iterator SingleSlash = I;
1592    if (I + 3 < U.end() && I[1] == '/' && I[2] == '/')
1593       SingleSlash += 3;
1594
1595    /* Find the / indicating the end of the hostname, ignoring /'s in the
1596       square brackets */
1597    bool InBracket = false;
1598    for (; SingleSlash < U.end() && (*SingleSlash != '/' || InBracket == true); ++SingleSlash)
1599    {
1600       if (*SingleSlash == '[')
1601          InBracket = true;
1602       if (InBracket == true && *SingleSlash == ']')
1603          InBracket = false;
1604    }
1605
1606    if (SingleSlash > U.end())
1607       SingleSlash = U.end();
1608
1609    // We can now write the access and path specifiers
1610    Access.assign(U.begin(),FirstColon);
1611    if (SingleSlash != U.end())
1612       Path.assign(SingleSlash,U.end());
1613    if (Path.empty() == true)
1614       Path = "/";
1615
1616    // Now we attempt to locate a user:pass@host fragment
1617    if (FirstColon + 2 <= U.end() && FirstColon[1] == '/' && FirstColon[2] == '/')
1618       FirstColon += 3;
1619    else
1620       FirstColon += 1;
1621    if (FirstColon >= U.end())
1622       return;
1623
1624    if (FirstColon > SingleSlash)
1625       FirstColon = SingleSlash;
1626
1627    // Find the colon...
1628    I = FirstColon + 1;
1629    if (I > SingleSlash)
1630       I = SingleSlash;
1631    for (; I < SingleSlash && *I != ':'; ++I);
1632    string::const_iterator SecondColon = I;
1633
1634    // Search for the @ after the colon
1635    for (; I < SingleSlash && *I != '@'; ++I);
1636    string::const_iterator At = I;
1637
1638    // Now write the host and user/pass
1639    if (At == SingleSlash)
1640    {
1641       if (FirstColon < SingleSlash)
1642          Host.assign(FirstColon,SingleSlash);
1643    }
1644    else
1645    {
1646       Host.assign(At+1,SingleSlash);
1647       // username and password must be encoded (RFC 3986)
1648       User.assign(DeQuoteString(FirstColon,SecondColon));
1649       if (SecondColon < At)
1650          Password.assign(DeQuoteString(SecondColon+1,At));
1651    }
1652
1653    // Now we parse the RFC 2732 [] hostnames.
1654    unsigned long PortEnd = 0;
1655    InBracket = false;
1656    for (unsigned I = 0; I != Host.length();)
1657    {
1658       if (Host[I] == '[')
1659       {
1660          InBracket = true;
1661          Host.erase(I,1);
1662          continue;
1663       }
1664
1665       if (InBracket == true && Host[I] == ']')
1666       {
1667          InBracket = false;
1668          Host.erase(I,1);
1669          PortEnd = I;
1670          continue;
1671       }
1672       I++;
1673    }
1674
1675    // Tsk, weird.
1676    if (InBracket == true)
1677    {
1678       Host.clear();
1679       return;
1680    }
1681
1682    // Now we parse off a port number from the hostname
1683    Port = 0;
1684    string::size_type Pos = Host.rfind(':');
1685    if (Pos == string::npos || Pos < PortEnd)
1686       return;
1687
1688    Port = atoi(string(Host,Pos+1).c_str());
1689    Host.assign(Host,0,Pos);
1690 }
1691                                                                         /*}}}*/
1692 // URI::operator string - Convert the URI to a string                   /*{{{*/
1693 // ---------------------------------------------------------------------
1694 /* */
1695 URI::operator string()
1696 {
1697    std::stringstream Res;
1698
1699    if (Access.empty() == false)
1700       Res << Access << ':';
1701
1702    if (Host.empty() == false)
1703    {
1704       if (Access.empty() == false)
1705          Res << "//";
1706
1707       if (User.empty() == false)
1708       {
1709          // FIXME: Technically userinfo is permitted even less
1710          // characters than these, but this is not conveniently
1711          // expressed with a blacklist.
1712          Res << QuoteString(User, ":/?#[]@");
1713          if (Password.empty() == false)
1714             Res << ":" << QuoteString(Password, ":/?#[]@");
1715          Res << "@";
1716       }
1717
1718       // Add RFC 2732 escaping characters
1719       if (Access.empty() == false && Host.find_first_of("/:") != string::npos)
1720          Res << '[' << Host << ']';
1721       else
1722          Res << Host;
1723
1724       if (Port != 0)
1725          Res << ':' << std::to_string(Port);
1726    }
1727
1728    if (Path.empty() == false)
1729    {
1730       if (Path[0] != '/')
1731          Res << "/" << Path;
1732       else
1733          Res << Path;
1734    }
1735
1736    return Res.str();
1737 }
1738                                                                         /*}}}*/
1739 // URI::SiteOnly - Return the schema and site for the URI               /*{{{*/
1740 string URI::SiteOnly(const string &URI)
1741 {
1742    ::URI U(URI);
1743    U.User.clear();
1744    U.Password.clear();
1745    U.Path.clear();
1746    return U;
1747 }
1748                                                                         /*}}}*/
1749 // URI::ArchiveOnly - Return the schema, site and cleaned path for the URI /*{{{*/
1750 string URI::ArchiveOnly(const string &URI)
1751 {
1752    ::URI U(URI);
1753    U.User.clear();
1754    U.Password.clear();
1755    if (U.Path.empty() == false && U.Path[U.Path.length() - 1] == '/')
1756       U.Path.erase(U.Path.length() - 1);
1757    return U;
1758 }
1759                                                                         /*}}}*/
1760 // URI::NoUserPassword - Return the schema, site and path for the URI   /*{{{*/
1761 string URI::NoUserPassword(const string &URI)
1762 {
1763    ::URI U(URI);
1764    U.User.clear();
1765    U.Password.clear();
1766    return U;
1767 }
1768                                                                         /*}}}*/