strutl.cc: Add declarations for the compat _ascii() functions

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

diff --git a/apt-pkg/contrib/strutl.cc b/apt-pkg/contrib/strutl.cc
index 87f57a30ece365b886fe807a304275296c2d31e3..b9bfc2c98541963fbd6aa36d6a0c5862074d9ba2 100644 (file)
--- a/apt-pkg/contrib/strutl.cc
+++ b/apt-pkg/contrib/strutl.cc
@@ -74,6 +74,13 @@ bool Endswith(const std::string &s, const std::string &end)
    return (s.substr(s.size() - end.size(), s.size()) == end);
 }
 
    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);
+}
+

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


@@ -317,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;
+   std::stringstream Res;

    for (string::const_iterator I = Str.begin(); I != Str.end(); ++I)
    {
    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                    /*{{{*/


@@ -372,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'};


@@ -387,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                          /*{{{*/


@@ -408,36 +413,27 @@ 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;
 }
                                                                        /*}}}*/
    return S;
 }
                                                                        /*}}}*/


@@ -694,9 +690,9 @@ 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 (; isspace_ascii(*I) != 0 && I < Message.end(); ++I);

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

-        for (; J > I && isspace(J[-1]) != 0; --J);
+        for (; J > I && isspace_ascii(J[-1]) != 0; --J);

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


@@ -772,86 +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[1] != '\n' ||
-              (I[0] != '\n' && strncmp(I, "\r\n\r\n", 4) != 0))
-           continue;
-        
-        // Pull the message out
-        string Message(Buffer,I-Buffer);
-        PartialMessage += Message;
-
-        // Fix up the buffer
-        for (; I < End && (*I == '\n' || *I == '\r'); ++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                   /*{{{*/


@@ -1061,7 +1065,7 @@ bool StrToNum(const char *Str,unsigned long long &Res,unsigned Len,unsigned Base
 // ---------------------------------------------------------------------
 /* This is used in decoding the 256bit encoded fixed length fields in
    tar files */
 // ---------------------------------------------------------------------
 /* 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;


@@ -1074,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 */


@@ -1085,7 +1106,7 @@ static int HexDigit(int c)
       return c - 'a' + 10;
    if (c >= 'A' && c <= 'F')
       return c - 'A' + 10;
       return c - 'a' + 10;
    if (c >= 'A' && c <= 'F')
       return c - 'A' + 10;

-   return 0;
+   return -1;

 }
                                                                        /*}}}*/
 // Hex2Num - Convert a long hex number into a buffer                   /*{{{*/
 }
                                                                        /*}}}*/
 // Hex2Num - Convert a long hex number into a buffer                   /*{{{*/


@@ -1100,11 +1121,16 @@ bool Hex2Num(const string &Str,unsigned char *Num,unsigned int Length)
    int J = 0;
    for (string::const_iterator I = Str.begin(); I != Str.end();J++, I += 2)
    {
    int J = 0;
    for (string::const_iterator I = Str.begin(); I != Str.end();J++, I += 2)
    {

-      if (isxdigit(*I) == 0 || isxdigit(I[1]) == 0)
+      int first_half = HexDigit(I[0]);
+      int second_half;
+      if (first_half < 0)

         return false;
       
         return false;
       

-      Num[J] = HexDigit(I[0]) << 4;
-      Num[J] += HexDigit(I[1]);
+      second_half = HexDigit(I[1]);
+      if (second_half < 0)
+        return false;
+      Num[J] = first_half << 4;
+      Num[J] += second_half;

    }
    
    return true;
    }
    
    return true;


@@ -1287,10 +1313,12 @@ void ioprintf(ostream &out,const char *format,...)
    va_list args;
    ssize_t size = 400;
    while (true) {
    va_list args;
    ssize_t size = 400;
    while (true) {

+      bool ret;

       va_start(args,format);
       va_start(args,format);

-      if (iovprintf(out, format, args, size) == true)
-        return;
+      ret = iovprintf(out, format, args, size);

       va_end(args);
       va_end(args);

+      if (ret == true)
+        return;

    }
 }
 void strprintf(string &out,const char *format,...)
    }
 }
 void strprintf(string &out,const char *format,...)


@@ -1299,10 +1327,12 @@ void strprintf(string &out,const char *format,...)
    ssize_t size = 400;
    std::ostringstream outstr;
    while (true) {
    ssize_t size = 400;
    std::ostringstream outstr;
    while (true) {

+      bool ret;

       va_start(args,format);
       va_start(args,format);

-      if (iovprintf(outstr, format, args, size) == true)
-        break;
+      ret = iovprintf(outstr, format, args, size);

       va_end(args);
       va_end(args);

+      if (ret == true)
+        break;

    }
    out = outstr.str();
 }
    }
    out = outstr.str();
 }


@@ -1339,17 +1369,32 @@ string StripEpoch(const string &VerStr)
    return VerStr.substr(i+1);
 }
                                                                        /*}}}*/
    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
    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. */
 // 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 notable faster than
    standard tolower/toupper and as a bonus avoids problems with different
    locales - we only operate on ascii chars anyway. */

+#undef tolower_ascii
+int tolower_ascii(int const c) APT_CONST APT_COLD;

 int tolower_ascii(int const c)
 {
 int tolower_ascii(int const c)
 {

-   if (c >= 'A' && c <= 'Z')
-      return c + 32;
-   return c;
+   return tolower_ascii_inline(c);
+}
+                                                                       /*}}}*/
+
+// isspace_ascii - isspace() function that ignores the locale          /*{{{*/
+// ---------------------------------------------------------------------
+/* This little function is one of the most called methods we have and tries
+   therefore to do the absolut minimum - and is notable faster than
+   standard isspace() and as a bonus avoids problems with different
+   locales - we only operate on ascii chars anyway. */
+#undef isspace_ascii
+int isspace_ascii(int const c) APT_CONST APT_COLD;
+int isspace_ascii(int const c)
+{
+   return isspace_ascii_inline(c);

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


@@ -1387,7 +1432,7 @@ size_t strv_length(const char **str_array)
       ;
    return i;
 }
       ;
    return i;
 }

-
+                                                                       /*}}}*/

 // DeEscapeString - unescape (\0XX and \xXX) from a string             /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // DeEscapeString - unescape (\0XX and \xXX) from a string             /*{{{*/
 // ---------------------------------------------------------------------
 /* */


@@ -1569,56 +1614,49 @@ 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)
       {
         // FIXME: Technically userinfo is permitted even less
         // characters than these, but this is not conveniently
         // expressed with a blacklist.
       if (User.empty() == false)
       {
         // FIXME: Technically userinfo is permitted even less
         // characters than these, but this is not conveniently
         // expressed with a blacklist.

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

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

-           Res += ":" + QuoteString(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);
 string URI::SiteOnly(const string &URI)
 {
    ::URI U(URI);


@@ -1628,9 +1666,18 @@ string URI::SiteOnly(const string &URI)
    return U;
 }
                                                                        /*}}}*/
    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  /*{{{*/
 // URI::NoUserPassword - Return the schema, site and path for the URI  /*{{{*/

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

 string URI::NoUserPassword(const string &URI)
 {
    ::URI U(URI);
 string URI::NoUserPassword(const string &URI)
 {
    ::URI U(URI);