dpkgpm.h

// -*- mode: cpp; mode: fold -*-
// Description                                                          /*{{{*/
/* ######################################################################
 
   DPKG Package Manager - Provide an interface to dpkg
   
   ##################################################################### */
                                                                        /*}}}*/
#ifndef PKGLIB_DPKGPM_H
#define PKGLIB_DPKGPM_H
 
#include <apt-pkg/macros.h>
#include <apt-pkg/packagemanager.h>
#include <apt-pkg/pkgcache.h>
 
#include <cstdio>
#include <map>
#include <string>
#include <vector>
 
class pkgDepCache;
namespace APT { namespace Progress { class PackageManager; } }
 
 
class pkgDPkgPMPrivate;
 
 
class APT_PUBLIC pkgDPkgPM : public pkgPackageManager
{
   private:
   pkgDPkgPMPrivate * const d;
 
   APT_HIDDEN void handleDisappearAction(std::string const &pkgname);
   APT_HIDDEN void handleCrossUpgradeAction(std::string const &pkgname);
 
   protected:
   int pkgFailures;
 
   // progress reporting
   struct DpkgState 
   {
      const char *state;     // the dpkg state (e.g. "unpack")
      const char *str;       // the human readable translation of the state
   };
 
   // the dpkg states that the pkg will run through, the string is 
   // the package, the vector contains the dpkg states that the package
   // will go through
   std::map<std::string,std::vector<struct DpkgState> > PackageOps;
   // the dpkg states that are already done; the string is the package
   // the int is the state that is already done (e.g. a package that is
   // going to be install is already in state "half-installed")
   std::map<std::string,unsigned int> PackageOpsDone;
 
   // progress reporting
   unsigned int PackagesDone;
   unsigned int PackagesTotal;
 
   public:
   struct Item
   {
      enum Ops {Install, Configure, Remove, Purge, ConfigurePending, TriggersPending,
         RemovePending, PurgePending } Op;
      std::string File;
      PkgIterator Pkg;
      Item(Ops Op,PkgIterator Pkg,std::string File = "") : Op(Op),
            File(File), Pkg(Pkg) {};
      Item() {};
   };
   protected:
   std::vector<Item> List;
 
   // Helpers
   bool RunScriptsWithPkgs(const char *Cnf);
   bool SendPkgsInfo(FILE * const F, unsigned int const &Version);
   void WriteHistoryTag(std::string const &tag, std::string value);
   std::string ExpandShortPackageName(pkgDepCache &Cache,
                                      const std::string &short_pkgname);
 
   // Terminal progress 
   void SendTerminalProgress(float percentage);
 
   // apport integration
   void WriteApportReport(const char *pkgpath, const char *errormsg);
 
   // dpkg log
   bool OpenLog();
   bool CloseLog();
 
   // helper
   void BuildPackagesProgressMap();
   void StartPtyMagic();
   void SetupSlavePtyMagic();
   void StopPtyMagic();
   
   // input processing
   void DoStdin(int master);
   void DoTerminalPty(int master);
   void DoDpkgStatusFd(int statusfd);
   void ProcessDpkgStatusLine(char *line);
 
   // The Actual installation implementation
   bool Install(PkgIterator Pkg,std::string File) override;
   bool Configure(PkgIterator Pkg) override;
   bool Remove(PkgIterator Pkg, bool Purge = false) override;
 
   bool Go(APT::Progress::PackageManager *progress) override;
 
   void Reset() override;
 
   public:
 
   explicit pkgDPkgPM(pkgDepCache *Cache);
   ~pkgDPkgPM() override;
 
   APT_HIDDEN static bool ExpandPendingCalls(std::vector<Item> &List, pkgDepCache &Cache);
};
 
void SigINT(int sig);
 
#endif