apt-pkg/contrib/strutl.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: strutl.cc,v 1.22 1999/03/16 00:43:55 jgg Exp $
   4 /* ######################################################################
   5
   6    String Util - Some usefull string functions.
   7
   8    These have been collected from here and there to do all sorts of usefull
   9    things to strings. They are usefull 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 #ifdef __GNUG__
  19 #pragma implementation "apt-pkg/strutl.h"
  20 #endif
  21
  22 #include <apt-pkg/strutl.h>
  23 #include <apt-pkg//fileutl.h>
  24
  25 #include <ctype.h>
  26 #include <string.h>
  27 #include <stdio.h>
  28 #include <unistd.h>
  29 #include <errno.h>
  30                                                                         /*}}}*/
  31
  32 // strstrip - Remove white space from the front and back of a string    /*{{{*/
  33 // ---------------------------------------------------------------------
  34 /* This is handy to use when parsing a file. It also removes \n's left
  35    over from fgets and company */
  36 char *_strstrip(char *String)
  37 {
  38    for (;*String != 0 && (*String == ' ' || *String == '\t'); String++);
  39
  40    if (*String == 0)
  41       return String;
  42
  43    char *End = String + strlen(String) - 1;
  44    for (;End != String - 1 && (*End == ' ' || *End == '\t' || *End == '\n' ||
  45                                *End == '\r'); End--);
  46    End++;
  47    *End = 0;
  48    return String;
  49 };
  50                                                                         /*}}}*/
  51 // strtabexpand - Converts tabs into 8 spaces                           /*{{{*/
  52 // ---------------------------------------------------------------------
  53 /* */
  54 char *_strtabexpand(char *String,size_t Len)
  55 {
  56    for (char *I = String; I != I + Len && *I != 0; I++)
  57    {
  58       if (*I != '\t')
  59          continue;
  60       if (I + 8 > String + Len)
  61       {
  62          *I = 0;
  63          return String;
  64       }
  65
  66       /* Assume the start of the string is 0 and find the next 8 char
  67          division */
  68       int Len;
  69       if (String == I)
  70          Len = 1;
  71       else
  72          Len = 8 - ((String - I) % 8);
  73       Len -= 2;
  74       if (Len <= 0)
  75       {
  76          *I = ' ';
  77          continue;
  78       }
  79
  80       memmove(I + Len,I + 1,strlen(I) + 1);
  81       for (char *J = I; J + Len != I; *I = ' ', I++);
  82    }
  83    return String;
  84 }
  85                                                                         /*}}}*/
  86 // ParseQuoteWord - Parse a single word out of a string                 /*{{{*/
  87 // ---------------------------------------------------------------------
  88 /* This grabs a single word, converts any % escaped characters to their
  89    proper values and advances the pointer. Double quotes are understood
  90    and striped out as well. This is for URI/URL parsing. */
  91 bool ParseQuoteWord(const char *&String,string &Res)
  92 {
  93    // Skip leading whitespace
  94    const char *C = String;
  95    for (;*C != 0 && *C == ' '; C++);
  96    if (*C == 0)
  97       return false;
  98
  99    // Jump to the next word
 100    for (;*C != 0 && *C != ' '; C++)
 101    {
 102       if (*C == '"')
 103       {
 104          for (C++;*C != 0 && *C != '"'; C++);
 105          if (*C == 0)
 106             return false;
 107       }
 108    }
 109
 110    // Now de-quote characters
 111    char Buffer[1024];
 112    char Tmp[3];
 113    const char *Start = String;
 114    char *I;
 115    for (I = Buffer; I < Buffer + sizeof(Buffer) && Start != C; I++)
 116    {
 117       if (*Start == '%' && Start + 2 < C)
 118       {
 119          Tmp[0] = Start[1];
 120          Tmp[1] = Start[2];
 121          Tmp[2] = 0;
 122          *I = (char)strtol(Tmp,0,16);
 123          Start += 3;
 124          continue;
 125       }
 126       if (*Start != '"')
 127          *I = *Start;
 128       else
 129          I--;
 130       Start++;
 131    }
 132    *I = 0;
 133    Res = Buffer;
 134
 135    // Skip ending white space
 136    for (;*C != 0 && *C == ' '; C++);
 137    String = C;
 138    return true;
 139 }
 140                                                                         /*}}}*/
 141 // ParseCWord - Parses a string like a C "" expression                  /*{{{*/
 142 // ---------------------------------------------------------------------
 143 /* This expects a series of space seperated strings enclosed in ""'s.
 144    It concatenates the ""'s into a single string. */
 145 bool ParseCWord(const char *String,string &Res)
 146 {
 147    // Skip leading whitespace
 148    const char *C = String;
 149    for (;*C != 0 && *C == ' '; C++);
 150    if (*C == 0)
 151       return false;
 152
 153    char Buffer[1024];
 154    char *Buf = Buffer;
 155    if (strlen(String) >= sizeof(Buffer))
 156        return false;
 157
 158    for (; *C != 0; C++)
 159    {
 160       if (*C == '"')
 161       {
 162          for (C++; *C != 0 && *C != '"'; C++)
 163             *Buf++ = *C;
 164
 165          if (*C == 0)
 166             return false;
 167
 168          continue;
 169       }
 170
 171       if (C != String && isspace(*C) != 0 && isspace(C[-1]) != 0)
 172          continue;
 173       if (isspace(*C) == 0)
 174          return false;
 175       *Buf++ = ' ';
 176    }
 177    *Buf = 0;
 178    Res = Buffer;
 179    return true;
 180 }
 181                                                                         /*}}}*/
 182 // QuoteString - Convert a string into quoted from                      /*{{{*/
 183 // ---------------------------------------------------------------------
 184 /* */
 185 string QuoteString(string Str,const char *Bad)
 186 {
 187    string Res;
 188    for (string::iterator I = Str.begin(); I != Str.end(); I++)
 189    {
 190       if (strchr(Bad,*I) != 0 || isprint(*I) == 0 ||
 191           *I <= 0x20 || *I >= 0x7F)
 192       {
 193          char Buf[10];
 194          sprintf(Buf,"%%%02x",(int)*I);
 195          Res += Buf;
 196       }
 197       else
 198          Res += *I;
 199    }
 200    return Res;
 201 }
 202                                                                         /*}}}*/
 203 // DeQuoteString - Convert a string from quoted from                    /*{{{*/
 204 // ---------------------------------------------------------------------
 205 /* This undoes QuoteString */
 206 string DeQuoteString(string Str)
 207 {
 208    string Res;
 209    for (string::iterator I = Str.begin(); I != Str.end(); I++)
 210    {
 211       if (*I == '%' && I + 2 < Str.end())
 212       {
 213          char Tmp[3];
 214          Tmp[0] = I[1];
 215          Tmp[1] = I[2];
 216          Tmp[2] = 0;
 217          Res += (char)strtol(Tmp,0,16);
 218          I += 2;
 219          continue;
 220       }
 221       else
 222          Res += *I;
 223    }
 224    return Res;
 225 }
 226
 227                                                                         /*}}}*/
 228 // SizeToStr - Convert a long into a human readable size                /*{{{*/
 229 // ---------------------------------------------------------------------
 230 /* A max of 4 digits are shown before conversion to the next highest unit.
 231    The max length of the string will be 5 chars unless the size is > 10
 232    YottaBytes (E24) */
 233 string SizeToStr(double Size)
 234 {
 235    char S[300];
 236    double ASize;
 237    if (Size >= 0)
 238       ASize = Size;
 239    else
 240       ASize = -1*Size;
 241
 242    /* bytes, KiloBytes, MegaBytes, GigaBytes, TeraBytes, PetaBytes,
 243       ExaBytes, ZettaBytes, YottaBytes */
 244    char Ext[] = {'\0','k','M','G','T','P','E','Z','Y'};
 245    int I = 0;
 246    while (I <= 8)
 247    {
 248       if (ASize < 100 && I != 0)
 249       {
 250          sprintf(S,"%.1f%c",ASize,Ext[I]);
 251          break;
 252       }
 253
 254       if (ASize < 10000)
 255       {
 256          sprintf(S,"%.0f%c",ASize,Ext[I]);
 257          break;
 258       }
 259       ASize /= 1000.0;
 260       I++;
 261    }
 262
 263    return S;
 264 }
 265                                                                         /*}}}*/
 266 // TimeToStr - Convert the time into a string                           /*{{{*/
 267 // ---------------------------------------------------------------------
 268 /* Converts a number of seconds to a hms format */
 269 string TimeToStr(unsigned long Sec)
 270 {
 271    char S[300];
 272
 273    while (1)
 274    {
 275       if (Sec > 60*60*24)
 276       {
 277          sprintf(S,"%lid %lih%lim%lis",Sec/60/60/24,(Sec/60/60) % 24,(Sec/60) % 60,Sec % 60);
 278          break;
 279       }
 280
 281       if (Sec > 60*60)
 282       {
 283          sprintf(S,"%lih%lim%lis",Sec/60/60,(Sec/60) % 60,Sec % 60);
 284          break;
 285       }
 286
 287       if (Sec > 60)
 288       {
 289          sprintf(S,"%lim%lis",Sec/60,Sec % 60);
 290          break;
 291       }
 292
 293       sprintf(S,"%lis",Sec);
 294       break;
 295    }
 296
 297    return S;
 298 }
 299                                                                         /*}}}*/
 300 // SubstVar - Substitute a string for another string                    /*{{{*/
 301 // ---------------------------------------------------------------------
 302 /* This replaces all occurances of Subst with Contents in Str. */
 303 string SubstVar(string Str,string Subst,string Contents)
 304 {
 305    string::size_type Pos = 0;
 306    string::size_type OldPos = 0;
 307    string Temp;
 308
 309    while (OldPos < Str.length() &&
 310           (Pos = Str.find(Subst,OldPos)) != string::npos)
 311    {
 312       Temp += string(Str,OldPos,Pos) + Contents;
 313       OldPos = Pos + Subst.length();
 314    }
 315
 316    if (OldPos == 0)
 317       return Str;
 318
 319    return Temp + string(Str,OldPos);
 320 }
 321                                                                         /*}}}*/
 322 // URItoFileName - Convert the uri into a unique file name              /*{{{*/
 323 // ---------------------------------------------------------------------
 324 /* This converts a URI into a safe filename. It quotes all unsafe characters
 325    and converts / to _ and removes the scheme identifier. The resulting
 326    file name should be unique and never occur again for a different file */
 327 string URItoFileName(string URI)
 328 {
 329    string::const_iterator I = URI.begin() + URI.find(':') + 1;
 330    for (; I < URI.end() && *I == '/'; I++);
 331
 332    // "\x00-\x20{}|\\\\^\\[\\]<>\"\x7F-\xFF";
 333    URI = QuoteString(string(I,URI.end() - I),"\\|{}[]<>\"^~_=!@#$%^&*");
 334    string::iterator J = URI.begin();
 335    for (; J != URI.end(); J++)
 336       if (*J == '/')
 337          *J = '_';
 338    return URI;
 339 }
 340                                                                         /*}}}*/
 341 // Base64Encode - Base64 Encoding routine for short strings             /*{{{*/
 342 // ---------------------------------------------------------------------
 343 /* This routine performs a base64 transformation on a string. It was ripped
 344    from wget and then patched and bug fixed.
 345
 346    This spec can be found in rfc2045 */
 347 string Base64Encode(string S)
 348 {
 349    // Conversion table.
 350    static char tbl[64] = {'A','B','C','D','E','F','G','H',
 351                           'I','J','K','L','M','N','O','P',
 352                           'Q','R','S','T','U','V','W','X',
 353                           'Y','Z','a','b','c','d','e','f',
 354                           'g','h','i','j','k','l','m','n',
 355                           'o','p','q','r','s','t','u','v',
 356                           'w','x','y','z','0','1','2','3',
 357                           '4','5','6','7','8','9','+','/'};
 358
 359    // Pre-allocate some space
 360    string Final;
 361    Final.reserve((4*S.length() + 2)/3 + 2);
 362
 363    /* Transform the 3x8 bits to 4x6 bits, as required by
 364       base64.  */
 365    for (string::const_iterator I = S.begin(); I < S.end(); I += 3)
 366    {
 367       char Bits[3] = {0,0,0};
 368       Bits[0] = I[0];
 369       if (I + 1 < S.end())
 370          Bits[1] = I[1];
 371       if (I + 2 < S.end())
 372          Bits[2] = I[2];
 373
 374       Final += tbl[Bits[0] >> 2];
 375       Final += tbl[((Bits[0] & 3) << 4) + (Bits[1] >> 4)];
 376
 377       if (I + 1 >= S.end())
 378          break;
 379
 380       Final += tbl[((Bits[1] & 0xf) << 2) + (Bits[2] >> 6)];
 381
 382       if (I + 2 >= S.end())
 383          break;
 384
 385       Final += tbl[Bits[2] & 0x3f];
 386    }
 387
 388    /* Apply the padding elements, this tells how many bytes the remote
 389       end should discard */
 390    if (S.length() % 3 == 2)
 391       Final += '=';
 392    if (S.length() % 3 == 1)
 393       Final += "==";
 394
 395    return Final;
 396 }
 397                                                                         /*}}}*/
 398 // stringcmp - Arbitary string compare                                  /*{{{*/
 399 // ---------------------------------------------------------------------
 400 /* This safely compares two non-null terminated strings of arbitary
 401    length */
 402 int stringcmp(const char *A,const char *AEnd,const char *B,const char *BEnd)
 403 {
 404    for (; A != AEnd && B != BEnd; A++, B++)
 405       if (*A != *B)
 406          break;
 407
 408    if (A == AEnd && B == BEnd)
 409       return 0;
 410    if (A == AEnd)
 411       return 1;
 412    if (B == BEnd)
 413       return -1;
 414    if (*A < *B)
 415       return -1;
 416    return 1;
 417 }
 418                                                                         /*}}}*/
 419 // stringcasecmp - Arbitary case insensitive string compare             /*{{{*/
 420 // ---------------------------------------------------------------------
 421 /* */
 422 int stringcasecmp(const char *A,const char *AEnd,const char *B,const char *BEnd)
 423 {
 424    for (; A != AEnd && B != BEnd; A++, B++)
 425       if (toupper(*A) != toupper(*B))
 426          break;
 427
 428    if (A == AEnd && B == BEnd)
 429       return 0;
 430    if (A == AEnd)
 431       return 1;
 432    if (B == BEnd)
 433       return -1;
 434    if (toupper(*A) < toupper(*B))
 435       return -1;
 436    return 1;
 437 }
 438                                                                         /*}}}*/
 439 // LookupTag - Lookup the value of a tag in a taged string              /*{{{*/
 440 // ---------------------------------------------------------------------
 441 /* The format is like those used in package files and the method
 442    communication system */
 443 string LookupTag(string Message,const char *Tag,const char *Default)
 444 {
 445    // Look for a matching tag.
 446    int Length = strlen(Tag);
 447    for (string::iterator I = Message.begin(); I + Length < Message.end(); I++)
 448    {
 449       // Found the tag
 450       if (I[Length] == ':' && stringcasecmp(I,I+Length,Tag) == 0)
 451       {
 452          // Find the end of line and strip the leading/trailing spaces
 453          string::iterator J;
 454          I += Length + 1;
 455          for (; isspace(*I) != 0 && I < Message.end(); I++);
 456          for (J = I; *J != '\n' && J < Message.end(); J++);
 457          for (; J > I && isspace(J[-1]) != 0; J--);
 458
 459          return string(I,J-I);
 460       }
 461
 462       for (; *I != '\n' && I < Message.end(); I++);
 463    }
 464
 465    // Failed to find a match
 466    if (Default == 0)
 467       return string();
 468    return Default;
 469 }
 470                                                                         /*}}}*/
 471 // StringToBool - Converts a string into a boolean                      /*{{{*/
 472 // ---------------------------------------------------------------------
 473 /* This inspects the string to see if it is true or if it is false and
 474    then returns the result. Several varients on true/false are checked. */
 475 int StringToBool(string Text,int Default = -1)
 476 {
 477    char *End;
 478    int Res = strtol(Text.c_str(),&End,0);
 479    if (End != Text.c_str() && Res >= 0 && Res <= 1)
 480       return Res;
 481
 482    // Check for positives
 483    if (strcasecmp(Text.c_str(),"no") == 0 ||
 484        strcasecmp(Text.c_str(),"false") == 0 ||
 485        strcasecmp(Text.c_str(),"without") == 0 ||
 486        strcasecmp(Text.c_str(),"off") == 0 ||
 487        strcasecmp(Text.c_str(),"disable") == 0)
 488       return 0;
 489
 490    // Check for negatives
 491    if (strcasecmp(Text.c_str(),"yes") == 0 ||
 492        strcasecmp(Text.c_str(),"true") == 0 ||
 493        strcasecmp(Text.c_str(),"with") == 0 ||
 494        strcasecmp(Text.c_str(),"on") == 0 ||
 495        strcasecmp(Text.c_str(),"enable") == 0)
 496       return 1;
 497
 498    return Default;
 499 }
 500                                                                         /*}}}*/
 501 // TimeRFC1123 - Convert a time_t into RFC1123 format                   /*{{{*/
 502 // ---------------------------------------------------------------------
 503 /* This converts a time_t into a string time representation that is
 504    year 2000 complient and timezone neutral */
 505 string TimeRFC1123(time_t Date)
 506 {
 507    struct tm Conv = *gmtime(&Date);
 508    char Buf[300];
 509
 510    const char *Day[] = {"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
 511    const char *Month[] = {"Jan","Feb","Mar","Apr","May","Jun","Jul",
 512                           "Aug","Sep","Oct","Nov","Dec"};
 513
 514    sprintf(Buf,"%s, %02i %s %i %02i:%02i:%02i GMT",Day[Conv.tm_wday],
 515            Conv.tm_mday,Month[Conv.tm_mon],Conv.tm_year+1900,Conv.tm_hour,
 516            Conv.tm_min,Conv.tm_sec);
 517    return Buf;
 518 }
 519                                                                         /*}}}*/
 520 // ReadMessages - Read messages from the FD                             /*{{{*/
 521 // ---------------------------------------------------------------------
 522 /* This pulls full messages from the input FD into the message buffer.
 523    It assumes that messages will not pause during transit so no
 524    fancy buffering is used. */
 525 bool ReadMessages(int Fd, vector<string> &List)
 526 {
 527    char Buffer[4000];
 528    char *End = Buffer;
 529
 530    while (1)
 531    {
 532       int Res = read(Fd,End,sizeof(Buffer) - (End-Buffer));
 533       if (Res < 0 && errno == EINTR)
 534          continue;
 535
 536       // Process is dead, this is kind of bad..
 537       if (Res == 0)
 538          return false;
 539
 540       // No data
 541       if (Res <= 0)
 542          return true;
 543
 544       End += Res;
 545
 546       // Look for the end of the message
 547       for (char *I = Buffer; I + 1 < End; I++)
 548       {
 549          if (I[0] != '\n' || I[1] != '\n')
 550             continue;
 551
 552          // Pull the message out
 553          string Message(Buffer,0,I-Buffer);
 554
 555          // Fix up the buffer
 556          for (; I < End && *I == '\n'; I++);
 557          End -= I-Buffer;
 558          memmove(Buffer,I,End-Buffer);
 559          I = Buffer;
 560
 561          List.push_back(Message);
 562       }
 563       if (End == Buffer)
 564          return true;
 565
 566       if (WaitFd(Fd) == false)
 567          return false;
 568    }
 569 }
 570                                                                         /*}}}*/
 571 // MonthConv - Converts a month string into a number                    /*{{{*/
 572 // ---------------------------------------------------------------------
 573 /* This was lifted from the boa webserver which lifted it from 'wn-v1.07'
 574    Made it a bit more robust with a few touppers though. */
 575 static int MonthConv(char *Month)
 576 {
 577    switch (toupper(*Month))
 578    {
 579       case 'A':
 580       return toupper(Month[1]) == 'P'?3:7;
 581       case 'D':
 582       return 11;
 583       case 'F':
 584       return 1;
 585       case 'J':
 586       if (toupper(Month[1]) == 'A')
 587          return 0;
 588       return toupper(Month[2]) == 'N'?5:6;
 589       case 'M':
 590       return toupper(Month[2]) == 'R'?2:4;
 591       case 'N':
 592       return 10;
 593       case 'O':
 594       return 9;
 595       case 'S':
 596       return 8;
 597
 598       // Pretend it is January..
 599       default:
 600       return 0;
 601    }
 602 }
 603                                                                         /*}}}*/
 604 // timegm - Internal timegm function if gnu is not available            /*{{{*/
 605 // ---------------------------------------------------------------------
 606 /* Ripped this evil little function from wget - I prefer the use of
 607    GNU timegm if possible as this technique will have interesting problems
 608    with leap seconds, timezones and other.
 609
 610    Converts struct tm to time_t, assuming the data in tm is UTC rather
 611    than local timezone (mktime assumes the latter).
 612
 613    Contributed by Roger Beeman <beeman@cisco.com>, with the help of
 614    Mark Baushke <mdb@cisco.com> and the rest of the Gurus at CISCO. */
 615 #ifndef __USE_MISC        // glib sets this
 616 static time_t timegm(struct tm *t)
 617 {
 618    time_t tl, tb;
 619
 620    tl = mktime (t);
 621    if (tl == -1)
 622       return -1;
 623    tb = mktime (gmtime (&tl));
 624    return (tl <= tb ? (tl + (tl - tb)) : (tl - (tb - tl)));
 625 }
 626 #endif
 627                                                                         /*}}}*/
 628 // StrToTime - Converts a string into a time_t                          /*{{{*/
 629 // ---------------------------------------------------------------------
 630 /* This handles all 3 populare time formats including RFC 1123, RFC 1036
 631    and the C library asctime format. It requires the GNU library function
 632    'timegm' to convert a struct tm in UTC to a time_t. For some bizzar
 633    reason the C library does not provide any such function :<*/
 634 bool StrToTime(string Val,time_t &Result)
 635 {
 636    struct tm Tm;
 637    char Month[10];
 638    const char *I = Val.c_str();
 639
 640    // Skip the day of the week
 641    for (;*I != 0  && *I != ' '; I++);
 642
 643    // Handle RFC 1123 time
 644    if (sscanf(I," %d %3s %d %d:%d:%d GMT",&Tm.tm_mday,Month,&Tm.tm_year,
 645               &Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec) != 6)
 646    {
 647       // Handle RFC 1036 time
 648       if (sscanf(I," %d-%3s-%d %d:%d:%d GMT",&Tm.tm_mday,Month,
 649                  &Tm.tm_year,&Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec) == 6)
 650          Tm.tm_year += 1900;
 651       else
 652       {
 653          // asctime format
 654          if (sscanf(I," %3s %d %d:%d:%d %d",Month,&Tm.tm_mday,
 655                     &Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec,&Tm.tm_year) != 6)
 656             return false;
 657       }
 658    }
 659
 660    Tm.tm_isdst = 0;
 661    Tm.tm_mon = MonthConv(Month);
 662    Tm.tm_year -= 1900;
 663
 664    // Convert to local time and then to GMT
 665    Result = timegm(&Tm);
 666    return true;
 667 }
 668                                                                         /*}}}*/
 669
 670 // URI::CopyFrom - Copy from an object                                  /*{{{*/
 671 // ---------------------------------------------------------------------
 672 /* This parses the URI into all of its components */
 673 void URI::CopyFrom(string U)
 674 {
 675    string::const_iterator I = U.begin();
 676
 677    // Locate the first colon, this seperates the scheme
 678    for (; I < U.end() && *I != ':' ; I++);
 679    string::const_iterator FirstColon = I;
 680
 681    /* Determine if this is a host type URI with a leading double //
 682       and then search for the first single / */
 683    string::const_iterator SingleSlash = I;
 684    if (I + 3 < U.end() && I[1] == '/' && I[2] == '/')
 685       SingleSlash += 3;
 686    for (; SingleSlash < U.end() && *SingleSlash != '/'; SingleSlash++);
 687    if (SingleSlash > U.end())
 688       SingleSlash = U.end();
 689
 690    // We can now write the access and path specifiers
 691    Access = string(U,0,FirstColon - U.begin());
 692    if (SingleSlash != U.end())
 693       Path = string(U,SingleSlash - U.begin());
 694    if (Path.empty() == true)
 695       Path = "/";
 696
 697    // Now we attempt to locate a user:pass@host fragment
 698    if (FirstColon[1] == '/' && FirstColon[2] == '/')
 699       FirstColon += 3;
 700    else
 701       FirstColon += 1;
 702    if (FirstColon >= U.end())
 703       return;
 704
 705    if (FirstColon > SingleSlash)
 706       FirstColon = SingleSlash;
 707
 708    // Search for the @
 709    I = FirstColon;
 710    for (; I < SingleSlash && *I != '@'; I++);
 711    string::const_iterator At = I;
 712
 713    // Colon in the @ section
 714    I = FirstColon + 1;
 715    for (; I < At && *I != ':'; I++);
 716    string::const_iterator SecondColon = I;
 717
 718    // Now write the host and user/pass
 719    if (At == SingleSlash)
 720    {
 721       if (FirstColon < SingleSlash)
 722          Host = string(U,FirstColon - U.begin(),SingleSlash - FirstColon);
 723    }
 724    else
 725    {
 726       Host = string(U,At - U.begin() + 1,SingleSlash - At - 1);
 727       User = string(U,FirstColon - U.begin(),SecondColon - FirstColon);
 728       if (SecondColon < At)
 729          Password = string(U,SecondColon - U.begin() + 1,At - SecondColon - 1);
 730    }
 731
 732    // Now we parse off a pot number from the hostname
 733    Port = 0;
 734    string::size_type Pos = Host.rfind(':');
 735    if (Pos == string::npos)
 736       return;
 737
 738    Port = atoi(string(Host,Pos+1).c_str());
 739    Host = string(Host,0,Pos);
 740 }
 741                                                                         /*}}}*/
 742 // URI::operator string - Convert the URI to a string                   /*{{{*/
 743 // ---------------------------------------------------------------------
 744 /* */
 745 URI::operator string()
 746 {
 747    string Res = Access + ':';
 748    if (Host.empty() == false)
 749    {
 750       Res += "//";
 751       if (User.empty() == false)
 752       {
 753          Res += "//" + User;
 754          if (Password.empty() == false)
 755             Res += ":" + Password;
 756          Res += "@";
 757       }
 758       Res += Host;
 759       if (Port != 0)
 760       {
 761          char S[30];
 762          sprintf(S,":%u",Port);
 763          Res += S;
 764       }
 765    }
 766
 767    if (Path.empty() == false)
 768    {
 769       if (Path[0] != '/')
 770          Res += "/" + Path;
 771       else
 772          Res += Path;
 773    }
 774
 775    return Res;
 776 }
 777                                                                         /*}}}*/