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