Fix ReadMessages to handle messages that are longer than 64000 bytes.

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

diff --git a/apt-pkg/contrib/strutl.cc b/apt-pkg/contrib/strutl.cc
index 37d263794b42b9c2049096068e2b3b99124371bd..eacc7077ad36f7fc82c72bbbbe6c7ec16c29c843 100644 (file)
--- a/apt-pkg/contrib/strutl.cc
+++ b/apt-pkg/contrib/strutl.cc
@@ -15,10 +15,6 @@
    ##################################################################### */
                                                                        /*}}}*/
 // Includes                                                            /*{{{*/
    ##################################################################### */
                                                                        /*}}}*/
 // Includes                                                            /*{{{*/

-#ifdef __GNUG__
-#pragma implementation "apt-pkg/strutl.h"
-#endif
-

 #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>


@@ -28,6 +24,7 @@
 #include <ctype.h>
 #include <string.h>
 #include <stdio.h>
 #include <ctype.h>
 #include <string.h>
 #include <stdio.h>

+#include <algorithm>

 #include <unistd.h>
 #include <regex.h>
 #include <errno.h>
 #include <unistd.h>
 #include <regex.h>
 #include <errno.h>


@@ -334,19 +331,19 @@ string TimeToStr(unsigned long Sec)
    {
       if (Sec > 60*60*24)
       {
    {
       if (Sec > 60*60*24)
       {

-        sprintf(S,"%lid %lih%lim%lis",Sec/60/60/24,(Sec/60/60) % 24,(Sec/60) % 60,Sec % 60);
+        sprintf(S,"%lid %lih%limin%lis",Sec/60/60/24,(Sec/60/60) % 24,(Sec/60) % 60,Sec % 60);

         break;
       }
       
       if (Sec > 60*60)
       {
         break;
       }
       
       if (Sec > 60*60)
       {

-        sprintf(S,"%lih%lim%lis",Sec/60/60,(Sec/60) % 60,Sec % 60);
+        sprintf(S,"%lih%limin%lis",Sec/60/60,(Sec/60) % 60,Sec % 60);

         break;
       }
       
       if (Sec > 60)
       {
         break;
       }
       
       if (Sec > 60)
       {

-        sprintf(S,"%lim%lis",Sec/60,Sec % 60);
+        sprintf(S,"%limin%lis",Sec/60,Sec % 60);

         break;
       }
       
         break;
       }
       


@@ -661,11 +658,24 @@ string TimeRFC1123(time_t Date)
 // ---------------------------------------------------------------------
 /* This pulls full messages from the input FD into the message buffer. 
    It assumes that messages will not pause during transit so no
 // ---------------------------------------------------------------------
 /* This pulls full messages from the input FD into the message buffer. 
    It assumes that messages will not pause during transit so no

-   fancy buffering is used. */
+   fancy buffering is used.
+
+   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.
+ */

 bool ReadMessages(int Fd, vector<string> &List)
 {
    char Buffer[64000];
    char *End = Buffer;
 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;

    
    while (1)
    {
    
    while (1)
    {


@@ -693,6 +703,7 @@ bool ReadMessages(int Fd, vector<string> &List)
         
         // Pull the message out
         string Message(Buffer,I-Buffer);
         
         // Pull the message out
         string Message(Buffer,I-Buffer);

+        PartialMessage += Message;

 
         // Fix up the buffer
         for (; I < End && *I == '\n'; I++);
 
         // Fix up the buffer
         for (; I < End && *I == '\n'; I++);


@@ -700,10 +711,32 @@ bool ReadMessages(int Fd, vector<string> &List)
         memmove(Buffer,I,End-Buffer);
         I = Buffer;
         
         memmove(Buffer,I,End-Buffer);
         I = Buffer;
         

-        List.push_back(Message);
+        List.push_back(PartialMessage);
+        PartialMessage.clear();

       }
       }

-      if (End == Buffer)
-        return true;
+      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
+       {
+         // 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;
+       }

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