test framework: Correctly generate new paths in noopchroot

[apt.git] / apt-pkg / contrib / strutl.cc

diff --git a/apt-pkg/contrib/strutl.cc b/apt-pkg/contrib/strutl.cc
index ab2da2d9af11a9b21ed9930b5ec76869754efef1..396cb7898c0e5dc26f31bbbbe030aa4c7cb90ca9 100644 (file)
--- a/apt-pkg/contrib/strutl.cc
+++ b/apt-pkg/contrib/strutl.cc
@@ -15,14 +15,20 @@
    ##################################################################### */
                                                                        /*}}}*/
 // Includes                                                            /*{{{*/
    ##################################################################### */
                                                                        /*}}}*/
 // Includes                                                            /*{{{*/

+#include <config.h>
+

 #include <apt-pkg/strutl.h>
 #include <apt-pkg/fileutl.h>
 #include <apt-pkg/error.h>
 
 #include <apt-pkg/strutl.h>
 #include <apt-pkg/fileutl.h>
 #include <apt-pkg/error.h>
 

-#include <apti18n.h>
-    
+#include <stddef.h>
+#include <stdlib.h>
+#include <time.h>
+#include <string>
+#include <vector>

 #include <ctype.h>
 #include <string.h>
 #include <ctype.h>
 #include <string.h>

+#include <sstream>

 #include <stdio.h>
 #include <algorithm>
 #include <unistd.h>
 #include <stdio.h>
 #include <algorithm>
 #include <unistd.h>


@@ -31,11 +37,53 @@
 #include <stdarg.h>
 #include <iconv.h>
 
 #include <stdarg.h>
 #include <iconv.h>
 

-#include "config.h"
-
-using namespace std;
+#include <apti18n.h>

                                                                        /*}}}*/
                                                                        /*}}}*/

+using namespace std;
+
+// Strip - Remove white space from the front and back of a string       /*{{{*/
+// ---------------------------------------------------------------------
+namespace APT {
+   namespace String {
+std::string Strip(const std::string &str)
+{
+   // ensure we have at least one character
+   if (str.empty() == true)
+      return str;
+
+   char const * const s = str.c_str();
+   size_t start = 0;
+   for (; isspace(s[start]) != 0; ++start)
+      ; // find the first not-space
+
+   // string contains only whitespaces
+   if (s[start] == '\0')
+      return "";
+
+   size_t end = str.length() - 1;
+   for (; isspace(s[end]) != 0; --end)
+      ; // find the last not-space
+
+   return str.substr(start, end - start + 1);
+}
+
+bool Endswith(const std::string &s, const std::string &end)
+{
+   if (end.size() > s.size())
+      return false;
+   return (s.substr(s.size() - end.size(), s.size()) == end);
+}
+
+bool Startswith(const std::string &s, const std::string &start)
+{
+   if (start.size() > s.size())
+      return false;
+   return (s.substr(0, start.size()) == start);
+}

 
 

+}
+}
+                                                                       /*}}}*/

 // UTF8ToCodeset - Convert some UTF-8 string for some codeset          /*{{{*/
 // ---------------------------------------------------------------------
 /* This is handy to use before display some information for enduser  */
 // UTF8ToCodeset - Convert some UTF-8 string for some codeset          /*{{{*/
 // ---------------------------------------------------------------------
 /* This is handy to use before display some information for enduser  */


@@ -116,14 +164,20 @@ char *_strstrip(char *String)
 
    if (*String == 0)
       return String;
 
    if (*String == 0)
       return String;

-
+   return _strrstrip(String);
+}
+                                                                       /*}}}*/
+// strrstrip - Remove white space from the back of a string    /*{{{*/
+// ---------------------------------------------------------------------
+char *_strrstrip(char *String)
+{

    char *End = String + strlen(String) - 1;
    for (;End != String - 1 && (*End == ' ' || *End == '\t' || *End == '\n' ||
                               *End == '\r'); End--);
    End++;
    *End = 0;
    return String;
    char *End = String + strlen(String) - 1;
    for (;End != String - 1 && (*End == ' ' || *End == '\t' || *End == '\n' ||
                               *End == '\r'); End--);
    End++;
    *End = 0;
    return String;

-};
+}

                                                                        /*}}}*/
 // strtabexpand - Converts tabs into 8 spaces                          /*{{{*/
 // ---------------------------------------------------------------------
                                                                        /*}}}*/
 // strtabexpand - Converts tabs into 8 spaces                          /*{{{*/
 // ---------------------------------------------------------------------


@@ -179,14 +233,14 @@ bool ParseQuoteWord(const char *&String,string &Res)
    {
       if (*C == '"')
       {
    {
       if (*C == '"')
       {

-        for (C++; *C != 0 && *C != '"'; C++);
-        if (*C == 0)
+        C = strchr(C + 1, '"');
+        if (C == NULL)

            return false;
       }
       if (*C == '[')
       {
            return false;
       }
       if (*C == '[')
       {

-        for (C++; *C != 0 && *C != ']'; C++);
-        if (*C == 0)
+        C = strchr(C + 1, ']');
+        if (C == NULL)

            return false;
       }
    }
            return false;
       }
    }


@@ -270,21 +324,19 @@ bool ParseCWord(const char *&String,string &Res)
 /* */
 string QuoteString(const string &Str, const char *Bad)
 {
 /* */
 string QuoteString(const string &Str, const char *Bad)
 {

-   string Res;
-   for (string::const_iterator I = Str.begin(); I != Str.end(); I++)
+   std::stringstream Res;
+   for (string::const_iterator I = Str.begin(); I != Str.end(); ++I)

    {
    {

-      if (strchr(Bad,*I) != 0 || isprint(*I) == 0 || 
+      if (strchr(Bad,*I) != 0 || isprint(*I) == 0 ||

          *I == 0x25 || // percent '%' char
          *I <= 0x20 || *I >= 0x7F) // control chars
       {
          *I == 0x25 || // percent '%' char
          *I <= 0x20 || *I >= 0x7F) // control chars
       {

-        char Buf[10];
-        sprintf(Buf,"%%%02x",(int)*I);
-        Res += Buf;
+        ioprintf(Res, "%%%02hhx", *I);

       }
       else
       }
       else

-        Res += *I;
+        Res << *I;

    }
    }

-   return Res;
+   return Res.str();

 }
                                                                        /*}}}*/
 // DeQuoteString - Convert a string from quoted from                    /*{{{*/
 }
                                                                        /*}}}*/
 // DeQuoteString - Convert a string from quoted from                    /*{{{*/


@@ -298,7 +350,7 @@ string DeQuoteString(string::const_iterator const &begin,
                        string::const_iterator const &end)
 {
    string Res;
                        string::const_iterator const &end)
 {
    string Res;

-   for (string::const_iterator I = begin; I != end; I++)
+   for (string::const_iterator I = begin; I != end; ++I)

    {
       if (*I == '%' && I + 2 < end &&
          isxdigit(I[1]) && isxdigit(I[2]))
    {
       if (*I == '%' && I + 2 < end &&
          isxdigit(I[1]) && isxdigit(I[2]))


@@ -325,13 +377,12 @@ string DeQuoteString(string::const_iterator const &begin,
    YottaBytes (E24) */
 string SizeToStr(double Size)
 {
    YottaBytes (E24) */
 string SizeToStr(double Size)
 {

-   char S[300];

    double ASize;
    if (Size >= 0)
       ASize = Size;
    else
       ASize = -1*Size;
    double ASize;
    if (Size >= 0)
       ASize = Size;
    else
       ASize = -1*Size;

-   
+

    /* bytes, KiloBytes, MegaBytes, GigaBytes, TeraBytes, PetaBytes, 
       ExaBytes, ZettaBytes, YottaBytes */
    char Ext[] = {'\0','k','M','G','T','P','E','Z','Y'};
    /* bytes, KiloBytes, MegaBytes, GigaBytes, TeraBytes, PetaBytes, 
       ExaBytes, ZettaBytes, YottaBytes */
    char Ext[] = {'\0','k','M','G','T','P','E','Z','Y'};


@@ -340,20 +391,21 @@ string SizeToStr(double Size)
    {
       if (ASize < 100 && I != 0)
       {
    {
       if (ASize < 100 && I != 0)
       {

-         sprintf(S,"%'.1f %c",ASize,Ext[I]);
-        break;
+        std::string S;
+        strprintf(S, "%'.1f %c", ASize, Ext[I]);
+        return S;

       }
       }

-      
+

       if (ASize < 10000)
       {
       if (ASize < 10000)
       {

-         sprintf(S,"%'.0f %c",ASize,Ext[I]);
-        break;
+        std::string S;
+        strprintf(S, "%'.0f %c", ASize, Ext[I]);
+        return S;

       }
       ASize /= 1000.0;
       I++;
    }
       }
       ASize /= 1000.0;
       I++;
    }

-   
-   return S;
+   return "";

 }
                                                                        /*}}}*/
 // TimeToStr - Convert the time into a string                          /*{{{*/
 }
                                                                        /*}}}*/
 // TimeToStr - Convert the time into a string                          /*{{{*/


@@ -361,61 +413,59 @@ string SizeToStr(double Size)
 /* Converts a number of seconds to a hms format */
 string TimeToStr(unsigned long Sec)
 {
 /* Converts a number of seconds to a hms format */
 string TimeToStr(unsigned long Sec)
 {

-   char S[300];
-   
-   while (1)
+   std::string S;
+   if (Sec > 60*60*24)

    {
    {

-      if (Sec > 60*60*24)
-      {
-        //d means days, h means hours, min means minutes, s means seconds
-        sprintf(S,_("%lid %lih %limin %lis"),Sec/60/60/24,(Sec/60/60) % 24,(Sec/60) % 60,Sec % 60);
-        break;
-      }
-      
-      if (Sec > 60*60)
-      {
-        //h means hours, min means minutes, s means seconds
-        sprintf(S,_("%lih %limin %lis"),Sec/60/60,(Sec/60) % 60,Sec % 60);
-        break;
-      }
-      
-      if (Sec > 60)
-      {
-        //min means minutes, s means seconds
-        sprintf(S,_("%limin %lis"),Sec/60,Sec % 60);
-        break;
-      }
-
-      //s means seconds
-      sprintf(S,_("%lis"),Sec);
-      break;
+      //TRANSLATOR: d means days, h means hours, min means minutes, s means seconds
+      strprintf(S,_("%lid %lih %limin %lis"),Sec/60/60/24,(Sec/60/60) % 24,(Sec/60) % 60,Sec % 60);
+   }
+   else if (Sec > 60*60)
+   {
+      //TRANSLATOR: h means hours, min means minutes, s means seconds
+      strprintf(S,_("%lih %limin %lis"),Sec/60/60,(Sec/60) % 60,Sec % 60);
+   }
+   else if (Sec > 60)
+   {
+      //TRANSLATOR: min means minutes, s means seconds
+      strprintf(S,_("%limin %lis"),Sec/60,Sec % 60);
+   }
+   else
+   {
+      //TRANSLATOR: s means seconds
+      strprintf(S,_("%lis"),Sec);

    }
    }

-   

    return S;
 }
                                                                        /*}}}*/
 // SubstVar - Substitute a string for another string                   /*{{{*/
 // ---------------------------------------------------------------------
    return S;
 }
                                                                        /*}}}*/
 // SubstVar - Substitute a string for another string                   /*{{{*/
 // ---------------------------------------------------------------------

-/* This replaces all occurances of Subst with Contents in Str. */
+/* This replaces all occurrences of Subst with Contents in Str. */

 string SubstVar(const string &Str,const string &Subst,const string &Contents)
 {
 string SubstVar(const string &Str,const string &Subst,const string &Contents)
 {

+   if (Subst.empty() == true)
+      return Str;
+

    string::size_type Pos = 0;
    string::size_type OldPos = 0;
    string Temp;
    string::size_type Pos = 0;
    string::size_type OldPos = 0;
    string Temp;

-   
-   while (OldPos < Str.length() && 
+
+   while (OldPos < Str.length() &&

          (Pos = Str.find(Subst,OldPos)) != string::npos)
    {
          (Pos = Str.find(Subst,OldPos)) != string::npos)
    {

-      Temp += string(Str,OldPos,Pos) + Contents;
-      OldPos = Pos + Subst.length();      
+      if (OldPos != Pos)
+        Temp.append(Str, OldPos, Pos - OldPos);
+      if (Contents.empty() == false)
+        Temp.append(Contents);
+      OldPos = Pos + Subst.length();

    }
    }

-   
+

    if (OldPos == 0)
       return Str;
    if (OldPos == 0)
       return Str;

-   
+
+   if (OldPos >= Str.length())
+      return Temp;

    return Temp + string(Str,OldPos);
 }
    return Temp + string(Str,OldPos);
 }

-

 string SubstVar(string Str,const struct SubstVar *Vars)
 {
    for (; Vars->Subst != 0; Vars++)
 string SubstVar(string Str,const struct SubstVar *Vars)
 {
    for (; Vars->Subst != 0; Vars++)


@@ -632,7 +682,7 @@ string LookupTag(const string &Message,const char *Tag,const char *Default)
 {
    // Look for a matching tag.
    int Length = strlen(Tag);
 {
    // Look for a matching tag.
    int Length = strlen(Tag);

-   for (string::const_iterator I = Message.begin(); I + Length < Message.end(); I++)
+   for (string::const_iterator I = Message.begin(); I + Length < Message.end(); ++I)

    {
       // Found the tag
       if (I[Length] == ':' && stringcasecmp(I,I+Length,Tag) == 0)
    {
       // Found the tag
       if (I[Length] == ':' && stringcasecmp(I,I+Length,Tag) == 0)


@@ -640,14 +690,14 @@ string LookupTag(const string &Message,const char *Tag,const char *Default)
         // Find the end of line and strip the leading/trailing spaces
         string::const_iterator J;
         I += Length + 1;
         // Find the end of line and strip the leading/trailing spaces
         string::const_iterator J;
         I += Length + 1;

-        for (; isspace(*I) != 0 && I < Message.end(); I++);
-        for (J = I; *J != '\n' && J < Message.end(); J++);
-        for (; J > I && isspace(J[-1]) != 0; J--);
+        for (; isspace(*I) != 0 && I < Message.end(); ++I);
+        for (J = I; *J != '\n' && J < Message.end(); ++J);
+        for (; J > I && isspace(J[-1]) != 0; --J);

         
         return string(I,J);
       }
       
         
         return string(I,J);
       }
       

-      for (; *I != '\n' && I < Message.end(); I++);
+      for (; *I != '\n' && I < Message.end(); ++I);

    }   
    
    // Failed to find a match
    }   
    
    // Failed to find a match


@@ -662,9 +712,12 @@ string LookupTag(const string &Message,const char *Tag,const char *Default)
    then returns the result. Several varients on true/false are checked. */
 int StringToBool(const string &Text,int Default)
 {
    then returns the result. Several varients on true/false are checked. */
 int StringToBool(const string &Text,int Default)
 {

-   char *End;
-   int Res = strtol(Text.c_str(),&End,0);   
-   if (End != Text.c_str() && Res >= 0 && Res <= 1)
+   char *ParseEnd;
+   int Res = strtol(Text.c_str(),&ParseEnd,0);
+   // ensure that the entire string was converted by strtol to avoid
+   // failures on "apt-cache show -a 0ad" where the "0" is converted
+   const char *TextEnd = Text.c_str()+Text.size();
+   if (ParseEnd == TextEnd && Res >= 0 && Res <= 1)

       return Res;
    
    // Check for positives
       return Res;
    
    // Check for positives


@@ -715,85 +768,94 @@ string TimeRFC1123(time_t Date)
 
    In particular: this reads blocks from the input until it believes
    that it's run out of input text.  Each block is terminated by a
 
    In particular: this reads blocks from the input until it believes
    that it's run out of input text.  Each block is terminated by a

-   double newline ('\n' followed by '\n').  As noted below, there is a
-   bug in this code: it assumes that all the blocks have been read if
-   it doesn't see additional text in the buffer after the last one is
-   parsed, which will cause it to lose blocks if the last block
-   coincides with the end of the buffer.
+   double newline ('\n' followed by '\n').

  */
 bool ReadMessages(int Fd, vector<string> &List)
 {
    char Buffer[64000];
  */
 bool ReadMessages(int Fd, vector<string> &List)
 {
    char Buffer[64000];

-   char *End = Buffer;

    // Represents any left-over from the previous iteration of the
    // parse loop.  (i.e., if a message is split across the end
    // of the buffer, it goes here)
    string PartialMessage;
    // Represents any left-over from the previous iteration of the
    // parse loop.  (i.e., if a message is split across the end
    // of the buffer, it goes here)
    string PartialMessage;

-   
-   while (1)
-   {
-      int Res = read(Fd,End,sizeof(Buffer) - (End-Buffer));
+
+   do {
+      int const Res = read(Fd, Buffer, sizeof(Buffer));

       if (Res < 0 && errno == EINTR)
         continue;
       if (Res < 0 && errno == EINTR)
         continue;

-      
-      // Process is dead, this is kind of bad..
+
+      // process we read from has died

       if (Res == 0)
         return false;
       if (Res == 0)
         return false;

-      
+

       // No data
       // No data

-      if (Res < 0 && errno == EAGAIN)
+      if (Res < 0 && (errno == EAGAIN || errno == EWOULDBLOCK))

         return true;
       if (Res < 0)
         return false;
         return true;
       if (Res < 0)
         return false;

-                             
-      End += Res;
-      
-      // Look for the end of the message
-      for (char *I = Buffer; I + 1 < End; I++)
+
+      // extract the message(s) from the buffer
+      char const *Start = Buffer;
+      char const * const End = Buffer + Res;
+
+      char const * NL = (char const *) memchr(Start, '\n', End - Start);
+      if (NL == NULL)

       {
       {

-        if (I[0] != '\n' || I[1] != '\n')
-           continue;
-        
-        // Pull the message out
-        string Message(Buffer,I-Buffer);
-        PartialMessage += Message;
-
-        // Fix up the buffer
-        for (; I < End && *I == '\n'; I++);
-        End -= I-Buffer;        
-        memmove(Buffer,I,End-Buffer);
-        I = Buffer;
-        
-        List.push_back(PartialMessage);
-        PartialMessage.clear();
+        // end of buffer: store what we have so far and read new data in
+        PartialMessage.append(Start, End - Start);
+        Start = End;

       }
       }

-      if (End != Buffer)
-       {
-         // If there's text left in the buffer, store it
-         // in PartialMessage and throw the rest of the buffer
-         // away.  This allows us to handle messages that
-         // are longer than the static buffer size.
-         PartialMessage += string(Buffer, End);
-         End = Buffer;
-       }

       else
       else

-       {
-         // BUG ALERT: if a message block happens to end at a
-         // multiple of 64000 characters, this will cause it to
-         // terminate early, leading to a badly formed block and
-         // probably crashing the method.  However, this is the only
-         // way we have to find the end of the message block.  I have
-         // an idea of how to fix this, but it will require changes
-         // to the protocol (essentially to mark the beginning and
-         // end of the block).
-         //
-         //  -- dburrows 2008-04-02
-         return true;
-       }
+        ++NL;
+
+      if (PartialMessage.empty() == false && Start < End)
+      {
+        // if we start with a new line, see if the partial message we have ended with one
+        // so that we properly detect records ending between two read() runs
+        // cases are: \n|\n  ,  \r\n|\r\n  and  \r\n\r|\n
+        // the case \r|\n\r\n is handled by the usual double-newline handling
+        if ((NL - Start) == 1 || ((NL - Start) == 2 && *Start == '\r'))
+        {
+           if (APT::String::Endswith(PartialMessage, "\n") || APT::String::Endswith(PartialMessage, "\r\n\r"))
+           {
+              PartialMessage.erase(PartialMessage.find_last_not_of("\r\n") + 1);
+              List.push_back(PartialMessage);
+              PartialMessage.clear();
+              while (NL < End && (*NL == '\n' || *NL == '\r')) ++NL;
+              Start = NL;
+           }
+        }
+      }
+
+      while (Start < End) {
+        char const * NL2 = (char const *) memchr(NL, '\n', End - NL);
+        if (NL2 == NULL)
+        {
+           // end of buffer: store what we have so far and read new data in
+           PartialMessage.append(Start, End - Start);
+           break;
+        }
+        ++NL2;
+
+        // did we find a double newline?
+        if ((NL2 - NL) == 1 || ((NL2 - NL) == 2 && *NL == '\r'))
+        {
+           PartialMessage.append(Start, NL2 - Start);
+           PartialMessage.erase(PartialMessage.find_last_not_of("\r\n") + 1);
+           List.push_back(PartialMessage);
+           PartialMessage.clear();
+           while (NL2 < End && (*NL2 == '\n' || *NL2 == '\r')) ++NL2;
+           Start = NL2;
+        }
+        NL = NL2;
+      }
+
+      // we have read at least one complete message and nothing left
+      if (PartialMessage.empty() == true)
+        return true;

 
       if (WaitFd(Fd) == false)
         return false;
 
       if (WaitFd(Fd) == false)
         return false;

-   }   
+   } while (true);

 }
                                                                        /*}}}*/
 // MonthConv - Converts a month string into a number                   /*{{{*/
 }
                                                                        /*}}}*/
 // MonthConv - Converts a month string into a number                   /*{{{*/


@@ -895,7 +957,7 @@ bool FTPMDTMStrToTime(const char* const str,time_t &time)
                                                                        /*}}}*/
 // StrToTime - Converts a string into a time_t                         /*{{{*/
 // ---------------------------------------------------------------------
                                                                        /*}}}*/
 // StrToTime - Converts a string into a time_t                         /*{{{*/
 // ---------------------------------------------------------------------

-/* This handles all 3 populare time formats including RFC 1123, RFC 1036
+/* This handles all 3 popular time formats including RFC 1123, RFC 1036

    and the C library asctime format. It requires the GNU library function
    'timegm' to convert a struct tm in UTC to a time_t. For some bizzar
    reason the C library does not provide any such function :< This also
    and the C library asctime format. It requires the GNU library function
    'timegm' to convert a struct tm in UTC to a time_t. For some bizzar
    reason the C library does not provide any such function :< This also


@@ -904,24 +966,23 @@ bool StrToTime(const string &Val,time_t &Result)
 {
    struct tm Tm;
    char Month[10];
 {
    struct tm Tm;
    char Month[10];

-   const char *I = Val.c_str();
-   
+

    // Skip the day of the week
    // Skip the day of the week

-   for (;*I != 0  && *I != ' '; I++);
-   
+   const char *I = strchr(Val.c_str(), ' ');
+

    // Handle RFC 1123 time
    Month[0] = 0;
    // Handle RFC 1123 time
    Month[0] = 0;

-   if (sscanf(I," %d %3s %d %d:%d:%d GMT",&Tm.tm_mday,Month,&Tm.tm_year,
+   if (sscanf(I," %2d %3s %4d %2d:%2d:%2d GMT",&Tm.tm_mday,Month,&Tm.tm_year,

              &Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec) != 6)
    {
       // Handle RFC 1036 time
              &Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec) != 6)
    {
       // Handle RFC 1036 time

-      if (sscanf(I," %d-%3s-%d %d:%d:%d GMT",&Tm.tm_mday,Month,
+      if (sscanf(I," %2d-%3s-%3d %2d:%2d:%2d GMT",&Tm.tm_mday,Month,

                 &Tm.tm_year,&Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec) == 6)
         Tm.tm_year += 1900;
       else
       {
         // asctime format
                 &Tm.tm_year,&Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec) == 6)
         Tm.tm_year += 1900;
       else
       {
         // asctime format

-        if (sscanf(I," %3s %d %d:%d:%d %d",Month,&Tm.tm_mday,
+        if (sscanf(I," %3s %2d %2d:%2d:%2d %4d",Month,&Tm.tm_mday,

                    &Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec,&Tm.tm_year) != 6)
         {
            // 'ftp' time
                    &Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec,&Tm.tm_year) != 6)
         {
            // 'ftp' time


@@ -936,6 +997,8 @@ bool StrToTime(const string &Val,time_t &Result)
    Tm.tm_isdst = 0;
    if (Month[0] != 0)
       Tm.tm_mon = MonthConv(Month);
    Tm.tm_isdst = 0;
    if (Month[0] != 0)
       Tm.tm_mon = MonthConv(Month);

+   else
+      Tm.tm_mon = 0; // we don't have a month, so pick something

    Tm.tm_year -= 1900;
    
    // Convert to local time and then to GMT
    Tm.tm_year -= 1900;
    
    // Convert to local time and then to GMT


@@ -970,11 +1033,39 @@ bool StrToNum(const char *Str,unsigned long &Res,unsigned Len,unsigned Base)
    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/

+// StrToNum - Convert a fixed length string to a number                        /*{{{*/
+// ---------------------------------------------------------------------
+/* This is used in decoding the crazy fixed length string headers in 
+   tar and ar files. */
+bool StrToNum(const char *Str,unsigned long long &Res,unsigned Len,unsigned Base)
+{
+   char S[30];
+   if (Len >= sizeof(S))
+      return false;
+   memcpy(S,Str,Len);
+   S[Len] = 0;
+   
+   // All spaces is a zero
+   Res = 0;
+   unsigned I;
+   for (I = 0; S[I] == ' '; I++);
+   if (S[I] == 0)
+      return true;
+   
+   char *End;
+   Res = strtoull(S,&End,Base);
+   if (End == S)
+      return false;
+   
+   return true;
+}
+                                                                       /*}}}*/
+

 // Base256ToNum - Convert a fixed length binary to a number             /*{{{*/
 // ---------------------------------------------------------------------
 /* This is used in decoding the 256bit encoded fixed length fields in
    tar files */
 // Base256ToNum - Convert a fixed length binary to a number             /*{{{*/
 // ---------------------------------------------------------------------
 /* This is used in decoding the 256bit encoded fixed length fields in
    tar files */

-bool Base256ToNum(const char *Str,unsigned long &Res,unsigned int Len)
+bool Base256ToNum(const char *Str,unsigned long long &Res,unsigned int Len)

 {
    if ((Str[0] & 0x80) == 0)
       return false;
 {
    if ((Str[0] & 0x80) == 0)
       return false;


@@ -987,6 +1078,23 @@ bool Base256ToNum(const char *Str,unsigned long &Res,unsigned int Len)
    }
 }
                                                                        /*}}}*/
    }
 }
                                                                        /*}}}*/

+// Base256ToNum - Convert a fixed length binary to a number             /*{{{*/
+// ---------------------------------------------------------------------
+/* This is used in decoding the 256bit encoded fixed length fields in
+   tar files */
+bool Base256ToNum(const char *Str,unsigned long &Res,unsigned int Len)
+{
+   unsigned long long Num;
+   bool rc;
+
+   rc = Base256ToNum(Str, Num, Len);
+   Res = Num;
+   if (Res != Num)
+      return false;
+
+   return rc;
+}
+                                                                       /*}}}*/

 // HexDigit - Convert a hex character into an integer                  /*{{{*/
 // ---------------------------------------------------------------------
 /* Helper for Hex2Num */
 // HexDigit - Convert a hex character into an integer                  /*{{{*/
 // ---------------------------------------------------------------------
 /* Helper for Hex2Num */


@@ -1070,9 +1178,11 @@ bool TokSplitString(char Tok,char *Input,char **List,
    also, but the advantage is that we have an iteratable vector */
 vector<string> VectorizeString(string const &haystack, char const &split)
 {
    also, but the advantage is that we have an iteratable vector */
 vector<string> VectorizeString(string const &haystack, char const &split)
 {

+   vector<string> exploded;
+   if (haystack.empty() == true)
+      return exploded;

    string::const_iterator start = haystack.begin();
    string::const_iterator end = start;
    string::const_iterator start = haystack.begin();
    string::const_iterator end = start;

-   vector<string> exploded;

    do {
       for (; end != haystack.end() && *end != split; ++end);
       exploded.push_back(string(start, end));
    do {
       for (; end != haystack.end() && *end != split; ++end);
       exploded.push_back(string(start, end));


@@ -1081,6 +1191,37 @@ vector<string> VectorizeString(string const &haystack, char const &split)
    return exploded;
 }
                                                                        /*}}}*/
    return exploded;
 }
                                                                        /*}}}*/

+// StringSplit - split a string into a string vector by token          /*{{{*/
+// ---------------------------------------------------------------------
+/* See header for details.
+ */
+vector<string> StringSplit(std::string const &s, std::string const &sep,
+                           unsigned int maxsplit)
+{
+   vector<string> split;
+   size_t start, pos;
+
+   // no seperator given, this is bogus
+   if(sep.size() == 0)
+      return split;
+
+   start = pos = 0;
+   while (pos != string::npos)
+   {
+      pos = s.find(sep, start);
+      split.push_back(s.substr(start, pos-start));
+      
+      // if maxsplit is reached, the remaining string is the last item
+      if(split.size() >= maxsplit)
+      {
+         split[split.size()-1] = s.substr(start);
+         break;
+      }
+      start = pos+sep.size();
+   }
+   return split;
+}
+                                                                       /*}}}*/

 // RegexChoice - Simple regex list/list matcher                                /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // RegexChoice - Simple regex list/list matcher                                /*{{{*/
 // ---------------------------------------------------------------------
 /* */


@@ -1091,7 +1232,7 @@ unsigned long RegexChoice(RxChoiceList *Rxs,const char **ListBegin,
       R->Hit = false;
 
    unsigned long Hits = 0;
       R->Hit = false;
 
    unsigned long Hits = 0;

-   for (; ListBegin != ListEnd; ListBegin++)
+   for (; ListBegin < ListEnd; ++ListBegin)

    {
       // Check if the name is a regex
       const char *I;
    {
       // Check if the name is a regex
       const char *I;


@@ -1141,34 +1282,54 @@ unsigned long RegexChoice(RxChoiceList *Rxs,const char **ListBegin,
    return Hits;
 }
                                                                        /*}}}*/
    return Hits;
 }
                                                                        /*}}}*/

-// ioprintf - C format string outputter to C++ iostreams               /*{{{*/
+// {str,io}printf - C format string outputter to C++ strings/iostreams /*{{{*/

 // ---------------------------------------------------------------------
 /* This is used to make the internationalization strings easier to translate
    and to allow reordering of parameters */
 // ---------------------------------------------------------------------
 /* This is used to make the internationalization strings easier to translate
    and to allow reordering of parameters */

-void ioprintf(ostream &out,const char *format,...) 
+static bool iovprintf(ostream &out, const char *format,
+                     va_list &args, ssize_t &size) {
+   char *S = (char*)malloc(size);
+   ssize_t const n = vsnprintf(S, size, format, args);
+   if (n > -1 && n < size) {
+      out << S;
+      free(S);
+      return true;
+   } else {
+      if (n > -1)
+        size = n + 1;
+      else
+        size *= 2;
+   }
+   free(S);
+   return false;
+}
+void ioprintf(ostream &out,const char *format,...)

 {
    va_list args;
 {
    va_list args;

-   va_start(args,format);
-   
-   // sprintf the description
-   char S[4096];
-   vsnprintf(S,sizeof(S),format,args);
-   out << S;
+   ssize_t size = 400;
+   while (true) {
+      bool ret;
+      va_start(args,format);
+      ret = iovprintf(out, format, args, size);
+      va_end(args);
+      if (ret == true)
+        return;
+   }

 }
 }

-                                                                       /*}}}*/
-// strprintf - C format string outputter to C++ strings                /*{{{*/
-// ---------------------------------------------------------------------
-/* This is used to make the internationalization strings easier to translate
-   and to allow reordering of parameters */
-void strprintf(string &out,const char *format,...) 
+void strprintf(string &out,const char *format,...)

 {
    va_list args;
 {
    va_list args;

-   va_start(args,format);
-   
-   // sprintf the description
-   char S[4096];
-   vsnprintf(S,sizeof(S),format,args);
-   out = string(S);
+   ssize_t size = 400;
+   std::ostringstream outstr;
+   while (true) {
+      bool ret;
+      va_start(args,format);
+      ret = iovprintf(outstr, format, args, size);
+      va_end(args);
+      if (ret == true)
+        break;
+   }
+   out = outstr.str();

 }
                                                                        /*}}}*/
 // safe_snprintf - Safer snprintf                                      /*{{{*/
 }
                                                                        /*}}}*/
 // safe_snprintf - Safer snprintf                                      /*{{{*/


@@ -1182,12 +1343,12 @@ char *safe_snprintf(char *Buffer,char *End,const char *Format,...)
    va_list args;
    int Did;
 
    va_list args;
    int Did;
 

-   va_start(args,Format);
-

    if (End <= Buffer)
       return End;
    if (End <= Buffer)
       return End;

-
+   va_start(args,Format);

    Did = vsnprintf(Buffer,End - Buffer,Format,args);
    Did = vsnprintf(Buffer,End - Buffer,Format,args);

+   va_end(args);
+

    if (Did < 0 || Buffer + Did > End)
       return End;
    return Buffer + Did;
    if (Did < 0 || Buffer + Did > End)
       return End;
    return Buffer + Did;


@@ -1202,11 +1363,11 @@ string StripEpoch(const string &VerStr)
       return VerStr;
    return VerStr.substr(i+1);
 }
       return VerStr;
    return VerStr.substr(i+1);
 }

-
+                                                                       /*}}}*/

 // tolower_ascii - tolower() function that ignores the locale          /*{{{*/
 // ---------------------------------------------------------------------
 /* This little function is the most called method we have and tries
 // tolower_ascii - tolower() function that ignores the locale          /*{{{*/
 // ---------------------------------------------------------------------
 /* This little function is the most called method we have and tries

-   therefore to do the absolut minimum - and is noteable faster than
+   therefore to do the absolut minimum - and is notable faster than

    standard tolower/toupper and as a bonus avoids problems with different
    locales - we only operate on ascii chars anyway. */
 int tolower_ascii(int const c)
    standard tolower/toupper and as a bonus avoids problems with different
    locales - we only operate on ascii chars anyway. */
 int tolower_ascii(int const c)


@@ -1217,14 +1378,14 @@ int tolower_ascii(int const c)
 }
                                                                        /*}}}*/
 
 }
                                                                        /*}}}*/
 

-// CheckDomainList - See if Host is in a , seperate list               /*{{{*/
+// CheckDomainList - See if Host is in a , separate list               /*{{{*/

 // ---------------------------------------------------------------------
 // ---------------------------------------------------------------------

-/* The domain list is a comma seperate list of domains that are suffix
+/* The domain list is a comma separate list of domains that are suffix

    matched against the argument */
 bool CheckDomainList(const string &Host,const string &List)
 {
    string::const_iterator Start = List.begin();
    matched against the argument */
 bool CheckDomainList(const string &Host,const string &List)
 {
    string::const_iterator Start = List.begin();

-   for (string::const_iterator Cur = List.begin(); Cur <= List.end(); Cur++)
+   for (string::const_iterator Cur = List.begin(); Cur <= List.end(); ++Cur)

    {
       if (Cur < List.end() && *Cur != ',')
         continue;
    {
       if (Cur < List.end() && *Cur != ',')
         continue;


@@ -1240,15 +1401,27 @@ bool CheckDomainList(const string &Host,const string &List)
    return false;
 }
                                                                        /*}}}*/
    return false;
 }
                                                                        /*}}}*/

-// DeEscapeString - unescape (\0XX and \xXX) from a string             /*{{{*/
+// strv_length - Return the length of a NULL-terminated string array   /*{{{*/
+// ---------------------------------------------------------------------
+/* */
+size_t strv_length(const char **str_array)
+{
+   size_t i;
+   for (i=0; str_array[i] != NULL; i++)
+      /* nothing */
+      ;
+   return i;
+}
+                                                                       /*}}}*/
+// DeEscapeString - unescape (\0XX and \xXX) from a string             /*{{{*/

 // ---------------------------------------------------------------------
 /* */
 string DeEscapeString(const string &input)
 {
    char tmp[3];
 // ---------------------------------------------------------------------
 /* */
 string DeEscapeString(const string &input)
 {
    char tmp[3];

-   string::const_iterator it, escape_start;
-   string output, octal, hex;
-   for (it = input.begin(); it != input.end(); it++) 
+   string::const_iterator it;
+   string output;
+   for (it = input.begin(); it != input.end(); ++it)

    {
       // just copy non-escape chars
       if (*it != '\\')
    {
       // just copy non-escape chars
       if (*it != '\\')


@@ -1264,7 +1437,7 @@ string DeEscapeString(const string &input)
          // copy
          output += *it;
          // advance iterator one step further
          // copy
          output += *it;
          // advance iterator one step further

-         it += 1;
+         ++it;

          continue;
       }
         
          continue;
       }
         


@@ -1273,7 +1446,7 @@ string DeEscapeString(const string &input)
          continue;
 
       // read it
          continue;
 
       // read it

-      it++;
+      ++it;

       switch (*it)
       {
          case '0':
       switch (*it)
       {
          case '0':


@@ -1310,7 +1483,7 @@ void URI::CopyFrom(const string &U)
    string::const_iterator I = U.begin();
 
    // Locate the first colon, this separates the scheme
    string::const_iterator I = U.begin();
 
    // Locate the first colon, this separates the scheme

-   for (; I < U.end() && *I != ':' ; I++);
+   for (; I < U.end() && *I != ':' ; ++I);

    string::const_iterator FirstColon = I;
 
    /* Determine if this is a host type URI with a leading double //
    string::const_iterator FirstColon = I;
 
    /* Determine if this is a host type URI with a leading double //


@@ -1322,7 +1495,7 @@ void URI::CopyFrom(const string &U)
    /* Find the / indicating the end of the hostname, ignoring /'s in the
       square brackets */
    bool InBracket = false;
    /* Find the / indicating the end of the hostname, ignoring /'s in the
       square brackets */
    bool InBracket = false;

-   for (; SingleSlash < U.end() && (*SingleSlash != '/' || InBracket == true); SingleSlash++)
+   for (; SingleSlash < U.end() && (*SingleSlash != '/' || InBracket == true); ++SingleSlash)

    {
       if (*SingleSlash == '[')
         InBracket = true;
    {
       if (*SingleSlash == '[')
         InBracket = true;


@@ -1355,11 +1528,11 @@ void URI::CopyFrom(const string &U)
    I = FirstColon + 1;
    if (I > SingleSlash)
       I = SingleSlash;
    I = FirstColon + 1;
    if (I > SingleSlash)
       I = SingleSlash;

-   for (; I < SingleSlash && *I != ':'; I++);
+   for (; I < SingleSlash && *I != ':'; ++I);

    string::const_iterator SecondColon = I;
    
    // Search for the @ after the colon
    string::const_iterator SecondColon = I;
    
    // Search for the @ after the colon

-   for (; I < SingleSlash && *I != '@'; I++);
+   for (; I < SingleSlash && *I != '@'; ++I);

    string::const_iterator At = I;
    
    // Now write the host and user/pass
    string::const_iterator At = I;
    
    // Now write the host and user/pass


@@ -1421,72 +1594,75 @@ void URI::CopyFrom(const string &U)
 /* */
 URI::operator string()
 {
 /* */
 URI::operator string()
 {

-   string Res;
-   
+   std::stringstream Res;
+

    if (Access.empty() == false)
    if (Access.empty() == false)

-      Res = Access + ':';
-   
+      Res << Access << ':';
+

    if (Host.empty() == false)
    if (Host.empty() == false)

-   {    
+   {

       if (Access.empty() == false)
       if (Access.empty() == false)

-        Res += "//";
-          
+        Res << "//";
+

       if (User.empty() == false)
       {
       if (User.empty() == false)
       {

-        Res +=  User;
+        // FIXME: Technically userinfo is permitted even less
+        // characters than these, but this is not conveniently
+        // expressed with a blacklist.
+        Res << QuoteString(User, ":/?#[]@");

         if (Password.empty() == false)
         if (Password.empty() == false)

-           Res += ":" + Password;
-        Res += "@";
+           Res << ":" << QuoteString(Password, ":/?#[]@");
+        Res << "@";

       }
       }

-      
+

       // Add RFC 2732 escaping characters
       // Add RFC 2732 escaping characters

-      if (Access.empty() == false &&
-         (Host.find('/') != string::npos || Host.find(':') != string::npos))
-        Res += '[' + Host + ']';
+      if (Access.empty() == false && Host.find_first_of("/:") != string::npos)
+        Res << '[' << Host << ']';

       else
       else

-        Res += Host;
-      
+        Res << Host;
+

       if (Port != 0)
       if (Port != 0)

-      {
-        char S[30];
-        sprintf(S,":%u",Port);
-        Res += S;
-      }         
+        Res << ':' << Port;

    }
    }

-   
+

    if (Path.empty() == false)
    {
       if (Path[0] != '/')
    if (Path.empty() == false)
    {
       if (Path[0] != '/')

-        Res += "/" + Path;
+        Res << "/" << Path;

       else
       else

-        Res += Path;
+        Res << Path;

    }
    }

-   
-   return Res;
+
+   return Res.str();

 }
                                                                        /*}}}*/
 // URI::SiteOnly - Return the schema and site for the URI              /*{{{*/
 }
                                                                        /*}}}*/
 // URI::SiteOnly - Return the schema and site for the URI              /*{{{*/

-// ---------------------------------------------------------------------
-/* */

 string URI::SiteOnly(const string &URI)
 {
    ::URI U(URI);
    U.User.clear();
    U.Password.clear();
    U.Path.clear();
 string URI::SiteOnly(const string &URI)
 {
    ::URI U(URI);
    U.User.clear();
    U.Password.clear();
    U.Path.clear();

-   U.Port = 0;
+   return U;
+}
+                                                                       /*}}}*/
+// URI::ArchiveOnly - Return the schema, site and cleaned path for the URI /*{{{*/
+string URI::ArchiveOnly(const string &URI)
+{
+   ::URI U(URI);
+   U.User.clear();
+   U.Password.clear();
+   if (U.Path.empty() == false && U.Path[U.Path.length() - 1] == '/')
+      U.Path.erase(U.Path.length() - 1);

    return U;
 }
                                                                        /*}}}*/
 // URI::NoUserPassword - Return the schema, site and path for the URI  /*{{{*/
    return U;
 }
                                                                        /*}}}*/
 // URI::NoUserPassword - Return the schema, site and path for the URI  /*{{{*/

-// ---------------------------------------------------------------------
-/* */

 string URI::NoUserPassword(const string &URI)
 {
    ::URI U(URI);
    U.User.clear();
    U.Password.clear();
 string URI::NoUserPassword(const string &URI)
 {
    ::URI U(URI);
    U.User.clear();
    U.Password.clear();

-   U.Port = 0;

    return U;
 }
                                                                        /*}}}*/
    return U;
 }
                                                                        /*}}}*/