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                (I[0] != '\n' && strncmp(I, "\r\n\r\n", 4) != 0))
 763             continue;
 764
 765          // Pull the message out
 766          string Message(Buffer,I-Buffer);
 767          PartialMessage += Message;
 768
 769          // Fix up the buffer
 770          for (; I < End && (*I == '\n' || *I == '\r'); ++I);
 771          End -= I-Buffer;
 772          memmove(Buffer,I,End-Buffer);
 773          I = Buffer;
 774
 775          List.push_back(PartialMessage);
 776          PartialMessage.clear();
 777       }
 778       if (End != Buffer)
 779         {
 780           // If there's text left in the buffer, store it
 781           // in PartialMessage and throw the rest of the buffer
 782           // away.  This allows us to handle messages that
 783           // are longer than the static buffer size.
 784           PartialMessage += string(Buffer, End);
 785           End = Buffer;
 786         }
 787       else
 788         {
 789           // BUG ALERT: if a message block happens to end at a
 790           // multiple of 64000 characters, this will cause it to
 791           // terminate early, leading to a badly formed block and
 792           // probably crashing the method.  However, this is the only
 793           // way we have to find the end of the message block.  I have
 794           // an idea of how to fix this, but it will require changes
 795           // to the protocol (essentially to mark the beginning and
 796           // end of the block).
 797           //
 798           //  -- dburrows 2008-04-02
 799           return true;
 800         }
 801
 802       if (WaitFd(Fd) == false)
 803          return false;
 804    }
 805 }
 806                                                                         /*}}}*/
 807 // MonthConv - Converts a month string into a number                    /*{{{*/
 808 // ---------------------------------------------------------------------
 809 /* This was lifted from the boa webserver which lifted it from 'wn-v1.07'
 810    Made it a bit more robust with a few tolower_ascii though. */
 811 static int MonthConv(char *Month)
 812 {
 813    switch (tolower_ascii(*Month))
 814    {
 815       case 'a':
 816       return tolower_ascii(Month[1]) == 'p'?3:7;
 817       case 'd':
 818       return 11;
 819       case 'f':
 820       return 1;
 821       case 'j':
 822       if (tolower_ascii(Month[1]) == 'a')
 823          return 0;
 824       return tolower_ascii(Month[2]) == 'n'?5:6;
 825       case 'm':
 826       return tolower_ascii(Month[2]) == 'r'?2:4;
 827       case 'n':
 828       return 10;
 829       case 'o':
 830       return 9;
 831       case 's':
 832       return 8;
 833
 834       // Pretend it is January..
 835       default:
 836       return 0;
 837    }
 838 }
 839                                                                         /*}}}*/
 840 // timegm - Internal timegm if the gnu version is not available         /*{{{*/
 841 // ---------------------------------------------------------------------
 842 /* Converts struct tm to time_t, assuming the data in tm is UTC rather
 843    than local timezone (mktime assumes the latter).
 844
 845    This function is a nonstandard GNU extension that is also present on
 846    the BSDs and maybe other systems. For others we follow the advice of
 847    the manpage of timegm and use his portable replacement. */
 848 #ifndef HAVE_TIMEGM
 849 static time_t timegm(struct tm *t)
 850 {
 851    char *tz = getenv("TZ");
 852    setenv("TZ", "", 1);
 853    tzset();
 854    time_t ret = mktime(t);
 855    if (tz)
 856       setenv("TZ", tz, 1);
 857    else
 858       unsetenv("TZ");
 859    tzset();
 860    return ret;
 861 }
 862 #endif
 863                                                                         /*}}}*/
 864 // FullDateToTime - Converts a HTTP1.1 full date strings into a time_t  /*{{{*/
 865 // ---------------------------------------------------------------------
 866 /* tries to parses a full date as specified in RFC2616 Section 3.3.1
 867    with one exception: All timezones (%Z) are accepted but the protocol
 868    says that it MUST be GMT, but this one is equal to UTC which we will
 869    encounter from time to time (e.g. in Release files) so we accept all
 870    here and just assume it is GMT (or UTC) later on */
 871 bool RFC1123StrToTime(const char* const str,time_t &time)
 872 {
 873    struct tm Tm;
 874    setlocale (LC_ALL,"C");
 875    bool const invalid =
 876    // Sun, 06 Nov 1994 08:49:37 GMT  ; RFC 822, updated by RFC 1123
 877       (strptime(str, "%a, %d %b %Y %H:%M:%S %Z", &Tm) == NULL &&
 878    // Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036
 879        strptime(str, "%A, %d-%b-%y %H:%M:%S %Z", &Tm) == NULL &&
 880    // Sun Nov  6 08:49:37 1994       ; ANSI C's asctime() format
 881        strptime(str, "%a %b %d %H:%M:%S %Y", &Tm) == NULL);
 882    setlocale (LC_ALL,"");
 883    if (invalid == true)
 884       return false;
 885
 886    time = timegm(&Tm);
 887    return true;
 888 }
 889                                                                         /*}}}*/
 890 // FTPMDTMStrToTime - Converts a ftp modification date into a time_t    /*{{{*/
 891 // ---------------------------------------------------------------------
 892 /* */
 893 bool FTPMDTMStrToTime(const char* const str,time_t &time)
 894 {
 895    struct tm Tm;
 896    // MDTM includes no whitespaces but recommend and ignored by strptime
 897    if (strptime(str, "%Y %m %d %H %M %S", &Tm) == NULL)
 898       return false;
 899
 900    time = timegm(&Tm);
 901    return true;
 902 }
 903                                                                         /*}}}*/
 904 // StrToTime - Converts a string into a time_t                          /*{{{*/
 905 // ---------------------------------------------------------------------
 906 /* This handles all 3 populare time formats including RFC 1123, RFC 1036
 907    and the C library asctime format. It requires the GNU library function
 908    'timegm' to convert a struct tm in UTC to a time_t. For some bizzar
 909    reason the C library does not provide any such function :< This also
 910    handles the weird, but unambiguous FTP time format*/
 911 bool StrToTime(const string &Val,time_t &Result)
 912 {
 913    struct tm Tm;
 914    char Month[10];
 915
 916    // Skip the day of the week
 917    const char *I = strchr(Val.c_str(), ' ');
 918
 919    // Handle RFC 1123 time
 920    Month[0] = 0;
 921    if (sscanf(I," %2d %3s %4d %2d:%2d:%2d GMT",&Tm.tm_mday,Month,&Tm.tm_year,
 922               &Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec) != 6)
 923    {
 924       // Handle RFC 1036 time
 925       if (sscanf(I," %2d-%3s-%3d %2d:%2d:%2d GMT",&Tm.tm_mday,Month,
 926                  &Tm.tm_year,&Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec) == 6)
 927          Tm.tm_year += 1900;
 928       else
 929       {
 930          // asctime format
 931          if (sscanf(I," %3s %2d %2d:%2d:%2d %4d",Month,&Tm.tm_mday,
 932                     &Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec,&Tm.tm_year) != 6)
 933          {
 934             // 'ftp' time
 935             if (sscanf(Val.c_str(),"%4d%2d%2d%2d%2d%2d",&Tm.tm_year,&Tm.tm_mon,
 936                        &Tm.tm_mday,&Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec) != 6)
 937                return false;
 938             Tm.tm_mon--;
 939          }
 940       }
 941    }
 942
 943    Tm.tm_isdst = 0;
 944    if (Month[0] != 0)
 945       Tm.tm_mon = MonthConv(Month);
 946    Tm.tm_year -= 1900;
 947
 948    // Convert to local time and then to GMT
 949    Result = timegm(&Tm);
 950    return true;
 951 }
 952                                                                         /*}}}*/
 953 // StrToNum - Convert a fixed length string to a number                 /*{{{*/
 954 // ---------------------------------------------------------------------
 955 /* This is used in decoding the crazy fixed length string headers in
 956    tar and ar files. */
 957 bool StrToNum(const char *Str,unsigned long &Res,unsigned Len,unsigned Base)
 958 {
 959    char S[30];
 960    if (Len >= sizeof(S))
 961       return false;
 962    memcpy(S,Str,Len);
 963    S[Len] = 0;
 964
 965    // All spaces is a zero
 966    Res = 0;
 967    unsigned I;
 968    for (I = 0; S[I] == ' '; I++);
 969    if (S[I] == 0)
 970       return true;
 971
 972    char *End;
 973    Res = strtoul(S,&End,Base);
 974    if (End == S)
 975       return false;
 976
 977    return true;
 978 }
 979                                                                         /*}}}*/
 980 // StrToNum - Convert a fixed length string to a number                 /*{{{*/
 981 // ---------------------------------------------------------------------
 982 /* This is used in decoding the crazy fixed length string headers in
 983    tar and ar files. */
 984 bool StrToNum(const char *Str,unsigned long long &Res,unsigned Len,unsigned Base)
 985 {
 986    char S[30];
 987    if (Len >= sizeof(S))
 988       return false;
 989    memcpy(S,Str,Len);
 990    S[Len] = 0;
 991
 992    // All spaces is a zero
 993    Res = 0;
 994    unsigned I;
 995    for (I = 0; S[I] == ' '; I++);
 996    if (S[I] == 0)
 997       return true;
 998
 999    char *End;
1000    Res = strtoull(S,&End,Base);
1001    if (End == S)
1002       return false;
1003
1004    return true;
1005 }
1006                                                                         /*}}}*/
1007
1008 // Base256ToNum - Convert a fixed length binary to a number             /*{{{*/
1009 // ---------------------------------------------------------------------
1010 /* This is used in decoding the 256bit encoded fixed length fields in
1011    tar files */
1012 bool Base256ToNum(const char *Str,unsigned long &Res,unsigned int Len)
1013 {
1014    if ((Str[0] & 0x80) == 0)
1015       return false;
1016    else
1017    {
1018       Res = Str[0] & 0x7F;
1019       for(unsigned int i = 1; i < Len; ++i)
1020          Res = (Res<<8) + Str[i];
1021       return true;
1022    }
1023 }
1024                                                                         /*}}}*/
1025 // HexDigit - Convert a hex character into an integer                   /*{{{*/
1026 // ---------------------------------------------------------------------
1027 /* Helper for Hex2Num */
1028 static int HexDigit(int c)
1029 {
1030    if (c >= '0' && c <= '9')
1031       return c - '0';
1032    if (c >= 'a' && c <= 'f')
1033       return c - 'a' + 10;
1034    if (c >= 'A' && c <= 'F')
1035       return c - 'A' + 10;
1036    return 0;
1037 }
1038                                                                         /*}}}*/
1039 // Hex2Num - Convert a long hex number into a buffer                    /*{{{*/
1040 // ---------------------------------------------------------------------
1041 /* The length of the buffer must be exactly 1/2 the length of the string. */
1042 bool Hex2Num(const string &Str,unsigned char *Num,unsigned int Length)
1043 {
1044    if (Str.length() != Length*2)
1045       return false;
1046
1047    // Convert each digit. We store it in the same order as the string
1048    int J = 0;
1049    for (string::const_iterator I = Str.begin(); I != Str.end();J++, I += 2)
1050    {
1051       if (isxdigit(*I) == 0 || isxdigit(I[1]) == 0)
1052          return false;
1053
1054       Num[J] = HexDigit(I[0]) << 4;
1055       Num[J] += HexDigit(I[1]);
1056    }
1057
1058    return true;
1059 }
1060                                                                         /*}}}*/
1061 // TokSplitString - Split a string up by a given token                  /*{{{*/
1062 // ---------------------------------------------------------------------
1063 /* This is intended to be a faster splitter, it does not use dynamic
1064    memories. Input is changed to insert nulls at each token location. */
1065 bool TokSplitString(char Tok,char *Input,char **List,
1066                     unsigned long ListMax)
1067 {
1068    // Strip any leading spaces
1069    char *Start = Input;
1070    char *Stop = Start + strlen(Start);
1071    for (; *Start != 0 && isspace(*Start) != 0; Start++);
1072
1073    unsigned long Count = 0;
1074    char *Pos = Start;
1075    while (Pos != Stop)
1076    {
1077       // Skip to the next Token
1078       for (; Pos != Stop && *Pos != Tok; Pos++);
1079
1080       // Back remove spaces
1081       char *End = Pos;
1082       for (; End > Start && (End[-1] == Tok || isspace(End[-1]) != 0); End--);
1083       *End = 0;
1084
1085       List[Count++] = Start;
1086       if (Count >= ListMax)
1087       {
1088          List[Count-1] = 0;
1089          return false;
1090       }
1091
1092       // Advance pos
1093       for (; Pos != Stop && (*Pos == Tok || isspace(*Pos) != 0 || *Pos == 0); Pos++);
1094       Start = Pos;
1095    }
1096
1097    List[Count] = 0;
1098    return true;
1099 }
1100                                                                         /*}}}*/
1101 // VectorizeString - Split a string up into a vector of strings         /*{{{*/
1102 // ---------------------------------------------------------------------
1103 /* This can be used to split a given string up into a vector, so the
1104    propose is the same as in the method above and this one is a bit slower
1105    also, but the advantage is that we have an iteratable vector */
1106 vector<string> VectorizeString(string const &haystack, char const &split)
1107 {
1108    string::const_iterator start = haystack.begin();
1109    string::const_iterator end = start;
1110    vector<string> exploded;
1111    do {
1112       for (; end != haystack.end() && *end != split; ++end);
1113       exploded.push_back(string(start, end));
1114       start = end + 1;
1115    } while (end != haystack.end() && (++end) != haystack.end());
1116    return exploded;
1117 }
1118                                                                         /*}}}*/
1119 // RegexChoice - Simple regex list/list matcher                         /*{{{*/
1120 // ---------------------------------------------------------------------
1121 /* */
1122 unsigned long RegexChoice(RxChoiceList *Rxs,const char **ListBegin,
1123                       const char **ListEnd)
1124 {
1125    for (RxChoiceList *R = Rxs; R->Str != 0; R++)
1126       R->Hit = false;
1127
1128    unsigned long Hits = 0;
1129    for (; ListBegin != ListEnd; ListBegin++)
1130    {
1131       // Check if the name is a regex
1132       const char *I;
1133       bool Regex = true;
1134       for (I = *ListBegin; *I != 0; I++)
1135          if (*I == '.' || *I == '?' || *I == '*' || *I == '|')
1136             break;
1137       if (*I == 0)
1138          Regex = false;
1139
1140       // Compile the regex pattern
1141       regex_t Pattern;
1142       if (Regex == true)
1143          if (regcomp(&Pattern,*ListBegin,REG_EXTENDED | REG_ICASE |
1144                      REG_NOSUB) != 0)
1145             Regex = false;
1146
1147       // Search the list
1148       bool Done = false;
1149       for (RxChoiceList *R = Rxs; R->Str != 0; R++)
1150       {
1151          if (R->Str[0] == 0)
1152             continue;
1153
1154          if (strcasecmp(R->Str,*ListBegin) != 0)
1155          {
1156             if (Regex == false)
1157                continue;
1158             if (regexec(&Pattern,R->Str,0,0,0) != 0)
1159                continue;
1160          }
1161          Done = true;
1162
1163          if (R->Hit == false)
1164             Hits++;
1165
1166          R->Hit = true;
1167       }
1168
1169       if (Regex == true)
1170          regfree(&Pattern);
1171
1172       if (Done == false)
1173          _error->Warning(_("Selection %s not found"),*ListBegin);
1174    }
1175
1176    return Hits;
1177 }
1178                                                                         /*}}}*/
1179 // {str,io}printf - C format string outputter to C++ strings/iostreams  /*{{{*/
1180 // ---------------------------------------------------------------------
1181 /* This is used to make the internationalization strings easier to translate
1182    and to allow reordering of parameters */
1183 static bool iovprintf(ostream &out, const char *format,
1184                       va_list &args, ssize_t &size) {
1185    char *S = (char*)malloc(size);
1186    ssize_t const n = vsnprintf(S, size, format, args);
1187    if (n > -1 && n < size) {
1188       out << S;
1189       free(S);
1190       return true;
1191    } else {
1192       if (n > -1)
1193          size = n + 1;
1194       else
1195          size *= 2;
1196    }
1197    free(S);
1198    return false;
1199 }
1200 void ioprintf(ostream &out,const char *format,...)
1201 {
1202    va_list args;
1203    ssize_t size = 400;
1204    while (true) {
1205       va_start(args,format);
1206       if (iovprintf(out, format, args, size) == true)
1207          return;
1208       va_end(args);
1209    }
1210 }
1211 void strprintf(string &out,const char *format,...)
1212 {
1213    va_list args;
1214    ssize_t size = 400;
1215    std::ostringstream outstr;
1216    while (true) {
1217       va_start(args,format);
1218       if (iovprintf(outstr, format, args, size) == true)
1219          break;
1220       va_end(args);
1221    }
1222    out = outstr.str();
1223 }
1224                                                                         /*}}}*/
1225 // safe_snprintf - Safer snprintf                                       /*{{{*/
1226 // ---------------------------------------------------------------------
1227 /* This is a snprintf that will never (ever) go past 'End' and returns a
1228    pointer to the end of the new string. The returned string is always null
1229    terminated unless Buffer == end. This is a better alterantive to using
1230    consecutive snprintfs. */
1231 char *safe_snprintf(char *Buffer,char *End,const char *Format,...)
1232 {
1233    va_list args;
1234    int Did;
1235
1236    va_start(args,Format);
1237
1238    if (End <= Buffer)
1239       return End;
1240
1241    Did = vsnprintf(Buffer,End - Buffer,Format,args);
1242    if (Did < 0 || Buffer + Did > End)
1243       return End;
1244    return Buffer + Did;
1245 }
1246                                                                         /*}}}*/
1247 // StripEpoch - Remove the version "epoch" from a version string        /*{{{*/
1248 // ---------------------------------------------------------------------
1249 string StripEpoch(const string &VerStr)
1250 {
1251    size_t i = VerStr.find(":");
1252    if (i == string::npos)
1253       return VerStr;
1254    return VerStr.substr(i+1);
1255 }
1256                                                                         /*}}}*/
1257 // tolower_ascii - tolower() function that ignores the locale           /*{{{*/
1258 // ---------------------------------------------------------------------
1259 /* This little function is the most called method we have and tries
1260    therefore to do the absolut minimum - and is noteable faster than
1261    standard tolower/toupper and as a bonus avoids problems with different
1262    locales - we only operate on ascii chars anyway. */
1263 int tolower_ascii(int const c)
1264 {
1265    if (c >= 'A' && c <= 'Z')
1266       return c + 32;
1267    return c;
1268 }
1269                                                                         /*}}}*/
1270
1271 // CheckDomainList - See if Host is in a , seperate list                /*{{{*/
1272 // ---------------------------------------------------------------------
1273 /* The domain list is a comma seperate list of domains that are suffix
1274    matched against the argument */
1275 bool CheckDomainList(const string &Host,const string &List)
1276 {
1277    string::const_iterator Start = List.begin();
1278    for (string::const_iterator Cur = List.begin(); Cur <= List.end(); ++Cur)
1279    {
1280       if (Cur < List.end() && *Cur != ',')
1281          continue;
1282
1283       // Match the end of the string..
1284       if ((Host.size() >= (unsigned)(Cur - Start)) &&
1285           Cur - Start != 0 &&
1286           stringcasecmp(Host.end() - (Cur - Start),Host.end(),Start,Cur) == 0)
1287          return true;
1288
1289       Start = Cur + 1;
1290    }
1291    return false;
1292 }
1293                                                                         /*}}}*/
1294 // DeEscapeString - unescape (\0XX and \xXX) from a string              /*{{{*/
1295 // ---------------------------------------------------------------------
1296 /* */
1297 string DeEscapeString(const string &input)
1298 {
1299    char tmp[3];
1300    string::const_iterator it;
1301    string output;
1302    for (it = input.begin(); it != input.end(); ++it)
1303    {
1304       // just copy non-escape chars
1305       if (*it != '\\')
1306       {
1307          output += *it;
1308          continue;
1309       }
1310
1311       // deal with double escape
1312       if (*it == '\\' &&
1313           (it + 1 < input.end()) &&  it[1] == '\\')
1314       {
1315          // copy
1316          output += *it;
1317          // advance iterator one step further
1318          ++it;
1319          continue;
1320       }
1321
1322       // ensure we have a char to read
1323       if (it + 1 == input.end())
1324          continue;
1325
1326       // read it
1327       ++it;
1328       switch (*it)
1329       {
1330          case '0':
1331             if (it + 2 <= input.end()) {
1332                tmp[0] = it[1];
1333                tmp[1] = it[2];
1334                tmp[2] = 0;
1335                output += (char)strtol(tmp, 0, 8);
1336                it += 2;
1337             }
1338             break;
1339          case 'x':
1340             if (it + 2 <= input.end()) {
1341                tmp[0] = it[1];
1342                tmp[1] = it[2];
1343                tmp[2] = 0;
1344                output += (char)strtol(tmp, 0, 16);
1345                it += 2;
1346             }
1347             break;
1348          default:
1349             // FIXME: raise exception here?
1350             break;
1351       }
1352    }
1353    return output;
1354 }
1355                                                                         /*}}}*/
1356 // URI::CopyFrom - Copy from an object                                  /*{{{*/
1357 // ---------------------------------------------------------------------
1358 /* This parses the URI into all of its components */
1359 void URI::CopyFrom(const string &U)
1360 {
1361    string::const_iterator I = U.begin();
1362
1363    // Locate the first colon, this separates the scheme
1364    for (; I < U.end() && *I != ':' ; ++I);
1365    string::const_iterator FirstColon = I;
1366
1367    /* Determine if this is a host type URI with a leading double //
1368       and then search for the first single / */
1369    string::const_iterator SingleSlash = I;
1370    if (I + 3 < U.end() && I[1] == '/' && I[2] == '/')
1371       SingleSlash += 3;
1372
1373    /* Find the / indicating the end of the hostname, ignoring /'s in the
1374       square brackets */
1375    bool InBracket = false;
1376    for (; SingleSlash < U.end() && (*SingleSlash != '/' || InBracket == true); ++SingleSlash)
1377    {
1378       if (*SingleSlash == '[')
1379          InBracket = true;
1380       if (InBracket == true && *SingleSlash == ']')
1381          InBracket = false;
1382    }
1383
1384    if (SingleSlash > U.end())
1385       SingleSlash = U.end();
1386
1387    // We can now write the access and path specifiers
1388    Access.assign(U.begin(),FirstColon);
1389    if (SingleSlash != U.end())
1390       Path.assign(SingleSlash,U.end());
1391    if (Path.empty() == true)
1392       Path = "/";
1393
1394    // Now we attempt to locate a user:pass@host fragment
1395    if (FirstColon + 2 <= U.end() && FirstColon[1] == '/' && FirstColon[2] == '/')
1396       FirstColon += 3;
1397    else
1398       FirstColon += 1;
1399    if (FirstColon >= U.end())
1400       return;
1401
1402    if (FirstColon > SingleSlash)
1403       FirstColon = SingleSlash;
1404
1405    // Find the colon...
1406    I = FirstColon + 1;
1407    if (I > SingleSlash)
1408       I = SingleSlash;
1409    for (; I < SingleSlash && *I != ':'; ++I);
1410    string::const_iterator SecondColon = I;
1411
1412    // Search for the @ after the colon
1413    for (; I < SingleSlash && *I != '@'; ++I);
1414    string::const_iterator At = I;
1415
1416    // Now write the host and user/pass
1417    if (At == SingleSlash)
1418    {
1419       if (FirstColon < SingleSlash)
1420          Host.assign(FirstColon,SingleSlash);
1421    }
1422    else
1423    {
1424       Host.assign(At+1,SingleSlash);
1425       // username and password must be encoded (RFC 3986)
1426       User.assign(DeQuoteString(FirstColon,SecondColon));
1427       if (SecondColon < At)
1428          Password.assign(DeQuoteString(SecondColon+1,At));
1429    }
1430
1431    // Now we parse the RFC 2732 [] hostnames.
1432    unsigned long PortEnd = 0;
1433    InBracket = false;
1434    for (unsigned I = 0; I != Host.length();)
1435    {
1436       if (Host[I] == '[')
1437       {
1438          InBracket = true;
1439          Host.erase(I,1);
1440          continue;
1441       }
1442
1443       if (InBracket == true && Host[I] == ']')
1444       {
1445          InBracket = false;
1446          Host.erase(I,1);
1447          PortEnd = I;
1448          continue;
1449       }
1450       I++;
1451    }
1452
1453    // Tsk, weird.
1454    if (InBracket == true)
1455    {
1456       Host.clear();
1457       return;
1458    }
1459
1460    // Now we parse off a port number from the hostname
1461    Port = 0;
1462    string::size_type Pos = Host.rfind(':');
1463    if (Pos == string::npos || Pos < PortEnd)
1464       return;
1465
1466    Port = atoi(string(Host,Pos+1).c_str());
1467    Host.assign(Host,0,Pos);
1468 }
1469                                                                         /*}}}*/
1470 // URI::operator string - Convert the URI to a string                   /*{{{*/
1471 // ---------------------------------------------------------------------
1472 /* */
1473 URI::operator string()
1474 {
1475    string Res;
1476
1477    if (Access.empty() == false)
1478       Res = Access + ':';
1479
1480    if (Host.empty() == false)
1481    {
1482       if (Access.empty() == false)
1483          Res += "//";
1484
1485       if (User.empty() == false)
1486       {
1487          // FIXME: Technically userinfo is permitted even less
1488          // characters than these, but this is not conveniently
1489          // expressed with a blacklist.
1490          Res += QuoteString(User, ":/?#[]@");
1491          if (Password.empty() == false)
1492             Res += ":" + QuoteString(Password, ":/?#[]@");
1493          Res += "@";
1494       }
1495
1496       // Add RFC 2732 escaping characters
1497       if (Access.empty() == false &&
1498           (Host.find('/') != string::npos || Host.find(':') != string::npos))
1499          Res += '[' + Host + ']';
1500       else
1501          Res += Host;
1502
1503       if (Port != 0)
1504       {
1505          char S[30];
1506          sprintf(S,":%u",Port);
1507          Res += S;
1508       }
1509    }
1510
1511    if (Path.empty() == false)
1512    {
1513       if (Path[0] != '/')
1514          Res += "/" + Path;
1515       else
1516          Res += Path;
1517    }
1518
1519    return Res;
1520 }
1521                                                                         /*}}}*/
1522 // URI::SiteOnly - Return the schema and site for the URI               /*{{{*/
1523 // ---------------------------------------------------------------------
1524 /* */
1525 string URI::SiteOnly(const string &URI)
1526 {
1527    ::URI U(URI);
1528    U.User.clear();
1529    U.Password.clear();
1530    U.Path.clear();
1531    return U;
1532 }
1533                                                                         /*}}}*/
1534 // URI::NoUserPassword - Return the schema, site and path for the URI   /*{{{*/
1535 // ---------------------------------------------------------------------
1536 /* */
1537 string URI::NoUserPassword(const string &URI)
1538 {
1539    ::URI U(URI);
1540    U.User.clear();
1541    U.Password.clear();
1542    return U;
1543 }
1544                                                                         /*}}}*/