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