apt-pkg/contrib/strutl.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: strutl.cc,v 1.29 1999/08/28 01:49:08 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 && isspace(*C) == 0; 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 && isspace(*C) != 0; 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 // StrToNum - Convert a fixed length string to a number                 /*{{{*/
 670 // ---------------------------------------------------------------------
 671 /* This is used in decoding the crazy fixed length string headers in
 672    tar and ar files. */
 673 bool StrToNum(const char *Str,unsigned long &Res,unsigned Len,unsigned Base)
 674 {
 675    char S[30];
 676    if (Len >= sizeof(S))
 677       return false;
 678    memcpy(S,Str,Len);
 679    S[Len] = 0;
 680
 681    // All spaces is a zero
 682    Res = 0;
 683    unsigned I;
 684    for (I = 0; S[I] == ' '; I++);
 685    if (S[I] == 0)
 686       return true;
 687
 688    char *End;
 689    Res = strtoul(S,&End,Base);
 690    if (End == S)
 691       return false;
 692
 693    return true;
 694 }
 695                                                                         /*}}}*/
 696 // HexDigit - Convert a hex character into an integer                   /*{{{*/
 697 // ---------------------------------------------------------------------
 698 /* Helper for Hex2Num */
 699 static int HexDigit(int c)
 700 {
 701    if (c >= '0' && c <= '9')
 702       return c - '0';
 703    if (c >= 'a' && c <= 'f')
 704       return c - 'a' + 10;
 705    if (c >= 'A' && c <= 'F')
 706       return c - 'A' + 10;
 707    return 0;
 708 }
 709                                                                         /*}}}*/
 710 // Hex2Num - Convert a long hex number into a buffer                    /*{{{*/
 711 // ---------------------------------------------------------------------
 712 /* The length of the buffer must be exactly 1/2 the length of the string. */
 713 bool Hex2Num(const char *Start,const char *End,unsigned char *Num,
 714              unsigned int Length)
 715 {
 716    if (End - Start != (signed)(Length*2))
 717       return false;
 718
 719    // Convert each digit. We store it in the same order as the string
 720    int J = 0;
 721    for (const char *I = Start; I < End;J++, I += 2)
 722    {
 723       if (isxdigit(*I) == 0 || isxdigit(I[1]) == 0)
 724          return false;
 725
 726       Num[J] = HexDigit(I[0]) << 4;
 727       Num[J] += HexDigit(I[1]);
 728    }
 729
 730    return true;
 731 }
 732                                                                         /*}}}*/
 733
 734 // URI::CopyFrom - Copy from an object                                  /*{{{*/
 735 // ---------------------------------------------------------------------
 736 /* This parses the URI into all of its components */
 737 void URI::CopyFrom(string U)
 738 {
 739    string::const_iterator I = U.begin();
 740
 741    // Locate the first colon, this seperates the scheme
 742    for (; I < U.end() && *I != ':' ; I++);
 743    string::const_iterator FirstColon = I;
 744
 745    /* Determine if this is a host type URI with a leading double //
 746       and then search for the first single / */
 747    string::const_iterator SingleSlash = I;
 748    if (I + 3 < U.end() && I[1] == '/' && I[2] == '/')
 749       SingleSlash += 3;
 750    for (; SingleSlash < U.end() && *SingleSlash != '/'; SingleSlash++);
 751    if (SingleSlash > U.end())
 752       SingleSlash = U.end();
 753
 754    // We can now write the access and path specifiers
 755    Access = string(U,0,FirstColon - U.begin());
 756    if (SingleSlash != U.end())
 757       Path = string(U,SingleSlash - U.begin());
 758    if (Path.empty() == true)
 759       Path = "/";
 760
 761    // Now we attempt to locate a user:pass@host fragment
 762    if (FirstColon[1] == '/' && FirstColon[2] == '/')
 763       FirstColon += 3;
 764    else
 765       FirstColon += 1;
 766    if (FirstColon >= U.end())
 767       return;
 768
 769    if (FirstColon > SingleSlash)
 770       FirstColon = SingleSlash;
 771
 772    // Find the colon...
 773    I = FirstColon + 1;
 774    if (I > SingleSlash)
 775       I = SingleSlash;
 776    for (; I < SingleSlash && *I != ':'; I++);
 777    string::const_iterator SecondColon = I;
 778
 779    // Search for the @ after the colon
 780    for (; I < SingleSlash && *I != '@'; I++);
 781    string::const_iterator At = I;
 782
 783    // Now write the host and user/pass
 784    if (At == SingleSlash)
 785    {
 786       if (FirstColon < SingleSlash)
 787          Host = string(U,FirstColon - U.begin(),SingleSlash - FirstColon);
 788    }
 789    else
 790    {
 791       Host = string(U,At - U.begin() + 1,SingleSlash - At - 1);
 792       User = string(U,FirstColon - U.begin(),SecondColon - FirstColon);
 793       if (SecondColon < At)
 794          Password = string(U,SecondColon - U.begin() + 1,At - SecondColon - 1);
 795    }
 796
 797    // Now we parse off a port number from the hostname
 798    Port = 0;
 799    string::size_type Pos = Host.rfind(':');
 800    if (Pos == string::npos)
 801       return;
 802
 803    Port = atoi(string(Host,Pos+1).c_str());
 804    Host = string(Host,0,Pos);
 805 }
 806                                                                         /*}}}*/
 807 // URI::operator string - Convert the URI to a string                   /*{{{*/
 808 // ---------------------------------------------------------------------
 809 /* */
 810 URI::operator string()
 811 {
 812    string Res = Access + ':';
 813    if (Host.empty() == false)
 814    {
 815       Res += "//";
 816       if (User.empty() == false)
 817       {
 818          Res += "//" + User;
 819          if (Password.empty() == false)
 820             Res += ":" + Password;
 821          Res += "@";
 822       }
 823       Res += Host;
 824       if (Port != 0)
 825       {
 826          char S[30];
 827          sprintf(S,":%u",Port);
 828          Res += S;
 829       }
 830    }
 831
 832    if (Path.empty() == false)
 833    {
 834       if (Path[0] != '/')
 835          Res += "/" + Path;
 836       else
 837          Res += Path;
 838    }
 839
 840    return Res;
 841 }
 842                                                                         /*}}}*/