apt-pkg/contrib/strutl.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: strutl.cc,v 1.32 2000/01/10 03:44:54 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    // Nuke 'sensitive' items
 330    ::URI U(URI);
 331    U.User = string();
 332    U.Password = string();
 333    U.Access = "";
 334
 335    // "\x00-\x20{}|\\\\^\\[\\]<>\"\x7F-\xFF";
 336    URI = QuoteString(U,"\\|{}[]<>\"^~_=!@#$%^&*");
 337    string::iterator J = URI.begin();
 338    for (; J != URI.end(); J++)
 339       if (*J == '/')
 340          *J = '_';
 341    return URI;
 342 }
 343                                                                         /*}}}*/
 344 // Base64Encode - Base64 Encoding routine for short strings             /*{{{*/
 345 // ---------------------------------------------------------------------
 346 /* This routine performs a base64 transformation on a string. It was ripped
 347    from wget and then patched and bug fixed.
 348
 349    This spec can be found in rfc2045 */
 350 string Base64Encode(string S)
 351 {
 352    // Conversion table.
 353    static char tbl[64] = {'A','B','C','D','E','F','G','H',
 354                           'I','J','K','L','M','N','O','P',
 355                           'Q','R','S','T','U','V','W','X',
 356                           'Y','Z','a','b','c','d','e','f',
 357                           'g','h','i','j','k','l','m','n',
 358                           'o','p','q','r','s','t','u','v',
 359                           'w','x','y','z','0','1','2','3',
 360                           '4','5','6','7','8','9','+','/'};
 361
 362    // Pre-allocate some space
 363    string Final;
 364    Final.reserve((4*S.length() + 2)/3 + 2);
 365
 366    /* Transform the 3x8 bits to 4x6 bits, as required by
 367       base64.  */
 368    for (string::const_iterator I = S.begin(); I < S.end(); I += 3)
 369    {
 370       char Bits[3] = {0,0,0};
 371       Bits[0] = I[0];
 372       if (I + 1 < S.end())
 373          Bits[1] = I[1];
 374       if (I + 2 < S.end())
 375          Bits[2] = I[2];
 376
 377       Final += tbl[Bits[0] >> 2];
 378       Final += tbl[((Bits[0] & 3) << 4) + (Bits[1] >> 4)];
 379
 380       if (I + 1 >= S.end())
 381          break;
 382
 383       Final += tbl[((Bits[1] & 0xf) << 2) + (Bits[2] >> 6)];
 384
 385       if (I + 2 >= S.end())
 386          break;
 387
 388       Final += tbl[Bits[2] & 0x3f];
 389    }
 390
 391    /* Apply the padding elements, this tells how many bytes the remote
 392       end should discard */
 393    if (S.length() % 3 == 2)
 394       Final += '=';
 395    if (S.length() % 3 == 1)
 396       Final += "==";
 397
 398    return Final;
 399 }
 400                                                                         /*}}}*/
 401 // stringcmp - Arbitary string compare                                  /*{{{*/
 402 // ---------------------------------------------------------------------
 403 /* This safely compares two non-null terminated strings of arbitary
 404    length */
 405 int stringcmp(const char *A,const char *AEnd,const char *B,const char *BEnd)
 406 {
 407    for (; A != AEnd && B != BEnd; A++, B++)
 408       if (*A != *B)
 409          break;
 410
 411    if (A == AEnd && B == BEnd)
 412       return 0;
 413    if (A == AEnd)
 414       return 1;
 415    if (B == BEnd)
 416       return -1;
 417    if (*A < *B)
 418       return -1;
 419    return 1;
 420 }
 421                                                                         /*}}}*/
 422 // stringcasecmp - Arbitary case insensitive string compare             /*{{{*/
 423 // ---------------------------------------------------------------------
 424 /* */
 425 int stringcasecmp(const char *A,const char *AEnd,const char *B,const char *BEnd)
 426 {
 427    for (; A != AEnd && B != BEnd; A++, B++)
 428       if (toupper(*A) != toupper(*B))
 429          break;
 430
 431    if (A == AEnd && B == BEnd)
 432       return 0;
 433    if (A == AEnd)
 434       return 1;
 435    if (B == BEnd)
 436       return -1;
 437    if (toupper(*A) < toupper(*B))
 438       return -1;
 439    return 1;
 440 }
 441                                                                         /*}}}*/
 442 // LookupTag - Lookup the value of a tag in a taged string              /*{{{*/
 443 // ---------------------------------------------------------------------
 444 /* The format is like those used in package files and the method
 445    communication system */
 446 string LookupTag(string Message,const char *Tag,const char *Default)
 447 {
 448    // Look for a matching tag.
 449    int Length = strlen(Tag);
 450    for (string::iterator I = Message.begin(); I + Length < Message.end(); I++)
 451    {
 452       // Found the tag
 453       if (I[Length] == ':' && stringcasecmp(I,I+Length,Tag) == 0)
 454       {
 455          // Find the end of line and strip the leading/trailing spaces
 456          string::iterator J;
 457          I += Length + 1;
 458          for (; isspace(*I) != 0 && I < Message.end(); I++);
 459          for (J = I; *J != '\n' && J < Message.end(); J++);
 460          for (; J > I && isspace(J[-1]) != 0; J--);
 461
 462          return string(I,J-I);
 463       }
 464
 465       for (; *I != '\n' && I < Message.end(); I++);
 466    }
 467
 468    // Failed to find a match
 469    if (Default == 0)
 470       return string();
 471    return Default;
 472 }
 473                                                                         /*}}}*/
 474 // StringToBool - Converts a string into a boolean                      /*{{{*/
 475 // ---------------------------------------------------------------------
 476 /* This inspects the string to see if it is true or if it is false and
 477    then returns the result. Several varients on true/false are checked. */
 478 int StringToBool(string Text,int Default = -1)
 479 {
 480    char *End;
 481    int Res = strtol(Text.c_str(),&End,0);
 482    if (End != Text.c_str() && Res >= 0 && Res <= 1)
 483       return Res;
 484
 485    // Check for positives
 486    if (strcasecmp(Text.c_str(),"no") == 0 ||
 487        strcasecmp(Text.c_str(),"false") == 0 ||
 488        strcasecmp(Text.c_str(),"without") == 0 ||
 489        strcasecmp(Text.c_str(),"off") == 0 ||
 490        strcasecmp(Text.c_str(),"disable") == 0)
 491       return 0;
 492
 493    // Check for negatives
 494    if (strcasecmp(Text.c_str(),"yes") == 0 ||
 495        strcasecmp(Text.c_str(),"true") == 0 ||
 496        strcasecmp(Text.c_str(),"with") == 0 ||
 497        strcasecmp(Text.c_str(),"on") == 0 ||
 498        strcasecmp(Text.c_str(),"enable") == 0)
 499       return 1;
 500
 501    return Default;
 502 }
 503                                                                         /*}}}*/
 504 // TimeRFC1123 - Convert a time_t into RFC1123 format                   /*{{{*/
 505 // ---------------------------------------------------------------------
 506 /* This converts a time_t into a string time representation that is
 507    year 2000 complient and timezone neutral */
 508 string TimeRFC1123(time_t Date)
 509 {
 510    struct tm Conv = *gmtime(&Date);
 511    char Buf[300];
 512
 513    const char *Day[] = {"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
 514    const char *Month[] = {"Jan","Feb","Mar","Apr","May","Jun","Jul",
 515                           "Aug","Sep","Oct","Nov","Dec"};
 516
 517    sprintf(Buf,"%s, %02i %s %i %02i:%02i:%02i GMT",Day[Conv.tm_wday],
 518            Conv.tm_mday,Month[Conv.tm_mon],Conv.tm_year+1900,Conv.tm_hour,
 519            Conv.tm_min,Conv.tm_sec);
 520    return Buf;
 521 }
 522                                                                         /*}}}*/
 523 // ReadMessages - Read messages from the FD                             /*{{{*/
 524 // ---------------------------------------------------------------------
 525 /* This pulls full messages from the input FD into the message buffer.
 526    It assumes that messages will not pause during transit so no
 527    fancy buffering is used. */
 528 bool ReadMessages(int Fd, vector<string> &List)
 529 {
 530    char Buffer[4000];
 531    char *End = Buffer;
 532
 533    while (1)
 534    {
 535       int Res = read(Fd,End,sizeof(Buffer) - (End-Buffer));
 536       if (Res < 0 && errno == EINTR)
 537          continue;
 538
 539       // Process is dead, this is kind of bad..
 540       if (Res == 0)
 541          return false;
 542
 543       // No data
 544       if (Res <= 0)
 545          return true;
 546
 547       End += Res;
 548
 549       // Look for the end of the message
 550       for (char *I = Buffer; I + 1 < End; I++)
 551       {
 552          if (I[0] != '\n' || I[1] != '\n')
 553             continue;
 554
 555          // Pull the message out
 556          string Message(Buffer,0,I-Buffer);
 557
 558          // Fix up the buffer
 559          for (; I < End && *I == '\n'; I++);
 560          End -= I-Buffer;
 561          memmove(Buffer,I,End-Buffer);
 562          I = Buffer;
 563
 564          List.push_back(Message);
 565       }
 566       if (End == Buffer)
 567          return true;
 568
 569       if (WaitFd(Fd) == false)
 570          return false;
 571    }
 572 }
 573                                                                         /*}}}*/
 574 // MonthConv - Converts a month string into a number                    /*{{{*/
 575 // ---------------------------------------------------------------------
 576 /* This was lifted from the boa webserver which lifted it from 'wn-v1.07'
 577    Made it a bit more robust with a few touppers though. */
 578 static int MonthConv(char *Month)
 579 {
 580    switch (toupper(*Month))
 581    {
 582       case 'A':
 583       return toupper(Month[1]) == 'P'?3:7;
 584       case 'D':
 585       return 11;
 586       case 'F':
 587       return 1;
 588       case 'J':
 589       if (toupper(Month[1]) == 'A')
 590          return 0;
 591       return toupper(Month[2]) == 'N'?5:6;
 592       case 'M':
 593       return toupper(Month[2]) == 'R'?2:4;
 594       case 'N':
 595       return 10;
 596       case 'O':
 597       return 9;
 598       case 'S':
 599       return 8;
 600
 601       // Pretend it is January..
 602       default:
 603       return 0;
 604    }
 605 }
 606                                                                         /*}}}*/
 607 // timegm - Internal timegm function if gnu is not available            /*{{{*/
 608 // ---------------------------------------------------------------------
 609 /* Ripped this evil little function from wget - I prefer the use of
 610    GNU timegm if possible as this technique will have interesting problems
 611    with leap seconds, timezones and other.
 612
 613    Converts struct tm to time_t, assuming the data in tm is UTC rather
 614    than local timezone (mktime assumes the latter).
 615
 616    Contributed by Roger Beeman <beeman@cisco.com>, with the help of
 617    Mark Baushke <mdb@cisco.com> and the rest of the Gurus at CISCO. */
 618 #ifndef __USE_MISC        // glib sets this
 619 static time_t timegm(struct tm *t)
 620 {
 621    time_t tl, tb;
 622
 623    tl = mktime (t);
 624    if (tl == -1)
 625       return -1;
 626    tb = mktime (gmtime (&tl));
 627    return (tl <= tb ? (tl + (tl - tb)) : (tl - (tb - tl)));
 628 }
 629 #endif
 630                                                                         /*}}}*/
 631 // StrToTime - Converts a string into a time_t                          /*{{{*/
 632 // ---------------------------------------------------------------------
 633 /* This handles all 3 populare time formats including RFC 1123, RFC 1036
 634    and the C library asctime format. It requires the GNU library function
 635    'timegm' to convert a struct tm in UTC to a time_t. For some bizzar
 636    reason the C library does not provide any such function :< This also
 637    handles the weird, but unambiguous FTP time format*/
 638 bool StrToTime(string Val,time_t &Result)
 639 {
 640    struct tm Tm;
 641    char Month[10];
 642    const char *I = Val.c_str();
 643
 644    // Skip the day of the week
 645    for (;*I != 0  && *I != ' '; I++);
 646
 647    // Handle RFC 1123 time
 648    Month[0] = 0;
 649    if (sscanf(I," %d %3s %d %d:%d:%d GMT",&Tm.tm_mday,Month,&Tm.tm_year,
 650               &Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec) != 6)
 651    {
 652       // Handle RFC 1036 time
 653       if (sscanf(I," %d-%3s-%d %d:%d:%d GMT",&Tm.tm_mday,Month,
 654                  &Tm.tm_year,&Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec) == 6)
 655          Tm.tm_year += 1900;
 656       else
 657       {
 658          // asctime format
 659          if (sscanf(I," %3s %d %d:%d:%d %d",Month,&Tm.tm_mday,
 660                     &Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec,&Tm.tm_year) != 6)
 661          {
 662             // 'ftp' time
 663             if (sscanf(Val.c_str(),"%4d%2d%2d%2d%2d%2d",&Tm.tm_year,&Tm.tm_mon,
 664                        &Tm.tm_mday,&Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec) != 6)
 665                return false;
 666             Tm.tm_mon--;
 667          }
 668       }
 669    }
 670
 671    Tm.tm_isdst = 0;
 672    if (Month[0] != 0)
 673       Tm.tm_mon = MonthConv(Month);
 674    Tm.tm_year -= 1900;
 675
 676    // Convert to local time and then to GMT
 677    Result = timegm(&Tm);
 678    return true;
 679 }
 680                                                                         /*}}}*/
 681 // StrToNum - Convert a fixed length string to a number                 /*{{{*/
 682 // ---------------------------------------------------------------------
 683 /* This is used in decoding the crazy fixed length string headers in
 684    tar and ar files. */
 685 bool StrToNum(const char *Str,unsigned long &Res,unsigned Len,unsigned Base)
 686 {
 687    char S[30];
 688    if (Len >= sizeof(S))
 689       return false;
 690    memcpy(S,Str,Len);
 691    S[Len] = 0;
 692
 693    // All spaces is a zero
 694    Res = 0;
 695    unsigned I;
 696    for (I = 0; S[I] == ' '; I++);
 697    if (S[I] == 0)
 698       return true;
 699
 700    char *End;
 701    Res = strtoul(S,&End,Base);
 702    if (End == S)
 703       return false;
 704
 705    return true;
 706 }
 707                                                                         /*}}}*/
 708 // HexDigit - Convert a hex character into an integer                   /*{{{*/
 709 // ---------------------------------------------------------------------
 710 /* Helper for Hex2Num */
 711 static int HexDigit(int c)
 712 {
 713    if (c >= '0' && c <= '9')
 714       return c - '0';
 715    if (c >= 'a' && c <= 'f')
 716       return c - 'a' + 10;
 717    if (c >= 'A' && c <= 'F')
 718       return c - 'A' + 10;
 719    return 0;
 720 }
 721                                                                         /*}}}*/
 722 // Hex2Num - Convert a long hex number into a buffer                    /*{{{*/
 723 // ---------------------------------------------------------------------
 724 /* The length of the buffer must be exactly 1/2 the length of the string. */
 725 bool Hex2Num(const char *Start,const char *End,unsigned char *Num,
 726              unsigned int Length)
 727 {
 728    if (End - Start != (signed)(Length*2))
 729       return false;
 730
 731    // Convert each digit. We store it in the same order as the string
 732    int J = 0;
 733    for (const char *I = Start; I < End;J++, I += 2)
 734    {
 735       if (isxdigit(*I) == 0 || isxdigit(I[1]) == 0)
 736          return false;
 737
 738       Num[J] = HexDigit(I[0]) << 4;
 739       Num[J] += HexDigit(I[1]);
 740    }
 741
 742    return true;
 743 }
 744                                                                         /*}}}*/
 745
 746 // URI::CopyFrom - Copy from an object                                  /*{{{*/
 747 // ---------------------------------------------------------------------
 748 /* This parses the URI into all of its components */
 749 void URI::CopyFrom(string U)
 750 {
 751    string::const_iterator I = U.begin();
 752
 753    // Locate the first colon, this seperates the scheme
 754    for (; I < U.end() && *I != ':' ; I++);
 755    string::const_iterator FirstColon = I;
 756
 757    /* Determine if this is a host type URI with a leading double //
 758       and then search for the first single / */
 759    string::const_iterator SingleSlash = I;
 760    if (I + 3 < U.end() && I[1] == '/' && I[2] == '/')
 761       SingleSlash += 3;
 762    for (; SingleSlash < U.end() && *SingleSlash != '/'; SingleSlash++);
 763    if (SingleSlash > U.end())
 764       SingleSlash = U.end();
 765
 766    // We can now write the access and path specifiers
 767    Access = string(U,0,FirstColon - U.begin());
 768    if (SingleSlash != U.end())
 769       Path = string(U,SingleSlash - U.begin());
 770    if (Path.empty() == true)
 771       Path = "/";
 772
 773    // Now we attempt to locate a user:pass@host fragment
 774    if (FirstColon[1] == '/' && FirstColon[2] == '/')
 775       FirstColon += 3;
 776    else
 777       FirstColon += 1;
 778    if (FirstColon >= U.end())
 779       return;
 780
 781    if (FirstColon > SingleSlash)
 782       FirstColon = SingleSlash;
 783
 784    // Find the colon...
 785    I = FirstColon + 1;
 786    if (I > SingleSlash)
 787       I = SingleSlash;
 788    for (; I < SingleSlash && *I != ':'; I++);
 789    string::const_iterator SecondColon = I;
 790
 791    // Search for the @ after the colon
 792    for (; I < SingleSlash && *I != '@'; I++);
 793    string::const_iterator At = I;
 794
 795    // Now write the host and user/pass
 796    if (At == SingleSlash)
 797    {
 798       if (FirstColon < SingleSlash)
 799          Host = string(U,FirstColon - U.begin(),SingleSlash - FirstColon);
 800    }
 801    else
 802    {
 803       Host = string(U,At - U.begin() + 1,SingleSlash - At - 1);
 804       User = string(U,FirstColon - U.begin(),SecondColon - FirstColon);
 805       if (SecondColon < At)
 806          Password = string(U,SecondColon - U.begin() + 1,At - SecondColon - 1);
 807    }
 808
 809    // Now we parse off a port number from the hostname
 810    Port = 0;
 811    string::size_type Pos = Host.rfind(':');
 812    if (Pos == string::npos)
 813       return;
 814
 815    Port = atoi(string(Host,Pos+1).c_str());
 816    Host = string(Host,0,Pos);
 817 }
 818                                                                         /*}}}*/
 819 // URI::operator string - Convert the URI to a string                   /*{{{*/
 820 // ---------------------------------------------------------------------
 821 /* */
 822 URI::operator string()
 823 {
 824    string Res;
 825
 826    if (Access.empty() == false)
 827       Res = Access + ':';
 828
 829    if (Host.empty() == false)
 830    {
 831       if (Access.empty() == false)
 832          Res += "//";
 833
 834       if (User.empty() == false)
 835       {
 836          Res +=  User;
 837          if (Password.empty() == false)
 838             Res += ":" + Password;
 839          Res += "@";
 840       }
 841
 842       Res += Host;
 843       if (Port != 0)
 844       {
 845          char S[30];
 846          sprintf(S,":%u",Port);
 847          Res += S;
 848       }
 849    }
 850
 851    if (Path.empty() == false)
 852    {
 853       if (Path[0] != '/')
 854          Res += "/" + Path;
 855       else
 856          Res += Path;
 857    }
 858
 859    return Res;
 860 }
 861                                                                         /*}}}*/