separating state variables regarding server/request

Having a Reset(bool) method to partially reset certain variables like
the download size always were strange, so this commit splits the
ServerState into an additional RequestState living on the stack for as
long as we deal with this request causing an automatic "reset".

There is much to do still to make this code look better, but this is a
good first step which compiles cleanly and passes all tests, so keeping
it as history might be beneficial and due to avoiding explicit memory
allocations it ends up fixing a small memory leak in https, too.

Closes: #440057

1 files changed, 40 insertions, 33 deletions

diff --git a/methods/server.h b/methods/server.h
index c3adba87a..6b12c7c7a 100644
--- a/methods/server.h
+++ b/methods/server.h
@@ -12,6 +12,7 @@
 #define APT_SERVER_H
 
 #include <apt-pkg/strutl.h>
+#include <apt-pkg/fileutl.h>
 #include "aptmethod.h"
 
 #include <time.h>
@@ -24,52 +25,62 @@ using std::endl;
 
 class Hashes;
 class ServerMethod;
-class FileFd;
+struct ServerState;
 
-struct ServerState
+struct RequestState
 {
-   // This is the last parsed Header Line
-   unsigned int Major;
-   unsigned int Minor;
-   unsigned int Result;
+   unsigned int Major = 0;
+   unsigned int Minor = 0;
+   unsigned int Result = 0;
    char Code[360];
 
-   // These are some statistics from the last parsed header lines
-
    // total size of the usable content (aka: the file)
-   unsigned long long TotalFileSize;
+   unsigned long long TotalFileSize = 0;
    // size we actually download (can be smaller than Size if we have partial content)
-   unsigned long long DownloadSize;
+   unsigned long long DownloadSize = 0;
    // size of junk content (aka: server error pages)
-   unsigned long long JunkSize;
+   unsigned long long JunkSize = 0;
    // The start of the data (for partial content)
-   unsigned long long StartPos;
+   unsigned long long StartPos = 0;
+
+   unsigned long long MaximumSize = 0;
 
    time_t Date;
-   bool HaveContent;
-   enum {Chunked,Stream,Closes} Encoding;
-   enum {Header, Data} State;
+   bool HaveContent = false;
+   enum {Chunked,Stream,Closes} Encoding = Closes;
+   enum {Header, Data} State = Header;
+   std::string Location;
+
+   FileFd File;
+
+   ServerMethod * const Owner;
+   ServerState * const Server;
+
+   bool HeaderLine(std::string const &Line);
+   bool AddPartialFileToHashes(FileFd &File);
+
+   RequestState(ServerMethod * const Owner, ServerState * const Server) :
+      Owner(Owner), Server(Server) { time(&Date); }
+};
+
+struct ServerState
+{
    bool Persistent;
    bool PipelineAllowed;
    bool RangesAllowed;
-   std::string Location;
 
-   // This is a Persistent attribute of the server itself.
    bool Pipeline;
    URI ServerName;
    URI Proxy;
    unsigned long TimeOut;
 
-   unsigned long long MaximumSize;
-
    protected:
    ServerMethod *Owner;
 
    virtual bool ReadHeaderLines(std::string &Data) = 0;
-   virtual bool LoadNextResponse(bool const ToFile, FileFd * const File) = 0;
+   virtual bool LoadNextResponse(bool const ToFile, RequestState &Req) = 0;
 
    public:
-   bool HeaderLine(std::string Line);
 
    /** \brief Result of the header acquire */
    enum RunHeadersResult {
@@ -81,25 +92,24 @@ struct ServerState
       RUN_HEADERS_PARSE_ERROR
    };
    /** \brief Get the headers before the data */
-   RunHeadersResult RunHeaders(FileFd * const File, const std::string &Uri);
-   bool AddPartialFileToHashes(FileFd &File);
+   RunHeadersResult RunHeaders(RequestState &Req, const std::string &Uri);
 
    bool Comp(URI Other) const {return Other.Host == ServerName.Host && Other.Port == ServerName.Port;};
-   virtual void Reset(bool const Everything = true);
+   virtual void Reset();
    virtual bool WriteResponse(std::string const &Data) = 0;
 
    /** \brief Transfer the data from the socket */
-   virtual bool RunData(FileFd * const File) = 0;
-   virtual bool RunDataToDevNull() = 0;
+   virtual bool RunData(RequestState &Req) = 0;
+   virtual bool RunDataToDevNull(RequestState &Req) = 0;
 
    virtual bool Open() = 0;
    virtual bool IsOpen() = 0;
    virtual bool Close() = 0;
    virtual bool InitHashes(HashStringList const &ExpectedHashes) = 0;
-   virtual Hashes * GetHashes() = 0;
-   virtual bool Die(FileFd * const File) = 0;
+   virtual bool Die(RequestState &Req) = 0;
    virtual bool Flush(FileFd * const File) = 0;
-   virtual bool Go(bool ToFile, FileFd * const File) = 0;
+   virtual bool Go(bool ToFile, RequestState &Req) = 0;
+   virtual Hashes * GetHashes() = 0;
 
    ServerState(URI Srv, ServerMethod *Owner);
    virtual ~ServerState() {};
@@ -112,7 +122,6 @@ class ServerMethod : public aptMethod
 
    std::unique_ptr<ServerState> Server;
    std::string NextURI;
-   FileFd *File;
 
    unsigned long PipelineDepth;
    bool AllowRedirect;
@@ -140,7 +149,7 @@ class ServerMethod : public aptMethod
       TRY_AGAIN_OR_REDIRECT
    };
    /** \brief Handle the retrieved header data */
-   virtual DealWithHeadersResult DealWithHeaders(FetchResult &Res);
+   virtual DealWithHeadersResult DealWithHeaders(FetchResult &Res, RequestState &Req);
 
    // In the event of a fatal signal this file will be closed and timestamped.
    static std::string FailFile;
@@ -148,8 +157,6 @@ class ServerMethod : public aptMethod
    static time_t FailTime;
    static APT_NORETURN void SigTerm(int);
 
-   virtual bool Flush() { return Server->Flush(File); };
-
    int Loop();
 
    virtual void SendReq(FetchItem *Itm) = 0;