apt-pkg/contrib/strutl.cc

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