$ mkdir sandbox
$ cd sandbox
$ vagrant init
$ echo > Vagranfile <<EOF
# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|
  config.vm.box = "debian/buster64"
end
EOF
$ vagrant up
# wait a few minutes
$ vagrant ssh
vagrant$ uname -a
Linux buster 4.19.0-16-amd64 #1 SMP Debian 4.19.181-1 (2021-03-19) x86_64 GNU/Linux

$ ls
Vagrantfile
$ cp /path/to/hello .
$ vagrant ssh
vagrant$ cd /vagrant
vagrant$ ls
hello Vagrantfile

vagrant# cd /vagrant/
vagrant# mkdir -p ./debian/usr/bin (1)
vagrant# cp hello ./debian/usr/bin/
vagrant# mkdir -p ./debian/DEBIAN (1)
vagrant# cat > ./debian/DEBIAN/control <<EOF
Package: hello
Version: 1.1-1
Section: base
Priority: optional
Architecture: amd64
Maintainer: Julien Sobczak
Description: Say Hello
EOF
vagrant# cat > ./debian/DEBIAN/preinst <<EOF (2)
#!/bin/sh
echo "preinst says hello";
EOF
vagrant# cat > ./debian/DEBIAN/postinst <<EOF (2)
#!/bin/sh
echo "postinst says hello";
EOF
vagrant# tree /vagrant/debian/
|-- DEBIAN
|   |-- control
|   |-- preinst
|   `-- postinst
`-- usr
    `-- bin
        `-- hello

$ apt install fakeroot # install the fakeroot command
$ fakeroot dpkg --build debian hello_1.1-1_amd64.deb (1)

$ apt install binutils # install the ar command
$ apt install fakeroot # install the fakeroot command
$ echo 2.0 > debian-binary
$ cd debian && tar czf ../data.tar.gz [a-z]* && cd ..
$ cd debian/DEBIAN/ && tar czf ../../control.tar.gz * && cd ../..
$ fakeroot ar r hello_1.1-1_amd64.deb debian-binary control.tar.gz data.tar.gz
ar: creating hello_1.1-1_amd64.deb (1)

int
do_build(const char *const *argv)
{
  struct compress_params control_compress_params;
  struct tar_pack_options tar_options;
  struct dpkg_error err;
  struct dpkg_ar *ar;
  const char *dir, *dest;
  char *ctrldir;
  char *debar;
  char *tfbuf;
  int gzfd;

  /* Decode our arguments. */
  dir = *argv++;
  dest = *argv++;

  debar = gen_dest_pathname(dir, dest); (1)
  ctrldir = str_fmt("%s/%s", dir, "DEBIAN");

  /* Now that we have verified everything it is time to actually
   * build something. Let's start by making the ar-wrapper. */
  ar = dpkg_ar_create(debar, 0644); (2)

  /* Create a temporary file to store the control data in. */
  tfbuf = path_make_temp_template("dpkg-deb");
  gzfd = mkstemp(tfbuf);
  free(tfbuf);

  /* Select the compressor to use for our control archive. */
  control_compress_params.type = COMPRESSOR_TYPE_GZIP;
  control_compress_params.strategy = COMPRESSOR_STRATEGY_NONE;
  control_compress_params.level = -1;

  /* Fork a tar to package the control-section of the package. */
  tar_options.mode = "u+rw,go=rX";
  tar_options.root_owner_group = true;
  tarball_pack(ctrldir, control_treewalk_feed, &tar_options,
               &control_compress_params, gzfd);

  free(ctrldir);

  /* We have our first file for the ar-archive. Write a header for it
   * to the package and insert it. */
  const char deb_magic[] = "2.0\n";
  char adminmember[16 + 1];

  sprintf(adminmember, "%s%s", "control.tar",
          compressor_get_extension(control_compress_params.type));

  dpkg_ar_put_magic(ar); (3)
  dpkg_ar_member_put_mem(ar, "debian-binary", deb_magic, strlen(deb_magic)); (4)
  dpkg_ar_member_put_file(ar, adminmember, gzfd, -1); (5)

  close(gzfd);

  /* Control is done, now we need to archive the data. */

  /* Start by creating a new temporary file. */
  tfbuf = path_make_temp_template("dpkg-deb");
  gzfd = mkstemp(tfbuf);
  free(tfbuf);

  /* Pack the directory into a tarball, feeding files from the callback. */
  tar_options.mode = NULL;
  tar_options.root_owner_group = opt_root_owner_group;
  tarball_pack(dir, file_treewalk_feed, &tar_options, &compress_params, gzfd);

  /* Okay, we have data.tar as well now, add it to the ar wrapper. */
  char datamember[16 + 1];

  sprintf(datamember, "%s%s", "data.tar",
          compressor_get_extension(compress_params.type));

  dpkg_ar_member_put_file(ar, datamember, gzfd, -1); (6)

  close(gzfd);

  if (fsync(ar->fd))
    ohshite(_("unable to sync file '%s'"), ar->name);

  dpkg_ar_close(ar); (7)

  free(debar);

  return 0;
}

package main

import (
    "archive/tar"
    "bytes"
    "fmt"
    "io/ioutil"
    "log"
    "os"
    "path/filepath"
    "strings"

    "github.com/blakesmith/ar"
)

func main() {
    // This program expects two arguments:
    // - The directory following the resources to package in the archive.
    // - The name of the output .deb file
    if len(os.Args) < 3 {
        log.Fatalf("Missing 'directory' and/or 'dest' arguments.")
    }

    directory := os.Args[1]
    dest := os.Args[2]

    // Create the Debian archive file
    fdeb, _ := os.Create(dest)
    defer fdeb.Close()

    // A Debian package is an archive using the AR format.
    // We use an external Go module to create the archive
    // as the standard library does not support it but supports
    // the tar format that will be used for the control and data files.

    writer := ar.NewWriter(fdeb)
    writer.WriteGlobalHeader()

    // A Debian package contains 3 files that must be
    // added in a precise order.
    // We use two utility functions that will be defined later:
    // - arPutFile is a wrapper around the library to add an entry.
    // - tarballPack creates a tarball using the Go library.

    // Append debian-binary
    arPutFile(writer, "debian-binary", []byte("2.0\n"))

    // Append control.tar
    controlDir := filepath.Join(directory, "DEBIAN")
    controlTarball := tarballPack(controlDir, nil)
    arPutFile(writer, "control.tar", controlTarball)

    // Append data.tar
    dataDir := directory
    dataTarball := tarballPack(dataDir, func(path string) bool {
        // Filter DEBIAN/ files
        return strings.HasPrefix(path, controlDir)
    })
    arPutFile(writer, "data.tar", dataTarball)
}

// arPutFile adds a new entry in a AR archive.
func arPutFile(w *ar.Writer, name string, body []byte) {
    hdr := &ar.Header{
        Name: name,
        Mode: 0600,
        Uid:  0,
        Gid:  0,
        Size: int64(len(body)),
    }
    w.WriteHeader(hdr)
    w.Write(body)
}

// tarballPack traverses a local directory to add all files under it
// into a tarball.
func tarballPack(directory string, filter func(string) bool) []byte {
    var bufdata bytes.Buffer
    twdata := tar.NewWriter(&bufdata)
    filepath.Walk(
        directory,
        func(path string, info os.FileInfo, errParent error) error {
            if info.IsDir() {
                return nil
            }
            if filter != nil && filter(path) {
                return nil
            }
            sep := fmt.Sprintf("%c", filepath.Separator)
            name := strings.TrimPrefix(strings.TrimPrefix(path, directory), sep)
            hdr := &tar.Header{
                Name: name,
                Uid:  0, // root
                Gid:  0, // root
                Mode: 0650,
                Size: info.Size(),
            }
            twdata.WriteHeader(hdr)
            content, _ := ioutil.ReadFile(path)
            twdata.Write(content)

            return nil
        })
    twdata.Close()

    return bufdata.Bytes()
}

$ go run main.go hello hello.deb

vagrant# dpkg -c /vagrant/hello.deb
-rw-r-x--- 0/0         2034781 1970-01-01 00:00 usr/bin/hello

vagrant# ar -tf /vagrant/hello.deb
ar -tf /vagrant/hello.deb
debian-binary
control.tar
data.tar
vagrant# ar -xf /vagrant/hello.deb data.tar
vagrant# tar -tf data.tar
usr/bin/hello

vagrant# dpkg -i /vagrant/hello.deb
Selecting previously unselected package hello.
(Reading database ... 32264 files and directories currently installed.)
Preparing to unpack /vagrant/hello.deb ...
preinst says hello
Unpacking hello (1.1-1) ...
Setting up hello (1.1-1) ...
postinst says hello

vagrant# hello
hello world

int
archivefiles(const char *const *argv)
{
  int i;

  modstatdb_open(msdbrw_readonly);

  for (i = 0; argv[i]; i++) {
    process_archive(argv[i]); (1)
  }

  process_queue(); (2)

  trigproc_run_deferred();
  modstatdb_shutdown();

  return 0;
}

void process_archive(const char *filename) {
  …
  cidir = get_control_dir(cidir); (1)
  pid = subproc_fork();
  if (pid == 0) {
    cidirrest[-1] = '\0';
    execlp("dpkg-deb", "dpkg-deb", "--control", filename, cidir, NULL); (2)
    ohshite(_("unable to execute %s (%s)"),
            _("package control information extraction"), BACKEND);
  }
  subproc_reap(pid, "dpkg-deb --control", 0);
  …
}

/**
 * Node describing an architecture package instance.
 *
 * This structure holds state information.
 */
struct pkginfo {
  struct pkgset *set;

  enum pkgwant want; (1)
  /** The error flag bitmask. */
  enum pkgeflag eflag; (2)
  enum pkgstatus status;
  enum pkgpriority priority;

  struct pkgbin installed; (3)
  struct pkgbin available; (3)

  struct fsys_namenode_list *files; (4)
  bool files_list_valid; (4)

  /* The status has changed, it needs to be logged. */
  bool status_dirty; (5)
}

void process_archive(const char *filename) {
  struct pkginfo *pkg;
  …
  parsedb(cidir, parsedb_flags, &pkg); (1)
  …
}

void process_archive(const char *filename) {
  …
  oldversionstatus = pkg->status; (1)

  if (oldversionstatus == PKG_STAT_INSTALLED) {
    pkg_set_eflags(pkg, PKG_EFLAG_REINSTREQ);
    pkg_set_status(pkg, PKG_STAT_HALFCONFIGURED); (2)
    modstatdb_note(pkg); (2)
    if (dpkg_version_compare(&pkg->available.version,
                             &pkg->installed.version) >= 0)
      /* Upgrade or reinstall. */
      maintscript_fallback(pkg, PRERMFILE, "pre-removal", cidir, cidirrest,
                           "upgrade", "failed-upgrade"); (3)
    else /* Downgrade => no fallback */
      maintscript_installed(pkg, PRERMFILE, "pre-removal",
                            "upgrade",
                            versiondescribe(&pkg->available.version,
                                            vdew_nonambig),
                            NULL); (2)
    pkg_set_status(pkg, PKG_STAT_UNPACKED); (1)
    oldversionstatus = PKG_STAT_UNPACKED;
    modstatdb_note(pkg); (1)
  }
  …
}

void process_archive(const char *filename) {
  …
  if (pkg->status == PKG_STAT_NOTINSTALLED) {
    pkg->installed.version = pkg->available.version;
    pkg->installed.multiarch = pkg->available.multiarch;
  }
  pkg_set_status(pkg, PKG_STAT_HALFINSTALLED);
  modstatdb_note(pkg);
  if (oldversionstatus == PKG_STAT_NOTINSTALLED) { (1)
    maintscript_new(pkg, PREINSTFILE, "pre-installation", cidir, cidirrest,
                    "install", NULL);
  } else if (oldversionstatus == PKG_STAT_CONFIGFILES) { (1)
    maintscript_new(pkg, PREINSTFILE, "pre-installation", cidir, cidirrest,
                    "install",
                    versiondescribe(&pkg->installed.version, vdew_nonambig),
                    versiondescribe(&pkg->available.version, vdew_nonambig),
                    NULL);
  } else { (1)
    maintscript_new(pkg, PREINSTFILE, "pre-installation", cidir, cidirrest,
                    "upgrade",
                    versiondescribe(&pkg->installed.version, vdew_nonambig),
                    versiondescribe(&pkg->available.version, vdew_nonambig),
                    NULL);
  }
  …
}

  /*
   * Now we unpack the archive, backing things up as we go.
   * For each file, we check to see if it already exists.
   * There are several possibilities:
   *
   * + We are trying to install a non-directory ...
   *  - It doesn't exist. In this case we simply extract it.
   *  - It is a plain file, device, symlink, &c. We do an ‘atomic
   *    overwrite’ using link() and rename(), but leave a backup copy.
   *    Later, when we delete the backup, we remove it from any other
   *    packages' lists.
   *  - It is a directory. In this case it depends on whether we're
   *    trying to install a symlink or something else.
   *   = If we're not trying to install a symlink we move the directory
   *     aside and extract the node. Later, when we recursively remove
   *     the backed-up directory, we remove it from any other packages'
   *     lists.
   *   = If we are trying to install a symlink we do nothing - ie,
   *     dpkg will never replace a directory tree with a symlink. This
   *     is to avoid embarrassing effects such as replacing a directory
   *     tree with a link to a link to the original directory tree.
   * + We are trying to install a directory ...
   *  - It doesn't exist. We create it with the appropriate modes.
   *  - It exists as a directory or a symlink to one. We do nothing.
   *  - It is a plain file or a symlink (other than to a directory).
   *    We move it aside and create the directory. Later, when we
   *    delete the backup, we remove it from any other packages' lists.
   *
   *                   Install non-dir   Install symlink   Install dir
   *  Exists not               X               X                X
   *  File/node/symlink       LXR             LXR              BXR
   *  Directory               BXR              -                -
   *
   *    X: extract file/node/link/directory
   *   LX: atomic overwrite leaving backup
   *    B: ordinary backup
   *    R: later remove from other packages' lists
   *    -: do nothing
   *
   * After we've done this we go through the remaining things in the
   * lists of packages we're trying to remove (including the old
   * version of the current package). This happens in reverse order,
   * so that we process files before the directories (or symlinks-to-
   * directories) containing them.
   *
   * + If the thing is a conffile then we leave it alone for the purge
   *   operation.
   * + Otherwise, there are several possibilities too:
   *  - The listed thing does not exist. We ignore it.
   *  - The listed thing is a directory or a symlink to a directory.
   *    We delete it only if it isn't listed in any other package.
   *  - The listed thing is not a directory, but was part of the package
   *    that was upgraded, we check to make sure the files aren't the
   *    same ones from the old package by checking dev/inode
   *  - The listed thing is not a directory or a symlink to one (ie,
   *    it's a plain file, device, pipe, &c, or a symlink to one, or a
   *    dangling symlink). We delete it.
   *
   * The removed packages' list becomes empty (of course, the new
   * version of the package we're installing will have a new list,
   * which replaces the old version's list).
   *
   * If at any stage we remove a file from a package's list, and the
   * package isn't one we're already processing, and the package's
   * list becomes empty as a result, we ‘vanish’ the package. This
   * means that we run its postrm with the ‘disappear’ argument, and
   * put the package in the ‘not-installed’ state. If it had any
   * conffiles, their hashes and ownership will have been transferred
   * already, so we just ignore those and forget about them from the
   * point of view of the disappearing package.
   *
   * NOTE THAT THE OLD POSTRM IS RUN AFTER THE NEW PREINST, since the
   * files get replaced ‘as we go’.
   */

void process_archive(const char *filename) {
  …

  /* OK, now we can write the updated files-in-this package list,
   * since we've done away (hopefully) with all the old junk. */
  write_filelist_except(pkg, &pkg->available, newfiles_queue.head, 0); (1)

  /* We also install the new maintainer scripts, and any other
   * cruft that may have come along with the package. First
   * we go through the existing scripts replacing or removing
   * them as appropriate; then we go through the new scripts
   * (any that are left) and install them. */
  pkg_infodb_update(pkg, cidir, cidirrest); (2)

  /* We store now the checksums dynamically computed while unpacking. */
  write_filehash_except(pkg, &pkg->available, newfiles_queue.head, 0); (3)

  /* Right, the package we've unpacked is now in a reasonable state.
   * The only thing that we have left to do with it is remove
   * backup files, and we can leave the user to fix that if and when
   * it happens (we leave the reinstall required flag, of course). */
  pkg_set_status(pkg, PKG_STAT_UNPACKED);
  modstatdb_note(pkg); (4)

  ...
}

int
archivefiles(const char *const *argv)
{
  int i;

  modstatdb_open(msdbrw_readonly);

  for (i = 0; argv[i]; i++) {
    process_archive(argv[i]);
  }

  process_queue(); (1)

  trigproc_run_deferred();
  modstatdb_shutdown();

  return 0;
}

static struct pkg_queue queue = { .head = NULL, .tail = NULL, .length = 0 }; (1)


/*
 * During the packages queue processing, the algorithm for deciding what to
 * configure first is as follows:
 *
 * Loop through all packages doing a ‘try 1’ until we've been round and
 * nothing has been done, then do ‘try 2’, and subsequent ones likewise.
 * The incrementing of ‘dependtry’ is done by process_queue().
 *
 * Try 1:
 *   Are all dependencies of this package done? If so, do it.
 *   Are any of the dependencies missing or the wrong version?
 *     If so, abort (unless --force-depends, in which case defer).
 *   Will we need to configure a package we weren't given as an
 *     argument? If so, abort ─ except if --force-configure-any,
 *     in which case we add the package to the argument list.
 *   If none of the above, defer the package.
 *
 * Try 2:
 *   Find a cycle and break it (see above).
 *   Do as for try 1.
 *
 * Try 3:
 *   Start processing triggers if necessary.
 *   Do as for try 2.
 *
 * Try 4:
 *   Same as for try 3, but check trigger cycles even when deferring
 *   processing due to unsatisfiable dependencies.
 *
 * Try 5 (only if --force-depends-version):
 *   Same as for try 2, but don't mind version number in dependencies.
 *
 * Try 6 (only if --force-depends):
 *   Do anyway.
 */
enum dependtry {
    DEPEND_TRY_NORMAL = 1,
    DEPEND_TRY_CYCLES = 2,
    DEPEND_TRY_TRIGGERS = 3,
    DEPEND_TRY_TRIGGERS_CYCLES = 4,
    DEPEND_TRY_FORCE_DEPENDS_VERSION = 5,
    DEPEND_TRY_FORCE_DEPENDS = 6,
    DEPEND_TRY_LAST,
};
enum dependtry dependtry = DEPEND_TRY_NORMAL; (2)
int sincenothing = 0; (2)

void process_queue(void) {
  struct pkginfo *volatile pkg;
  volatile enum action action_todo;

  while (!pkg_queue_is_empty(&queue)) {
    pkg = pkg_queue_pop(&queue);

    ensure_package_clientdata(pkg);
    pkg->clientdata->enqueued = false;

    action_todo = cipaction->arg_int;

    if (sincenothing++ > queue.length * 3 + 2) {
      /* Make sure that even if we have exceeded the queue since not having
       * made any progress, we are not getting stuck trying to progress by
       * trigger processing, w/o jumping into the next dependtry. */
      dependtry++;
      sincenothing = 0;
      if (dependtry >= DEPEND_TRY_LAST)
        internerr("exceeded dependtry %d (sincenothing=%d; queue.length=%d)",
                  dependtry, sincenothing, queue.length);
    } else if (sincenothing > queue.length * 2 + 2) {
      if (dependtry >= DEPEND_TRY_TRIGGERS &&
          progress_bytrigproc && progress_bytrigproc->trigpend_head) {
        enqueue_package(pkg);
        pkg = progress_bytrigproc;
        progress_bytrigproc = NULL;
        action_todo = act_configure;
      } else {
        dependtry++;
        sincenothing = 0;
        if (dependtry >= DEPEND_TRY_LAST)
          internerr("exceeded dependtry %d (sincenothing=%d, queue.length=%d)",
                    dependtry, sincenothing, queue.length);
      }
    }

    debug(dbg_general, "process queue pkg %s queue.len %d progress %d, try %d",
          pkg_name(pkg, pnaw_always), queue.length, sincenothing, dependtry);

    deferred_configure(pkg); (1)
  }

  if (queue.length)
    internerr("finished package processing with non-empty queue length %d",
              queue.length);
}

/**
 * Process the deferred configure package.
 *
 * @param pkg The package to act on.
 */
void
deferred_configure(struct pkginfo *pkg)
{
    struct varbuf aemsgs = VARBUF_INIT;
    struct conffile *conff;
    struct pkginfo *otherpkg;
    enum dep_check ok;

    ok = dependencies_ok(pkg, NULL, &aemsgs); (1)
    if (ok == DEP_CHECK_DEFER) {
        varbuf_destroy(&aemsgs);
        ensure_package_clientdata(pkg);
        pkg->clientdata->istobe = PKG_ISTOBE_INSTALLNEW;
        enqueue_package(pkg);
        return;
    }

    /*
     * At this point removal from the queue is confirmed. This
     * represents irreversible progress wrt trigger cycles. Only
     * packages in PKG_STAT_UNPACKED are automatically added to the
     * configuration queue, and during configuration and trigger
     * processing new packages can't enter into unpacked.
     */
    sincenothing = 0;


    printf(_("Setting up %s (%s) ...\n"), pkg_name(pkg, pnaw_nonambig),
           versiondescribe(&pkg->installed.version, vdew_nonambig));
    log_action("configure", pkg, &pkg->installed);


    if (pkg->status == PKG_STAT_UNPACKED) {
        /* On entry, the ‘new’ version of each conffile has been
         * unpacked as ‘*.dpkg-new’, and the ‘installed’ version is
         * as-yet untouched in ‘*’. The hash of the ‘old distributed’
         * version is in the conffiles data for the package. If
         * ‘*.dpkg-new’ no longer exists we assume that we've
         * already processed this one. */
        for (conff = pkg->installed.conffiles; conff; conff = conff->next) {
            deferred_configure_conffile(pkg, conff); (2)
        }

        pkg_set_status(pkg, PKG_STAT_HALFCONFIGURED);
        modstatdb_note(pkg);
    }

    maintscript_postinst(pkg, "configure",
      dpkg_version_is_informative(&pkg->configversion) ?
            versiondescribe(&pkg->configversion, vdew_nonambig) :
          "",
      NULL); (3)

    pkg_reset_eflags(pkg);
    post_postinst_tasks(pkg, PKG_STAT_INSTALLED); (4)
}

vagrant# hello
hello world!

vagrant# dpkg -s hello
Package: hello
Status: install ok unpacked
Priority: optional
Section: base
Maintainer: Julien Sobczak
Architecture: amd64
Version: 1.1-1
Description: Say Hello

# dpkg -r hello
(Reading database ... 26963 files and directories currently installed.)
Removing hello (1.1-1) ...

# hello
bash: /usr/bin/hello: No such file or directory

package main

import (
    "archive/tar"
    "bytes"
    "fmt"
    "io"
    "log"
    "os"
    "os/exec"
    "path/filepath"
    "strings"

    "github.com/blakesmith/ar"
    "github.com/julien-sobczak/deb822"
)

func main() {
    // This program expects one or more package files to install.
    if len(os.Args) < 2 {
        log.Fatalf("Missing package archive(s)")
    }

    // Read the DPKG database
    db, _ := loadDatabase()

    // Unpack and configure the archive(s)
    for _, archivePath := range os.Args[1:] {
        processArchive(db, archivePath)
    }

    // For simplicity reasons, we don't manage a queue to defer
    // the configuration of packages like in the official code.
}

//
// Dpkg Database
//

type Database struct {
    // File /var/lib/dpkg/status
    Status deb822.Document
    // Packages under /var/lib/dpkg/info/
    Packages []*PackageInfo
}

type PackageInfo struct {
    Paragraph deb822.Paragraph // Extracted section in /var/lib/dpkg/status

    // info
    Files             []string          // File <name>.list
    Conffiles         []string          // File <name>.conffiles
    MaintainerScripts map[string]string // File <name>.{preinst,prerm,...}

    Status      string // Current status (as present in `Paragraph`)
    StatusDirty bool   // True to ask for sync
}

func (p *PackageInfo) Name() string {
    // Extract the package name from its section in /var/lib/dpkg/status
    return p.Paragraph.Value("Package")
}

func (p *PackageInfo) Version() string {
    // Extract the package version from its section in /var/lib/dpkg/status
    return p.Paragraph.Value("Version")
}

// isConffile determines if a file must be processed as a conffile.
func (p *PackageInfo) isConffile(path string) bool {
    for _, conffile := range p.Conffiles {
        if path == conffile {
            return true
        }
    }
    return false
}

// InfoPath returns the path of a file under /var/lib/dpkg/info/.
// Ex: "list" => /var/lib/dpkg/info/hello.list
func (p *PackageInfo) InfoPath(filename string) string {
    return filepath.Join("/var/lib/dpkg", p.Name()+"."+filename)
}

// We now add a method to change the package status
// and make sure the section in the status file is updated too.
// This method will be used several times at the different steps
// of the installation process.

func (p *PackageInfo) SetStatus(new string) {
    p.Status = new
    p.StatusDirty = true
    // Override in DEB 822 document used to write the status file
    old := p.Paragraph.Values["Status"]
    parts := strings.Split(old, " ")
    newStatus := fmt.Sprintf("%s %s %s", parts[0], parts[1], new)
    p.Paragraph.Values["Status"] = newStatus
}

// Now, we are ready to read the database directory to initialize the structs.

func loadDatabase() (*Database, error) {
    // Load the status file
    f, _ := os.Open("/var/lib/dpkg/status")
    parser, _ := deb822.NewParser(f)
    status, _ := parser.Parse()

    // Read the info directory
    var packages []*PackageInfo
    for _, statusParagraph := range status.Paragraphs {
        statusField := statusParagraph.Value("Status") // install ok installed
        statusValues := strings.Split(statusField, " ")

        pkg := PackageInfo{
            Paragraph:         statusParagraph,
            MaintainerScripts: make(map[string]string),
            Status:            statusValues[2],
            StatusDirty:       false,
        }

        // Read the configuration files
        pkg.Files, _ = ReadLines(pkg.InfoPath("list"))
        pkg.Conffiles, _ = ReadLines(pkg.InfoPath("conffiles"))

        // Read the maintainer scripts
        maintainerScripts := []string{"preinst", "postinst", "prerm", "postrm"}
        for _, script := range maintainerScripts {
            scriptPath := pkg.InfoPath(script)
            if _, err := os.Stat(scriptPath); !os.IsNotExist(err) {
                content, err := os.ReadFile(scriptPath)
                if err != nil {
                    return nil, err
                }
                pkg.MaintainerScripts[script] = string(content)
            }
        }
        packages = append(packages, &pkg)
    }

    // We have read everything that interest us and are ready
    // to populate the Database struct.

    return &Database{
        Status:   status,
        Packages: packages,
    }, nil
}

// Now we are ready to process an archive to install.

func processArchive(db *Database, archivePath string) error {

    // Read the Debian archive file
    f, err := os.Open(archivePath)
    if err != nil {
        return err
    }
    defer f.Close()
    reader := ar.NewReader(f)

    // Skip debian-binary
    reader.Next()

    // control.tar
    reader.Next()
    var bufControl bytes.Buffer
    io.Copy(&bufControl, reader)

    pkg, err := parseControl(db, bufControl)
    if err != nil {
        return err
    }

    // Add the new package in the database
    db.Packages = append(db.Packages, pkg)
    db.Sync()

    // data.tar
    reader.Next()
    var bufData bytes.Buffer
    io.Copy(&bufData, reader)

    fmt.Printf("Preparing to unpack %s ...\n", filepath.Base(archivePath))

    if err := pkg.Unpack(bufData); err != nil {
        return err
    }
    if err := pkg.Configure(); err != nil {
        return err
    }

    db.Sync()

    return nil
}

// parseControl processes the control.tar archive.
func parseControl(db *Database, buf bytes.Buffer) (*PackageInfo, error) {

    // The control.tar archive contains the most important files
    // we need to install the package.
    // We need to extract metadata from the control file, determine
    // if the package contains conffiles and maintainer scripts.

    pkg := PackageInfo{
        MaintainerScripts: make(map[string]string),
        Status:            "not-installed",
        StatusDirty:       true,
    }

    tr := tar.NewReader(&buf)

    for {
        hdr, err := tr.Next()
        if err == io.EOF {
            break // End of archive
        }
        if err != nil {
            return nil, err
        }

        // Read the file content
        var buf bytes.Buffer
        if _, err := io.Copy(&buf, tr); err != nil {
            return nil, err
        }

        switch filepath.Base(hdr.Name) {
        case "control":
            parser, _ := deb822.NewParser(strings.NewReader(buf.String()))
            document, _ := parser.Parse()
            controlParagraph := document.Paragraphs[0]

            // Copy control fields and add the Status field in second position
            pkg.Paragraph = deb822.Paragraph{
                Values: make(map[string]string),
            }

            // Make sure the field "Package' comes first, then "Status",
            // then remaining fields.
            pkg.Paragraph.Order = append(
                pkg.Paragraph.Order, "Package", "Status")
            pkg.Paragraph.Values["Package"] = controlParagraph.Value("Package")
            pkg.Paragraph.Values["Status"] = "install ok non-installed"
            for _, field := range controlParagraph.Order {
                if field == "Package" {
                    continue
                }
                pkg.Paragraph.Order = append(pkg.Paragraph.Order, field)
                pkg.Paragraph.Values[field] = controlParagraph.Value(field)
            }
        case "conffiles":
            pkg.Conffiles = SplitLines(buf.String())
        case "prerm":
            fallthrough
        case "preinst":
            fallthrough
        case "postinst":
            fallthrough
        case "postrm":
            pkg.MaintainerScripts[filepath.Base(hdr.Name)] = buf.String()
        }
    }

    return &pkg, nil
}

// Unpack processes the data.tar archive.
func (p *PackageInfo) Unpack(buf bytes.Buffer) error {

    // The unpacking process consists in extracting all files
    // in data.tar to their final destination, except for conffiles,
    // which are copied with a special extension that will be removed
    // in the configure step.

    if err := p.runMaintainerScript("preinst"); err != nil {
        return err
    }

    fmt.Printf("Unpacking %s (%s) ...\n", p.Name(), p.Version())

    tr := tar.NewReader(&buf)
    for {
        hdr, err := tr.Next()
        if err == io.EOF {
            break // End of archive
        }
        if err != nil {
            return err
        }

        var buf bytes.Buffer
        if _, err := io.Copy(&buf, tr); err != nil {
            return err
        }

        switch hdr.Typeflag {
        case tar.TypeReg:
            dest := hdr.Name
            if strings.HasPrefix(dest, "./") {
                // ./usr/bin/hello => /usr/bin/hello
                dest = dest[1:]
            }
            if !strings.HasPrefix(dest, "/") {
                // usr/bin/hello => /usr/bin/hello
                dest = "/" + dest
            }

            tmpdest := dest
            if p.isConffile(tmpdest) {
                // Extract using the extension .dpkg-new
                tmpdest += ".dpkg-new"
            }

            if err := os.MkdirAll(filepath.Dir(tmpdest), 0755); err != nil {
                log.Fatalf("Failed to unpack directory %s: %v", tmpdest, err)
            }

            content := buf.Bytes()
            if err := os.WriteFile(tmpdest, content, 0755); err != nil {
                log.Fatalf("Failed to unpack file %s: %v", tmpdest, err)
            }

            p.Files = append(p.Files, dest)
        }
    }

    p.SetStatus("unpacked")
    p.Sync()

    return nil
}

// Configure processes the conffiles.
func (p *PackageInfo) Configure() error {

    // The configure process consists in renaming the conffiles
    // unpacked at the previous step.
    //
    // We ignore some implementation concerns like checking if a conffile
    // has been updated using the last known checksum.

    fmt.Printf("Setting up %s (%s) ...\n", p.Name(), p.Version())

    // Rename conffiles
    for _, conffile := range p.Conffiles {
        os.Rename(conffile+".dpkg-new", conffile)
    }
    p.SetStatus("half-configured")
    p.Sync()

    // Run maintainer script
    if err := p.runMaintainerScript("postinst"); err != nil {
        return err
    }
    p.SetStatus("installed")
    p.Sync()

    return nil
}

func (p *PackageInfo) runMaintainerScript(name string) error {

    // The control.tar file can contains scripts to be run at
    // specific moments. This function uses the standard Go library
    // to run the `sh` command with a maintainer scrpit as an argument.

    if _, ok := p.MaintainerScripts[name]; !ok {
        // Nothing to run
        return nil
    }

    out, err := exec.Command("/bin/sh", p.InfoPath(name)).Output()
    if err != nil {
        return err
    }
    fmt.Print(string(out))

    return nil
}

// We have covered the different steps of the installation process.
// We still need to write the code to sync the database.

func (d *Database) Sync() error {
    newStatus := deb822.Document{
        Paragraphs: []deb822.Paragraph{},
    }

    // Sync the /var/lib/dpkg/info directory
    for _, pkg := range d.Packages {
        newStatus.Paragraphs = append(newStatus.Paragraphs, pkg.Paragraph)

        if pkg.StatusDirty {
            if err := pkg.Sync(); err != nil {
                return err
            }
        }
    }

    // Make a new version of /var/lib/dpkg/status
    os.Rename("/var/lib/dpkg/status", "/var/lib/dpkg/status-old")
    formatter := deb822.NewFormatter()
    formatter.SetFoldedFields("Description")
    formatter.SetMultilineFields("Conffiles")
    if err := os.WriteFile("/var/lib/dpkg/status",
        []byte(formatter.Format(newStatus)), 0644); err != nil {
        return err
    }

    return nil
}

func (p *PackageInfo) Sync() error {
    // This function synchronizes the files under /var/lib/dpkg/info
    // for a single package.

    // Write <package>.list
    if err := os.WriteFile(p.InfoPath("list"),
        []byte(MergeLines(p.Files)), 0644); err != nil {
        return err
    }

    // Write <package>.conffiles
    if err := os.WriteFile(p.InfoPath("conffiles"),
        []byte(MergeLines(p.Conffiles)), 0644); err != nil {
        return err
    }

    // Write <package>.{preinst,prerm,postinst,postrm}
    for name, content := range p.MaintainerScripts {
        err := os.WriteFile(p.InfoPath(name), []byte(content), 0755)
        if err != nil {
            return err
        }
    }

    p.StatusDirty = false
    return nil
}

/* Utility functions */

func ReadLines(path string) ([]string, error) {
    if _, err := os.Stat(path); !os.IsNotExist(err) {
        content, err := os.ReadFile(path)
        if err != nil {
            return nil, err
        }
        return SplitLines(string(content)), nil
    }
    return nil, nil
}

func SplitLines(content string) []string {
    var lines []string
    for _, line := range strings.Split(string(content), "\n") {
        if strings.TrimSpace(line) == "" {
            continue
        }
        lines = append(lines, line)
    }
    return lines
}

func MergeLines(lines []string) string {
    return strings.Join(lines, "\n") + "\n"
}

$ go build -o dpkg main.go
$ vagrant destroy -f # Recreate the VM
$ vagrant up         # to force a fresh installation.
vagrant$ sudo su
vagrant# /vagrant/dpkg /vagrant/hello.deb
Preparing to unpack hello.deb ...
preinst says hello
Unpacking hello (1.1-1) ...
Setting up hello (1.1-1) ...
postinst says hello

vagrant# hello
hello world

vagrant# dpkg -s hello
Package: hello
Status: install ok installed
Priority: optional
Section: base
Maintainer: Julien Sobczak
Architecture: amd64
Version: 1.1-1
Description: Say Hello

vagrant# dpkg -r hello
(Reading database ... 25063 files and directories currently installed.)
Removing hello (1.1-1) ...
prerm says hello
postrm says hello

vagrant# hello
bash: /usr/bin/hello: No such file or directory

bool DoUpdate(CommandLine &CmdL)
{
   CacheFile Cache;

   // Covered in step 1
   // Get the source list
   if (Cache.BuildSourceList() == false)
      return false;
   pkgSourceList *List = Cache.GetSourceList();

   // Covered in step 2
   // do the work
   AcqTextStatus Stat(std::cout, ScreenWidth,_config->FindI("quiet",0));
   ListUpdate(Stat, *List);

   // Covered in step 3
   // Rebuild the cache.
   pkgCacheFile::RemoveCaches();
   if (Cache.BuildCaches(false) == false)
      return false;

   // Covered in step 4
   // show basic stats (if the user whishes)
   if (_config->FindB("APT::Cmd::Show-Update-Stats", false) == true)
   {
      int upgradable = 0;
      if (Cache.Open(false) == false)
         return false;
      for (pkgCache::PkgIterator I = Cache->PkgBegin(); I.end() != true; ++I)
      {
         pkgDepCache::StateCache &state = Cache[I];
         if (I->CurrentVer != 0 && state.Upgradable() && state.CandidateVer != NULL)
            upgradable++;
      }
      const char *msg = P_(
         "%i package can be upgraded. Run 'apt list --upgradable' to see it.\n",
         "%i packages can be upgraded. Run 'apt list --upgradable' to see them.\n",
         upgradable);
      if (upgradable == 0)
         c1out << _("All packages are up to date.") << std::endl;
      else
         ioprintf(c1out, msg, upgradable);
   }

   return true;
}

// Get the source list
if (Cache.BuildSourceList() == false)
   return false;
pkgSourceList *List = Cache.GetSourceList();

class pkgSourceList
{
   public:

   typedef std::vector<metaIndex *>::const_iterator const_iterator;

   protected:

   std::vector<metaIndex *> SrcList;

   public:

   void Reset();
   bool ReadMainList();
   bool Read(std::string const &File);

   // List accessors
   inline const_iterator begin() const {return SrcList.begin();};
   inline const_iterator end() const {return SrcList.end();};
   inline unsigned int size() const {return SrcList.size();};
   inline bool empty() const {return SrcList.empty();};

   bool FindIndex(pkgCache::PkgFileIterator File,
                  pkgIndexFile *&Found) const;
   bool GetIndexes(pkgAcquire *Owner, bool GetAll=false) const;

   pkgSourceList();
   virtual ~pkgSourceList();
};

bool pkgCacheFile::BuildSourceList(OpProgress * /*Progress*/)
{
   std::unique_ptr<pkgSourceList> SrcList;
   SrcList.reset(new pkgSourceList());
   if (SrcList->ReadMainList() == false)
      return _error->Error(_("The list of sources could not be read."));
   this->SrcList = SrcList.release();
   return true;
}

bool pkgSourceList::ReadMainList()
{
   Reset();
   string Main = _config->FindFile("Dir::Etc::sourcelist", "sources.list");
   string Parts = _config->FindDir("Dir::Etc::sourceparts", "sources.list.d");

   _error->PushToStack();
   if (RealFileExists(Main) == true)
      ReadAppend(Main); (1)
   if (DirectoryExists(Parts) == true)
      ReadSourceDir(Parts); (1)

   auto good = _error->PendingError() == false;
   _error->MergeWithStack();
   return good;
}

// do the work
AcqTextStatus Stat(std::cout, ScreenWidth,_config->FindI("quiet",0)); (1)
ListUpdate(Stat, *List);

bool ListUpdate(pkgAcquireStatus &Stat,
                pkgSourceList &List,
                int PulseInterval)
{
   pkgAcquire Fetcher(&Stat); (1)
   if (Fetcher.GetLock(_config->FindDir("Dir::State::Lists")) == false) (2)
      return false;

   // Populate it with the source selection
   if (List.GetIndexes(&Fetcher) == false) (3)
         return false;

   return AcquireUpdate(Fetcher, PulseInterval, true); (4)
}

// Rebuild the cache.
pkgCacheFile::RemoveCaches();
if (Cache.BuildCaches(false) == false)
   return false;

bool pkgCacheGenerator::MakeStatusCache(pkgSourceList &List,OpProgress *Progress,
                        MMap **OutMap,pkgCache **OutCache, bool)
{
   std::vector<pkgIndexFile *> Files;
   if (_system->AddStatusFiles(Files) == false)
      return false;

   // Decide if we can write to the files..
   string const CacheFileName = _config->FindFile("Dir::Cache::pkgcache"); (1)
   string const SrcCacheFileName = _config->FindFile("Dir::Cache::srcpkgcache"); (1)

   if (Progress != NULL)
      Progress->OverallProgress(0,1,1,_("Reading package lists"));

   bool pkgcache_fine = false;
   bool srcpkgcache_fine = false;

   FileFd CacheFile;
   if (CheckValidity(CacheFile, CacheFileName, List, Files.begin(), Files.end()) (2)
   {
      pkgcache_fine = true;
      srcpkgcache_fine = true;
   }

   FileFd SrcCacheFile;
   if (pkgcache_fine == false)
   {
      if (CheckValidity(SrcCacheFile, SrcCacheFileName, List,
            Files.end(), Files.end()) == true) (2)
      {
         srcpkgcache_fine = true;
      }
   }

   if (srcpkgcache_fine == true && pkgcache_fine == true)
   {
      if (Progress != NULL)
         Progress->OverallProgress(1,1,1,_("Reading package lists"));
      return true; (3)
   }

   bool Writeable = false;
   if (srcpkgcache_fine == false || pkgcache_fine == false)
   {
      if (CacheFileName.empty() == false)
         Writeable = access(flNotFile(CacheFileName).c_str(),W_OK) == 0;
      else if (SrcCacheFileName.empty() == false)
         Writeable = access(flNotFile(SrcCacheFileName).c_str(),W_OK) == 0;
   }

   // At this point we know we need to construct something, so get storage ready
   std::unique_ptr<DynamicMMap> Map(CreateDynamicMMap(NULL, 0));

   std::unique_ptr<pkgCacheGenerator> Gen{nullptr};
   map_filesize_t CurrentSize = 0;
   map_filesize_t TotalSize = 0;

   if (srcpkgcache_fine == true && pkgcache_fine == false)
   {
      if (loadBackMMapFromFile(Gen, Map, Progress, SrcCacheFile) == false)
         return false;
      srcpkgcache_fine = true;
      TotalSize += ComputeSize(NULL, Files.begin(), Files.end());
   }
   else if (srcpkgcache_fine == false)
   {
      Gen.reset(new pkgCacheGenerator(Map.get(),Progress));
      if (Gen->Start() == false)
         return false;

      TotalSize += ComputeSize(&List, Files.begin(),Files.end());
      if (BuildCache(*Gen, Progress, CurrentSize, TotalSize, &List,
               Files.end(),Files.end()) == false)
         return false;

      if (Writeable == true && SrcCacheFileName.empty() == false)
         if (writeBackMMapToFile(Gen.get(), Map.get(), SrcCacheFileName) == false)
            return false;
   }

   if (pkgcache_fine == false)
   {
      if (BuildCache(*Gen, Progress, CurrentSize, TotalSize, NULL,
               Files.begin(), Files.end()) == false)
         return false;

      if (Writeable == true && CacheFileName.empty() == false)
         if (writeBackMMapToFile(Gen.get(), Map.get(), CacheFileName) == false)
            return false;
   }

   if (OutMap != nullptr)
      *OutMap = Map.release();

   return true;
}

class pkgCache
{
   public:

   struct Header;  // The size and count of each following properties
                   // required to jump to the index in the binary format.

   struct Group;  // Packages with the same name form a group, so we have
                  // a simple way to access a package built
                  // for different architectures.
                  // Groups are also used to iterate over all binaries
                  // produced by a source package.
   struct Package;  // A single package with all the available versions
                    // and the possible installed version.
   struct ReleaseFile;  // Release index file.
   struct PackageFile;  // Packages index file.
   struct Version;  // A single version of a package with the list of
                    // dependencies and the list of files in this package.
   struct Description;  // Translation of a single version of a package
   struct DependencyData;  // Information for a single dependency
                           // (the version, the type, ...)

   // Iterators
   class GrpIterator;
   class PkgIterator;
   class VerIterator;
   class DescIterator;
   class DepIterator;
   class RlsFileIterator;
   class PkgFileIterator;

   class Namespace;

   public:

   // Pointers to the arrays of items
   Header *HeaderP;
   Group *GrpP;
   Package *PkgP;
   DescFile *DescFileP;
   ReleaseFile *RlsFileP; // All Release files used to build the cache
   PackageFile *PkgFileP; // All Packages files used to build the cache
   Version *VerP;
   Description *DescP;
   DependencyData *DepDataP;

   // Accessors
   GrpIterator FindGrp(APT::StringView Name);
   PkgIterator FindPkg(APT::StringView Name);

   inline GrpIterator GrpBegin();
   inline GrpIterator GrpEnd();
   inline PkgIterator PkgBegin();
   inline PkgIterator PkgEnd();
   inline PkgFileIterator FileBegin();
   inline PkgFileIterator FileEnd();
   inline RlsFileIterator RlsFileBegin();
   inline RlsFileIterator RlsFileEnd();
};


struct pkgCache::Package
{
   /** \brief Architecture of the package */
   map_stringitem_t Arch;
   /** \brief List of versions sorted from highest version to lowest version */
   map_pointer<Version> VersionList;
   /** \brief index to the installed version */
   map_pointer<Version> CurrentVer;
   /** \brief index of the group this package belongs to */
   map_pointer<pkgCache::Group> Group;

   /** \brief List of all dependencies on this package */
   map_pointer<Dependency> RevDepends;
   /** \brief List of all "packages" this package provide */
   map_pointer<Provides> ProvidesList;

   // Install/Remove/Purge etc
   /** \brief state that the user wishes the package to be in */
   map_number_t SelectedState;     // What
   /** \brief installation state of the package */
   map_number_t InstState;         // Flags
   /** \brief indicates if the package is installed */
   map_number_t CurrentState;      // State
};

struct pkgCache::ReleaseFile
{
   /** \brief physical disk file that this ReleaseFile represents */
   map_stringitem_t FileName;
   map_stringitem_t Archive;
   map_stringitem_t Codename;
   map_stringitem_t Version;
   map_stringitem_t Origin;
   map_stringitem_t Label;
   /** \brief The site the index file was fetched from */
   map_stringitem_t Site;
};

struct pkgCache::PackageFile
{
   /** \brief physical disk file that this PackageFile represents */
   map_stringitem_t FileName;
   /** \brief the release information to keep record of which
    version belongs to which release e.g. for pinning. */
   map_pointer<ReleaseFile> Release;

   map_stringitem_t Component;
   map_stringitem_t Architecture;
};

struct pkgCache::Version
{
   /** \brief complete version string */
   map_stringitem_t VerStr;
   /** \brief section this version is filled in */
   map_stringitem_t Section;
   /** \brief source package name this version comes from
      Always contains the name, even if it is the same as the binary name */
   map_stringitem_t SourcePkgName;
   /** \brief source version this version comes from
      Always contains the version string, even if it is the same as the binary version */
   map_stringitem_t SourceVerStr;

   /** \brief references all the PackageFile's that this version came from

       FileList can be used to determine what distribution(s) the Version
       applies to. If FileList is 0 then this is a blank version.
       The structure should also have a 0 in all other fields excluding
       pkgCache::Version::VerStr and Possibly pkgCache::Version::NextVer. */
   map_pointer<VerFile> FileList;
   /** \brief base of the dependency list */
   map_pointer<Dependency> DependsList;
   /** \brief links to the owning package

       This allows reverse dependencies to determine the package */
   map_pointer<Package> ParentPkg;
   /** \brief list of pkgCache::Provides */
   map_pointer<Provides> ProvidesList;
};

struct pkgCache::DependencyData
{
   /** \brief string of the version the dependency is applied against */
   map_stringitem_t Version;
   /** \brief index of the package this depends applies to

       The generator will - if the package does not already exist -
       create a blank (no version records) package. */
   map_pointer<pkgCache::Package> Package;

   /** \brief Dependency type - Depends, Recommends, Conflicts, etc */
   map_number_t Type;
   /** \brief comparison operator specified on the depends line

       If the high bit is set then it is a logical OR with the previous record. */
   map_flags_t CompareOp;
};

// Other structs are omitted for brievity.

class pkgDepCache
{
   public:

   enum ModeList {ModeDelete = 0, ModeKeep = 1, ModeInstall = 2, ModeGarbage = 3};

   struct StateCache
   {
      // text versions of the two version fields
      const char *CandVersion;
      const char *CurVersion;

      // Pointer to the candidate install version.
      Version *CandidateVer;

      // Pointer to the install version.
      Version *InstallVer;

      // Various tree indicators
      signed char Status;              // -1,0,1,2
      unsigned char Mode;              // ModeList

      // Various test members for the current status of the package
      inline bool Keep() const {return Mode == ModeKeep;};
      inline bool Upgrade() const {return Status > 0 && Mode == ModeInstall;};
      inline bool Upgradable() const {return Status >= 1 && CandidateVer != NULL;};
      inline bool Downgrade() const {return Status < 0 && Mode == ModeInstall;};
      inline bool Held() const {return Status != 0 && Keep();};
      // ...
   };

   protected:

   // State information
   pkgCache *Cache;
   StateCache *PkgState;

   public:

   // Accessors
   inline StateCache &operator [](PkgIterator const &I) {return PkgState[I->ID];};
   inline StateCache &operator [](PkgIterator const &I) const {return PkgState[I->ID];};

   // read persistent states
   bool readStateFile(OpProgress * const prog);
   bool writeStateFile(OpProgress * const prog, bool const InstalledOnly=true);

   bool Init(OpProgress * const Prog);
   // Generate all state information
   void Update(OpProgress * const Prog = 0);

   pkgDepCache(pkgCache * const Cache,Policy * const Plcy = 0);
   virtual ~pkgDepCache();
};

// show basic stats (if the user whishes)
if (_config->FindB("APT::Cmd::Show-Update-Stats", false) == true)
{
   int upgradable = 0;
   if (Cache.Open(false) == false)
      return false;
   for (pkgCache::PkgIterator I = Cache->PkgBegin(); I.end() != true; ++I)
   {
      pkgDepCache::StateCache &state = Cache[I]; (1)
      if (I->CurrentVer != 0 && state.Upgradable() && state.CandidateVer != NULL) (2)
         upgradable++;
   }
   const char *msg = P_(
      "%i package can be upgraded. Run 'apt list --upgradable' to see it.\n",
      "%i packages can be upgraded. Run 'apt list --upgradable' to see them.\n",
      upgradable); (3)
   if (upgradable == 0)
      c1out << _("All packages are up to date.") << std::endl;
   else
      ioprintf(c1out, msg, upgradable);
}

bool DoList(CommandLine &Cmd)
{
   pkgCacheFile CacheFile;
   pkgCache * const Cache = CacheFile.GetPkgCache(); (1)
   pkgRecords records(CacheFile);

   std::string format = "${color:highlight}${Package}" +
      "${color:neutral}/${Origin} ${Version} " +
      "${Architecture}${ }${apt:Status}"; (2)

   std::list<pkgCache::VerIterator> bag; (3)

   GetVersionSet(CacheFile, &bag);
   std::map<std::string, std::string> output_map;
   for (std::list<pkgCache::VerIterator>::iterator V = bag.begin();
          V != bag.end(); ++V)
   {
      std::stringstream outs;
      ListSingleVersion(CacheFile, records, V, outs, format);
      output_map.insert(std::make_pair<std::string, std::string>(
               V.ParentPkg().FullName(), outs.str()));
   }

   // output the map
   std::map<std::string, std::string>::const_iterator K;
   for (K = output_map.begin(); K != output_map.end(); ++K)
      std::cout << (*K).second << std::endl;

   return true;
}

bool GetVersionSet(pkgCacheFile &CacheFile,
                   std::list<pkgCache::VerIterator> versions)
{
   pkgCache * const Cache = CacheFile.GetPkgCache();
   pkgDepCache * const DepCache = CacheFile.GetDepCache();

   bool const insertCurrentVer = _config->FindB("APT::Cmd::Installed", false);
   bool const insertUpgradable = _config->FindB("APT::Cmd::Upgradable", false);

   for (pkgCache::PkgIterator P = Cache->PkgBegin(); P.end() == false; ++P)
   {
      pkgDepCache::StateCache &state = (*DepCache)[P];
      if (insertCurrentVer == true) (1)
      {
         if (P->CurrentVer != 0)
            versions->insert(P.CurrentVer());
      }
      else if (insertUpgradable == true) (2)
      {
         if (P.CurrentVer() && state.Upgradable())
            versions->insert(CacheFile.GetPolicy()->GetCandidateVer(P));
      }
      else (3)
      {
         versions->insert(P.VersionList());
      }
   }
   if (progress != NULL)
      progress->Done();
   return true;
}

void ListSingleVersion(pkgCacheFile &CacheFile, pkgRecords &records,        /*{{{*/
                       pkgCache::VerIterator const &V, std::ostream &out,
                       std::string const &format)
{
   pkgCache::PkgIterator const P = V.ParentPkg();
   pkgDepCache * const DepCache = CacheFile.GetDepCache();
   pkgDepCache::StateCache const &state = (*DepCache)[P];

   std::string output = format; (1)

   output = SubstVar(output, "${db::Status-Abbrev}",
                     GetFlagsStr(CacheFile, P));
   output = SubstVar(output, "${Package}", P.Name());
   std::string const ArchStr = GetArchitecture(CacheFile, P);
   output = SubstVar(output, "${Architecture}", ArchStr);
   std::string const InstalledVerStr = GetInstalledVersion(CacheFile, P);
   output = SubstVar(output, "${installed:Version}", InstalledVerStr);
   std::string const CandidateVerStr = GetCandidateVersion(CacheFile, P);
   output = SubstVar(output, "${candidate:Version}", CandidateVerStr);
   std::string const VersionStr = GetVersion(CacheFile, V);
   output = SubstVar(output, "${Version}", VersionStr);
   output = SubstVar(output, "${Origin}", GetArchiveSuite(CacheFile, V));

   std::string StatusStr = ""; (2)
   if (P->CurrentVer != 0)
   {
      if (P.CurrentVer() == V)
      {
         if (state.Upgradable() && state.CandidateVer != NULL)
            strprintf(StatusStr, _("[installed,upgradable to: %s]"),
                  CandidateVerStr.c_str());
         else if (V.Downloadable() == false)
            StatusStr = _("[installed,local]");
         else if(V.Automatic() == true && state.Garbage == true)
            StatusStr = _("[installed,auto-removable]");
         else if ((state.Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
            StatusStr = _("[installed,automatic]");
         else
            StatusStr = _("[installed]");
      }
      else if (state.CandidateVer == V && state.Upgradable())
         strprintf(StatusStr, _("[upgradable from: %s]"),
               InstalledVerStr.c_str());
   }
   else if (V.ParentPkg()->CurrentState == pkgCache::State::ConfigFiles)
      StatusStr = _("[residual-config]");
   output = SubstVar(output, "${apt:Status}", StatusStr);
   output = SubstVar(output, "${color:highlight}",
                     _config->Find("APT::Color::Highlight", ""));
   output = SubstVar(output, "${color:neutral}",
                     _config->Find("APT::Color::Neutral", ""));
   output = SubstVar(output, "${Description}",
                     GetShortDescription(CacheFile, records, P));
   output = SubstVar(output, "${LongDescription}",
                     GetLongDescription(CacheFile, records, P));
   output = SubstVar(output, "${ }${ }", "${ }"); (3)
   output = SubstVar(output, "${ }\n", "\n"); (3)
   output = SubstVar(output, "${ }", " "); (3)

   out << output;
}

bool DoInstall(CommandLine &CmdL)
{
   CacheFile Cache;

   // Covered in step 1
   if (Cache.OpenForInstall() == false)
      return false;

   std::set<pkgCache::VerIterator> verset;

   // Covered in step 2
   if (!DoCacheManipulationFromCommandLine(CmdL, Cache, verset))
   {
      return false;
   }

   // Covered in step 3
   /* Print out a list of packages that are going to be installed extra
      to what the user asked */
   if (Cache->InstCount() != verset.size()) (1)
      std::list<pkgCache::PkgIterator> extras;
      for (pkgCache::PkgIterator I = Cache->PkgBegin(); I.end() != true; ++I)
      {
        if ((*Cache)[Pkg].Install() == false)
           continue;
        pkgCache::VerIterator const Cand =
          (*Cache)[Pkg].CandidateVerIter(*Cache);
        if (verset->find(Cand) == verset->end())
        {
           extra.insert(Pkg);
        }
      }
      ShowList(_("The following additional packages will be installed:"),
               extras);

   /* Print out a list of suggested and recommended packages */
   {
      std::list<std::string> Recommends, Suggests, SingleRecommends, SingleSuggests;
      for (auto const &Pkg: pkgCache::PkgIterator(*Cache))
      {
         /* Just look at the ones we want to install */
         if ((*Cache)[Pkg].Install() == false)
           continue;

         // get the recommends/suggests for the candidate ver
         pkgCache::VerIterator CV = (*Cache)[Pkg].CandidateVerIter(*Cache);
         for (pkgCache::DepIterator D = CV.DependsList(); D.end() == false; )
         {
            pkgCache::DepIterator Start;
            pkgCache::DepIterator End;
            D.GlobOr(Start, End); // advances D
            if (Start->Type != pkgCache::Dep::Recommends &&
                Start->Type != pkgCache::Dep::Suggests)
               continue;

            std::string target;
            for (pkgCache::DepIterator I = Start; I != D; ++I)
            {
               if (target.empty() == false)
                  target.append(" | ");
               target.append(I.TargetPkg().FullName(true));
            }
            std::list<std::string> &Type =
                Start->Type == pkgCache::Dep::Recommends ?
                  Recommends :
                  Suggests;
            if (std::find(Type.begin(), Type.end(), target) != Type.end())
               continue;
            Type.push_back(target);
         }

      }
      ShowList(_("Suggested packages:"), Suggests);
      ShowList(_("Recommended packages:"), Recommends);
   }

   bool result;

   // Covered in step 4
   result = InstallPackages(Cache, false);

   return result;
}

bool pkgCacheFile::Open(OpProgress *Progress)
{
   if (BuildCaches(Progress) == false)
      return false;

   if (BuildPolicy(Progress) == false)
      return false;

   if (BuildDepCache(Progress) == false)
      return false;

   if (Progress != NULL)
      Progress->Done();
   if (_error->PendingError() == true)
      return false;

   return true;
}

Package: nginx-core
Description: nginx web/proxy server (standard version)
Version: 1.18.0-6+b1
Architecture: amd64
Replaces: nginx-full (<< 1.18.0-1)
Depends: libnginx-mod-http-geoip (= 1.18.0-6+b1), nginx-common (= 1.18.0-6),
  iproute2, libc6 (>= 2.28), libcrypt1 (>= 1:4.1.0), libpcre3,
  libssl1.1 (>= 1.1.1), zlib1g (>= 1:1.1.4)
Suggests: nginx-doc (= 1.18.0-6)
Conflicts: nginx-extras, nginx-light
Breaks: nginx (<< 1.4.5-1), nginx-full (<< 1.18.0-1)

bool DoCacheManipulationFromCommandLine(CommandLine &CmdL, CacheFile &Cache,
                                        std::set<APT::VersionSet> &verset)
{
   std::unique_ptr<pkgProblemResolver> Fix(nullptr);
   Fix.reset(new pkgProblemResolver(Cache));

   for (const char **I = CmdL.FileList + 1; *I != 0; ++I) { (1)
      pkgCache::GrpIterator Grp = Cache.GetPkgCache()->FindGrp(pkg);
      verset.insert(Grp.FindPreferredPkg())
   }

   TryToInstall InstallAction(Cache, Fix.get());

   for (unsigned short i = 0; order[i] != 0; ++i)
   {
      InstallAction = std::for_each(verset.begin(), verset.end(), InstallAction); (2)
   }

   // Call the scored problem resolver
   OpTextProgress Progress(*_config);
   bool resolver_fail = Fix->Resolve(true, &Progress); (3)

   if (resolver_fail == false)
      return false;

   return true;
}

...
Package: ngraph-gtk
Version: 6.09.01-1
Maintainer: Hiroyuki Ito <ZXB01226@nifty.com>
Architecture: amd64
Depends: libc6 (>= 2.4), libngraph0 (>= 6.07.02)
Recommends: ngraph-gtk-addins, ngraph-gtk-doc
Suggests: fonts-liberation
Description: create scientific 2-dimensional graphs
...

vagrant# apt install ngraph-gtk
Reading package lists... Done
Building dependency tree... Done
Reading state information... Done
The following additional packages will be installed:
  adwaita-icon-theme at-spi2-core dbus-user-session dconf-gsettings-backend
  dconf-service fontconfig fontconfig-config fonts-dejavu-core glib-networking
  glib-networking-common glib-networking-services gsettings-desktop-schemas
  gtk-update-icon-cache hicolor-icon-theme libatk-bridge2.0-0 libatk1.0-0
  libatk1.0-data libatspi2.0-0 libavahi-client3 libavahi-common-data
  libavahi-common3 libcairo-gobject2 libcairo2 libcolord2 libcups2
  libdatrie1 libdconf1 libdeflate0 libepoxy0 libfontconfig1 libfribidi0
  libgdk-pixbuf-2.0-0 libgdk-pixbuf-xlib-2.0-0 libgdk-pixbuf2.0-0
  libgdk-pixbuf2.0-bin libgdk-pixbuf2.0-common libgraphite2-3 libgsl25
  libgslcblas0 libgtk-3-0 libgtk-3-bin libgtk-3-common libgtksourceview-4-0
  libgtksourceview-4-common libharfbuzz0b libjbig0 libjpeg62-turbo
  libjson-glib-1.0-0 libjson-glib-1.0-common liblcms2-2 libngraph0
  libpango-1.0-0 libpangocairo-1.0-0 libpangoft2-1.0-0 libpixman-1-0
  libproxy1v5 librest-0.7-0 librsvg2-2 librsvg2-common libsoup-gnome2.4-1
  libsoup2.4-1 libthai-data libthai0 libtiff5 libwayland-client0
  libwayland-cursor0 libwayland-egl1 libwebp6 libx11-6 libx11-data libxau6
  libxcb-render0 libxcb-shm0 libxcb1 libxcomposite1 libxcursor1 libxdamage1
  libxdmcp6 libxext6 libxfixes3 libxi6 libxinerama1 libxkbcommon0 libxrandr2
  libxrender1 libxtst6 ngraph-gtk-addins ngraph-gtk-addins-base
  ngraph-gtk-doc shared-mime-info x11-common xkb-data
Suggested packages:
  colord cups-common gsl-ref-psdoc | gsl-doc-pdf | gsl-doc-info |
  gsl-ref-html gvfs liblcms2-utils fonts-liberation librsvg2-bin
The following NEW packages will be installed:
  adwaita-icon-theme at-spi2-core dbus-user-session dconf-gsettings-backend
  dconf-service fontconfig fontconfig-config fonts-dejavu-core glib-networking
  glib-networking-common glib-networking-services gsettings-desktop-schemas
  gtk-update-icon-cache hicolor-icon-theme libatk-bridge2.0-0 libatk1.0-0
  libatk1.0-data libatspi2.0-0 libavahi-client3 libavahi-common-data
  libavahi-common3 libcairo-gobject2 libcairo2 libcolord2 libcups2 libdatrie1
  libdconf1 libdeflate0 libepoxy0 libfontconfig1 libfribidi0
  libgdk-pixbuf-2.0-0 libgdk-pixbuf-xlib-2.0-0 libgdk-pixbuf2.0-0
  libgdk-pixbuf2.0-bin libgdk-pixbuf2.0-common libgraphite2-3 libgsl25
  libgslcblas0 libgtk-3-0 libgtk-3-bin libgtk-3-common libgtksourceview-4-0
  libgtksourceview-4-common libharfbuzz0b libjbig0 libjpeg62-turbo
  libjson-glib-1.0-0 libjson-glib-1.0-common liblcms2-2 libngraph0
  libpango-1.0-0 libpangocairo-1.0-0 libpangoft2-1.0-0 libpixman-1-0
  libproxy1v5 librest-0.7-0 librsvg2-2 librsvg2-common libsoup-gnome2.4-1
  libsoup2.4-1 libthai-data libthai0 libtiff5 libwayland-client0
  libwayland-cursor0 libwayland-egl1 libwebp6 libx11-6 libx11-data libxau6
  libxcb-render0 libxcb-shm0 libxcb1 libxcomposite1 libxcursor1 libxdamage1
  libxdmcp6 libxext6 libxfixes3 libxi6 libxinerama1 libxkbcommon0 libxrandr2
  libxrender1 libxtst6 ngraph-gtk ngraph-gtk-addins ngraph-gtk-addins-base
  ngraph-gtk-doc shared-mime-info x11-common xkb-data
0 upgraded, 93 newly installed, 0 to remove and 11 not upgraded.
Need to get 38.5 MB of archives.
After this operation, 137 MB of additional disk space will be used.
Do you want to continue? [Y/n]

bool InstallPackages(CacheFile &Cache, bool ShwKept, bool Ask)
{
   // Create the download object
   aptAcquireWithTextStatus Fetcher;
   if (Fetcher.GetLock(_config->FindDir("Dir::Cache::Archives")) == false) (1)
      return false;

   // Read the source list
   if (Cache.BuildSourceList() == false)
      return false;
   pkgSourceList * const List = Cache.GetSourceList();

   // Create the text record parser
   pkgRecords Recs(Cache);
   if (_error->PendingError() == true)
      return false;

   // Create the package manager and prepare to download
   std::unique_ptr<pkgPackageManager> PM(_system->CreatePM(Cache)); (2)
   if (PM->GetArchives(&Fetcher, List, &Recs) == false ||
       _error->PendingError() == true)
      return false;

   auto const FetchBytes = Fetcher.FetchNeeded(); (3)
   auto const FetchPBytes = Fetcher.PartialPresent(); (3)

   // Size delta
   ioprintf(c1out,_("After this operation, %sB of additional disk space " +
                    "will be used.\n"),
            SizeToStr(Cache->UsrSize()).c_str());

   if (_error->PendingError() == true)
      return false;

   // Prompt to continue
   if (Ask == true || Fail == true) (4)
   {
      if (_config->FindI("quiet", 0) < 2 &&
            _config->FindB("APT::Get::Assume-Yes", false) == false)
      {
         if (YnPrompt(_("Do you want to continue?")) == false)
         {
            cout << _("Abort.") << std::endl;
            exit(1);
         }
      }
   }

   // Run it
   bool Failed = false;
   while (1)
   {
      bool Transient = false;
      if (AcquireRun(Fetcher, 0, &Failed, &Transient) == false)
         return false;

      if (Failed == true && _config->FindB("APT::Get::Fix-Missing",false) == false)
         return _error->Error(_("Unable to fetch some archives, " +
           "maybe run apt-get update or try with --fix-missing?"));

      auto const progress = APT::Progress::PackageManagerProgressFactory();
      _system->UnLockInner(); (5)
      pkgPackageManager::OrderResult const Res = PM->DoInstall(progress);
      delete progress;

      if (Res == pkgPackageManager::Failed || _error->PendingError() == true)
         return false;
      if (Res == pkgPackageManager::Completed)
         break;

      _system->LockInner();

      Fetcher.Shutdown();
      if (PM->GetArchives(&Fetcher, List, &Recs) == false)
         return false;

      Failed = false;
   }

   std::set<std::string> const disappearedPkgs = PM->GetDisappearedPackages();
   if (disappearedPkgs.empty() == false) (6)
   {
      ShowList(c1out, P_("The following package disappeared from your system as\n"
               "all files have been overwritten by other packages:",
               "The following packages disappeared from your system as\n"
               "all files have been overwritten by other packages:",
               disappearedPkgs.size()), disappearedPkgs,
            [](std::string const &Pkg) { return Pkg.empty() == false; },
            [](std::string const &Pkg) { return Pkg; },
            [](std::string const &) { return std::string(); });
      cout << _("Note: This is done automatically and on purpose by dpkg.") << std::endl;
   }

   return true;
}

class pkgDPkgPM : public pkgPackageManager
{
   protected:

   // 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; (1)

   virtual bool Install(PkgIterator Pkg,std::string File) override; (2)
   virtual bool Configure(PkgIterator Pkg) override;
   virtual bool Remove(PkgIterator Pkg,bool Purge = false) override;

   virtual bool Go(APT::Progress::PackageManager *progress) override; (3)

   virtual void Reset() override;

   public:

   explicit pkgDPkgPM(pkgDepCache *Cache);
   virtual ~pkgDPkgPM();

   APT_HIDDEN static bool ExpandPendingCalls(std::vector<Item> &List, pkgDepCache &Cache);
};

bool pkgDPkgPM::Go(APT::Progress::PackageManager *progress)
{
   ...

   // Generate the base argument list for dpkg
   std::vector<const char *> Args = { "dpkg" };

   // this loop is runs once per dpkg operation
   vector<Item>::const_iterator I = List.cbegin();
   while (I != List.end())
   {

      int fd[2];
      if (pipe(fd) != 0)
         return _error->Errno("pipe","Failed to create IPC pipe to dpkg");

      ADDARGC("--status-fd");
      char status_fd_buf[20];
      snprintf(status_fd_buf,sizeof(status_fd_buf),"%i", fd[1]);
      ADDARG(status_fd_buf);
      unsigned long const Op = I->Op;

      switch (I->Op)
      {
         // Skip other operations

         case Item::Install:
         ADDARGC("--unpack");
         ADDARGC("--auto-deconfigure");
         break;
      }

      // Write in the file or package name
      if (I->Op == Item::Install)
      {
         if (I->File[0] != '/')
               return _error->Error("Internal Error, " +
               "Pathname to install is not absolute '%s'", I->File.c_str());
            Args.push_back(I->File.c_str());
      }

      pid_t Child = ExecFork(fd[1]); (1)
      if (Child == 0)
      {
         // This is the child
         close(fd[0]); // close the read end of the pipe

         debSystem::DpkgChrootDirectory();

         if (chdir(_config->FindDir("DPkg::Run-Directory","/").c_str()) != 0)
            _exit(100);

         execvp(Args[0], (char**) &Args[0]); (1)
         cerr << "Could not exec dpkg!" << endl;
         _exit(100);
      }

      // we read from dpkg here
      int const _dpkgin = fd[0];
      close(fd[1]); // close the write end of the pipe

      // the result of the waitpid call
      int Status = 0;
      int res;
      bool waitpid_failure = false;
      bool dpkg_finished = false;
      do
      {
         if (dpkg_finished == false)
         {
            if ((res = waitpid(Child, &Status, WNOHANG)) == Child) (1)
               dpkg_finished = true;
            else if (res < 0)
            {
               // error handling, waitpid returned -1
               if (errno == EINTR)
                  continue;
               waitpid_failure = true;
               break;
            }
         }
         if (dpkg_finished)
            break;

      } while (true);

      if (waitpid_failure == true)
      {
         strprintf(d->dpkg_error, "Sub-process %s couldn't be waited for.",
                   Args[0]);
         _error->Error("%s", d->dpkg_error.c_str());
         break;
      }

      ...
   }
}

vagrant# tree /vagrant/hello/3.1-1/
3.1-1/
|-- DEBIAN
|   `-- control
`-- usr
    `-- bin
        `-- hello

vagrant# cat /vagrant/hello/3.1-1/DEBIAN/control
Package: hello
Version: 3.1-1
Section: base
Priority: optional
Architecture: amd64
Maintainer: Julien Sobczak
Description: Say Hello
Depends: cowsay (1)

vagrant# cat /vagrant/hello/3.1-1/usr/bin/hello
#!/bin/bash
echo "hello world" | /usr/games/cowsay (2)

vagrant# $ dpkg --build 3.1-1 hello_3.1-1_amd64.deb (1)

vagrant# apt install /vagrant/hello/hello_3.1-1_amd64.deb
Reading package lists... Done
Building dependency tree... Done
Reading state information... Done
The following additional packages will be installed:
  cowsay
Suggested packages:
  filters cowsay-off
The following NEW packages will be installed:
  cowsay hello
0 upgraded, 2 newly installed, 0 to remove and 11 not upgraded.
After this operation, 94.2 kB of additional disk space will be used.
Do you want to continue? [Y/n] Y

Get:1 /vagrant/hello/hello_3.1-1_amd64.deb hello amd64 3.1-1 [20.7 kB]
Get:2 http://deb.debian.org/debian bullseye/main amd64 cowsay all 3.03+dfsg2-8 [21.4 kB]
Fetched 21.4 kB in 0s (66.6 kB/s)
Selecting previously unselected package cowsay.
(Reading database ... 34384 files and directories currently installed.)
Preparing to unpack .../cowsay_3.03+dfsg2-8_all.deb ...
Unpacking cowsay (3.03+dfsg2-8) ...
Selecting previously unselected package hello.
Preparing to unpack .../hello/hello_3.1-1_amd64.deb ...
preinst says hello
Unpacking hello (3.1-1) ...
Setting up cowsay (3.03+dfsg2-8) ...
Setting up hello (3.1-1) ...
postinst says hello
Processing triggers for man-db (2.9.4-2) ...

vagrant# hello
 _____________
< hello world >
 -------------
        \   ^__^
         \  (oo)\_______
            (__)\       )\/\
                ||----w |
                ||     ||

package main

import (
    "bufio"
    "bytes"
    "crypto/md5"
    "crypto/sha256"
    "fmt"
    "io"
    "io/ioutil"
    "net/http"
    "os"
    "os/exec"
    "path/filepath"
    "regexp"
    "strings"
    "sync"

    "github.com/julien-sobczak/deb822"
    "github.com/ulikunitz/xz"
    "golang.org/x/crypto/openpgp"
    "golang.org/x/crypto/openpgp/clearsign"
)

// The command `apt install` requires more code
// than our previous implementation of the command `dpkg`.
// We will introduce the different components successively.

///////////////////////////////////////////////////////////

//
// The Acquire subsystem
//

// Apt accepts package names and needs to retrieve their archives
// from repositories, commonly using HTTP.
// The pkgAcquire struct downloads the various required files
// using a pool of worker to process each item to download.
// Like the real implementation, this system is not a generic downloader
// but contains some Apt logic.

type pkgAcquire struct {
    // The downloaded items are used to populate the Apt cache
    cacheFile *CacheFile

    // The items still not finished.
    pendingJobs int
    jobs        chan Item
    results     chan error
    // Workers are run in goroutines and push new items.
    jobsMutex sync.Mutex
}

// There are different types of files to retrieve from an Apt repository:
// - `InRelease`: the metadata about the repository.
// - `Packages`: the list of packages present in the repository.
// - `.deb` files: the archives to install using `dpkg`.
// Each item is accessible from an URI, must be stored locally, and required
// some postprocessing like checking the integrity of the files to prevent
// MITM attacks.

type Item interface {
    // DownloadURI returns the URI to retrieve the item.
    DownloadURI() string

    // DestFile returns the path where the file
    // represented by the URI must be written.
    DestFile(uri string) string

    // Done is called when the file has been downloaded.
    // This function updates the cache with the retrieved item
    // and can trigger new downloads.
    Done(c *CacheFile, a *pkgAcquire) error
}

// We will detail each type after the implementation of pkgAcquire.

// NewPkgAcquire initializes the Acquire system.
func NewPkgAcquire(c *CacheFile) *pkgAcquire {
    a := &pkgAcquire{
        cacheFile:   c,
        pendingJobs: 0,
        jobs:        make(chan Item, 1000),
        results:     make(chan error, 1000),
    }

    // Start the workers responsible to process the items in `jobs`.
    for w := 1; w <= 2; w++ {
        go a.worker(w, a.jobs, a.results)
    }

    return a
}

// Add is used to request the downloading of a new item.
// New items are simply send to the `jobs` channel.
func (a *pkgAcquire) Add(item Item) {
    // The function is called from different goroutines.
    // We use a lock to prevent data inconsistencies.
    a.jobsMutex.Lock()
    a.jobs <- item
    a.pendingJobs++
    a.jobsMutex.Unlock()
}

// A worker simply reads from the `jobs` channel and uses the different
// methods defined by `Item` to know what to do.

func (a *pkgAcquire) worker(id int, jobs <-chan Item, results chan<- error) {
    for item := range jobs {
        results <- a.downloadItem(item)
    }
}

func (a *pkgAcquire) downloadItem(item Item) error {
    uri := item.DownloadURI()
    dest := item.DestFile(uri)

    // Download the file
    resp, err := http.Get(uri)
    if err != nil {
        fmt.Printf("Err: %v\n\t%s\n", item, err)
        return err
    }
    defer resp.Body.Close()

    // Create the local file
    os.MkdirAll(filepath.Dir(dest), 0755)

    out, err := os.Create(dest)
    if err != nil {
        return err
    }
    defer out.Close()

    // Copy the body to the local file
    io.Copy(out, resp.Body)

    fmt.Printf("Get: %v\n", item)

    return item.Done(a.cacheFile, a)
}

// There is one remaining method to cover.
// The Acquire system will try to download items in parallel
// but the code often need to block until all items have been downloaded
// to continue. The next function is used to wait.

/**
 * Run downloads all items that have been added to this
 * download process.
 *
 * This method will block until the download completes.
 */
func (a *pkgAcquire) Run() error {
    var errors []string
    var err error

    for {
        // Exit when there are no more remaining jobs
        a.jobsMutex.Lock()
        if a.pendingJobs == 0 {
            a.jobsMutex.Unlock()
            break
        }
        a.jobsMutex.Unlock()

        // Search for errors in the results
        err = <-a.results
        if err != nil {
            errors = append(errors, err.Error())
        }

        a.jobsMutex.Lock()
        a.pendingJobs--
        a.jobsMutex.Unlock()
    }

    if len(errors) > 0 {
        return fmt.Errorf(strings.Join(errors, "\n"))
    }

    return nil
}

// That's all for the Acquire system. What remains is the implementation
// of the various types of Item.

///////////////////////////////////////////////////////////

/*
 * The first kind of `Item` we have to download are `InRelease` files.
 * These files contain metadata about other index files (ex: `Packages`)
 * present in the same repository and are used to check the integrity
 * of these files.
 */

type MetaIndexItem struct { // InRelease/Release files
    // The Debian source pointing to this repository.
    // The source contains fields required to determine the target URI.
    source *pkgSource
}

func NewMetaIndexItem(source *pkgSource) *MetaIndexItem {
    return &MetaIndexItem{
        source: source,
    }
}

func (i *MetaIndexItem) DownloadURI() string {
    // Ex: http://deb.debian.org/debian/dists/buster/InRelease
    return i.source.URI + "/dists/" + i.source.Dist + "/InRelease"
}

func (i *MetaIndexItem) DestFile(uri string) string {
    // Ex: /var/lib/apt/lists/deb.debian.org_debian_dists_buster_InRelease
    s := i.source
    return "/var/lib/apt/lists/" +
        fmt.Sprintf("%s.%s_InRelease", s.EscapedURI(), s.Dist)
}

func (i *MetaIndexItem) Done(c *CacheFile, acq *pkgAcquire) error {
    s := i.source

    filePath := i.DestFile(s.URI)

    // 1. Check the file integrity

    // Apt loads all GPG keys under /etc/apt/trusted.gpg.d/.
    // Here, for simplicity, we load only the single key we really need:
    // /etc/apt/trusted.gpg.d/debian-archive-buster-stable.gpg
    publicKey := fmt.Sprintf(
        "/etc/apt/trusted.gpg.d/debian-archive-%s-stable.gpg", s.Dist)
    decodedContent, err := gpgDecode(filePath, publicKey)
    if err != nil {
        return fmt.Errorf("the following signature couldn't be verified %s\n%v",
            filePath, err)
    }

    // 2. Parse the content to extract metadata like the checksums
    // for other files to download
    parser, err := deb822.NewParser(strings.NewReader(string(decodedContent)))
    if err != nil {
        return fmt.Errorf("malformed Release file: %v", err)
    }
    doc, err := parser.Parse()
    if err != nil {
        return fmt.Errorf("malformed Release file: %v", err)
    }

    // Extract values
    s.doc = doc.Paragraphs[0]
    s.Codename = s.doc.Value("Codename") // Ex: buster
    s.Suite = s.doc.Value("Suite")       // Ex: stable
    s.Origin = s.doc.Value("Origin")     // Ex: Debian
    s.Label = s.doc.Value("Label")       // Ex: Debian
    s.Entries = make(map[string]string)
    for _, entry := range strings.Split(s.doc.Value("MD5Sum"), "\n") {
        // Ex: 0233ae8f041ca0f1aa5a7f395d326e80    57365 contrib/Contents-all.gz
        fields := regexp.MustCompile(`\s+`).Split(entry, -1)
        relativePath := strings.TrimSpace(fields[2])
        md5sum := fields[0]
        s.Entries[relativePath] = md5sum
    }

    // 3. Download the `Packages` files
    acq.Add(NewIndexItem(s, "main", "amd64"))
    // The real code download other Packages files in addition
    // like the ones for the `contrib` and `non-free` components.

    return nil
}
func (i MetaIndexItem) String() string {
    // Ex: https://packages.grafana.com/oss/deb stable InRelease
    return fmt.Sprintf("%s stable InRelease", i.source.URI)
}

///////////////////////////////////////////////////////////

/*
 * The second kind of Item we have to download are index files
 * (Packages and Sources files).
 * In this implementation, we are ignoring Sources index files.
 * Packages index files list the Debian control files (DEBIAN/control)
 * with a few additional fields for every .deb package available.
 */

type IndexItem struct { // `Packages`/`Sources` files
    source       *pkgSource
    component    string // Ex: main, free or non-free
    architecture string // Ex: amd64

}

func NewIndexItem(source *pkgSource,
    component string, architecture string) *IndexItem {
    return &IndexItem{
        source:       source,
        component:    component,
        architecture: architecture,
    }
}

func (i *IndexItem) DownloadURI() string {
    // Ex: http://deb.debian.org/debian/dists/buster/main/binary-all/Packages.xz
    return i.source.URI + "/dists/" + i.source.Dist + "/" + i.component +
        "/binary-" + i.architecture + "/Packages.xz"
}

func (i *IndexItem) DestFile(uri string) string {
    // Ex: /var/lib/apt/lists/
    //       deb.debian.org_debian_dists_buster_main_binary-amd64_Packages.xz
    s := i.source
    return "/var/lib/apt/lists/" + fmt.Sprintf("%s.%s_%s_binary-%s_Packages.xz",
        s.EscapedURI(), s.Dist, i.component, i.architecture)
}

func (i *IndexItem) Done(c *CacheFile, a *pkgAcquire) error {
    s := i.source
    path := i.DestFile(s.URI)

    // 1. Read the file
    file, err := os.Open(path)
    if err != nil {
        return fmt.Errorf("missing file: %v", err)
    }
    defer file.Close()

    b, err := ioutil.ReadAll(file)
    if err != nil {
        return fmt.Errorf("unable to open file %s: %v", path, err)
    }

    // 2. Check integrity
    hash := md5.New()
    if _, err := io.Copy(hash, bytes.NewReader(b)); err != nil {
        return fmt.Errorf("unable to determine MD5 sum: %s", err)
    }
    md5sum := fmt.Sprintf("%x", hash.Sum(nil))
    md5sumRef := s.Entries[i.EntryName()]
    if md5sum != md5sumRef {
        return fmt.Errorf("found MD5 mismatch: %v != %v", md5sum, md5sumRef)
    }

    // 3. Extract content
    r, err := xz.NewReader(bytes.NewReader(b))
    if err != nil {
        return fmt.Errorf("unable to open xz file: %v", err)
    }
    content, err := io.ReadAll(r)
    if err != nil {
        return fmt.Errorf("unable to read index file content: %v", err)
    }

    // 4. Parse content
    parser, err := deb822.NewParser(strings.NewReader(string(content)))
    if err != nil {
        return fmt.Errorf("malformed index file: %v", err)
    }
    doc, err := parser.Parse()
    if err != nil {
        return fmt.Errorf("malformed index file: %v", err)
    }

    // 5. Add the package into the Apt cache.
    for _, paragraph := range doc.Paragraphs {
        c.AddPackage(&Package{
            doc:    paragraph,
            source: s,
        })
    }

    return nil
}

// EntryName returns the key in MD5Sum for this file in the Release file.
func (i IndexItem) EntryName() string {
    // Ex: main/binary-am64/Packages
    return fmt.Sprintf("%s/binary-%s/Packages.xz", i.component, i.architecture)
}

func (i IndexItem) String() string {
    // Ex: https://packages.grafana.com/oss/deb stable/main amd64 Packages
    return fmt.Sprintf("%s stable/%s %s Packages",
        i.source.URI, i.component, i.architecture)
}

///////////////////////////////////////////////////////////

/*
 * The last kind of Item we have to download are .deb archives that will
 * be passed to the dpkg command to proceed to the installation.
 * These files are downloaded under /var/cache/apt/archives/.
 */

type PackageItem struct { // `.deb` files
    // The package metadata associated with the archive to download.
    pkg *Package
}

func NewPackageItem(pkg *Package) *PackageItem {
    return &PackageItem{
        pkg: pkg,
    }
}

func (i *PackageItem) DownloadURI() string {
    // Ex: http://deb.debian.org/debian/pool/main/r/rsync/rsync_3.2.3_amd64.deb
    return i.pkg.source.URI + "/" + i.pkg.doc.Value("Filename")
}

func (i *PackageItem) DestFile(uri string) string {
    // Ex: /var/cache/apt/archives/rsync_3.2.3-4_amd64.deb
    pkg := i.pkg
    pkg.cacheFilepath = "/var/cache/apt/archives/" + filepath.Base(uri)
    return pkg.cacheFilepath
}

func (i *PackageItem) Done(c *CacheFile, a *pkgAcquire) error {
    // 1. Check file integrity
    f, err := os.Open(i.pkg.cacheFilepath)
    if err != nil {
        return err
    }
    defer f.Close()

    h := sha256.New()
    if _, err := io.Copy(h, f); err != nil {
        return err
    }

    indexChecksum := i.pkg.doc.Value("SHA256")
    effectiveChecksum := fmt.Sprintf("%x", h.Sum(nil))

    if indexChecksum != effectiveChecksum {
        return fmt.Errorf("invalid checksum for %s", i.pkg.cacheFilepath)
    }

    // 2. Nothing more to do.
    // The archive will be processed later when delegating to the `dpkg` command.

    return nil
}

func (i PackageItem) String() string {
    // Ex: https://grafana.com/oss/deb stable/main amd64 grafana amd64 7.5.5
    pkg := i.pkg
    return fmt.Sprintf("%s stable/main %s %s %s", pkg.source.URI,
        pkg.Name(), pkg.Architecture(), pkg.Version())
}

///////////////////////////////////////////////////////////

//
// The Apt Cache
//

// We try to using the same naming as for the real implementation
// using similar structs but containing only the main fields.

// CacheFile is the high-level component for the Apt cache.
type CacheFile struct {
    cache    *pkgCache
    depCache *pkgDepCache
    sources  []*pkgSource
}

// pkgCache contains all known packages
// (found in Dpkg database and in repositories)
type pkgCache struct {
    packages map[string]*Package // The key is the package name
}

// pkgDepCache contains the state information for every package
// (installed, to install, upgradable, ...).
type pkgDepCache struct {
    states map[string]*StateCache
    // The ordered list of packages waiting to be installed.
    order []string
}

// pkgSource represents a single line in a source.list file.
type pkgSource struct {
    doc deb822.Paragraph // `Release` file content

    // parsed from the sources.list file
    Type string
    URI  string
    Dist string

    // parsed from the Packages file
    Codename string
    Suite    string
    Origin   string
    Label    string
    Entries  map[string]string // Checksums of all repository files
}

// EscapedURI returns a name based on the URI that can be used in filename.
// Indeed, most retrieved files are stored under /var/lib/apt/
// and are named after their source.
func (s *pkgSource) EscapedURI() string {
    return strings.ReplaceAll(strings.TrimPrefix(s.URI, "http://"), "/", "_")
}

// The core of the Apt cache is the list of packages.

// Package is a Debian package.
type Package struct {
    // The metadata as present in `Packages` or `status` file
    doc deb822.Paragraph
    // The source where this package is coming from.
    // Can be undefined for already installed packages.
    source *pkgSource

    // The path under /var/cache/apt/packages.
    // Initialized after the download of the package.
    cacheFilepath string
}

// We expose a few additional methods to extract attributes
// from the underlying DEB822 document.

func (p *Package) Name() string {
    return p.doc.Value("Package")
}

func (p *Package) Version() string {
    return p.doc.Value("Version")
}

func (p *Package) Architecture() string {
    return p.doc.Value("Architecture")
}

func (p *Package) Depends() []Dependency {
    return ParseDependencies(p.doc.Value("Depends"))
}

func (p *Package) Suggests() []Dependency {
    return ParseDependencies(p.doc.Value("Suggests"))
}

type Dependency struct {
    Name     string
    Version  string
    Relation string
}

func ParseDependencies(values string) []Dependency {
    // Ex: "adduser, gpgv | gpgv2 | gpgv1, libapt-pkg5.0 (>= 1.7.0~alpha3~)"
    depsValues := strings.TrimSpace(values)
    if depsValues == "" {
        return nil
    }

    var deps []Dependency
    for _, value := range strings.Split(depsValues, ", ") {
        deps = append(deps, ParseDependency(value))
    }
    return deps
}

func ParseDependency(value string) Dependency {
    // Example of syntax:
    // "adduser", "gpgv | gpgv2", "libc6 (>= 2.15)",
    // "python3:any (>= 3.5~)", "foo [i386]", "perl:any", "perlapi-5.28.0"

    var dep Dependency

    r := regexp.MustCompile(`^(?P<name>[\w\.-]+)(?:[:]\w+)?` +
        `(?: [(](?P<relation>(?:>>|>=|=|<=|<<)) ` +
        `(?P<version>\S+)[)])?(?: [|].*)?$`)
    res := r.FindStringSubmatch(value)
    names := r.SubexpNames()
    for i, _ := range res {
        switch names[i] {
        case "name":
            dep.Name = res[i]
        case "relation":
            dep.Relation = res[i]
        case "version":
            dep.Version = res[i]
        }
    }
    return dep
}

// That's all for the different structures relating to the Apt cache.

///////////////////////////////////////////////////////////

// Now, we need to initialize the three main components.
// The first step is thus to create the array containing all known packages.
// This array will be populated in the successive steps.

func (c *CacheFile) BuildCaches() {
    c.cache = &pkgCache{
        packages: make(map[string]*Package),
    }
}

// The second step is to read the lists of sources to find the `Packages` files
// containing the list of available packages.
// So, we need a function to parse these local source files.

// ParseSourceFile parses a single source file.
// It only supports the common multi-line format,
// and not the most recent DEB822 format.
func ParseSourceFile(content string) []*pkgSource {
    var results []*pkgSource

    scanner := bufio.NewScanner(strings.NewReader(content))
    // Read line by line
    for scanner.Scan() {
        line := scanner.Text()
        if strings.TrimSpace(line) == "" {
            // Ignore blank lines
            continue
        }
        if strings.HasPrefix("#", line) {
            // Ignore comments
            continue
        }
        parts := strings.Split(line, " ")
        // Basic parser (ignore some options or unused attributes)
        source := &pkgSource{
            Type: parts[0],
            URI:  parts[1],
            Dist: parts[2],
        }
        results = append(results, source)
    }

    return results
}

// BuildSourceList parses every source file.
func (c *CacheFile) BuildSourceList() {
    var sources []*pkgSource

    // Read /etc/apt/sources.list
    mainPath := "/etc/apt/sources.list"
    if _, err := os.Stat(mainPath); !os.IsNotExist(err) {
        content, err := ioutil.ReadFile(mainPath)
        if err != nil {
            fmt.Printf("E: Unable to read source file\n\t%s\n", err)
            os.Exit(1)
        }
        sources = append(sources, ParseSourceFile(string(content))...)
    }

    // Read /etc/apt/sources.list.d/
    dirPath := "/etc/apt/sources.list.d/"
    if _, err := os.Stat(dirPath); !os.IsNotExist(err) {
        files, err := ioutil.ReadDir(dirPath)
        if err != nil {
            fmt.Printf("E: Unable to read source dir\n\t%s\n", err)
            os.Exit(1)
        }
        for _, file := range files {
            filePath := filepath.Join(dirPath, file.Name())
            content, err := ioutil.ReadFile(filePath)
            if err != nil {
                fmt.Printf("E: Unable to read source file\n\t%s\n", err)
                os.Exit(1)
            }
            sources = append(sources, ParseSourceFile(string(content))...)
        }
    }
    c.sources = sources
}

// The last step is to read the Dpkg database
// to determine the packages already installed.
// Therefore, we need a function to parse the status file.

func ParseStatus() (*deb822.Document, error) {
    f, err := os.Open("/var/lib/dpkg/status")
    if err != nil {
        return nil, err
    }
    parser, err := deb822.NewParser(f)
    if err != nil {
        return nil, err
    }
    statusContent, err := parser.Parse()
    if err != nil {
        return nil, err
    }
    return &statusContent, nil
}

func (c *CacheFile) BuildDepCache() {
    states := make(map[string]*StateCache)

    // Read /var/lib/dpkg/status
    status, err := ParseStatus()
    if err != nil {
        fmt.Printf("E: The package lists or status file could not be parsed.")
        os.Exit(1)
    }

    // Add state for packages already installed
    for _, pkg := range status.Paragraphs {
        // The status file also contains packages
        // that were partially installed or removed.
        if !strings.Contains(pkg.Value("Status"), "installed") {
            continue
        }
        state, ok := states[pkg.Value("Package")]
        if !ok {
            state = &StateCache{}
            states[pkg.Value("Package")] = state
        }
        state.CurrentVersion = pkg.Value("Version")
    }

    c.depCache = &pkgDepCache{
        states: states,
    }
}

///////////////////////////////////////////////////////////

// We now have the three functions required to initialize the Apt cache.
// We will hide them behind a simple method.

func (c *CacheFile) Open() {
    // Initialize the Acquire system to download file from repositories
    acq := NewPkgAcquire(c)

    // Initialize the cache structure
    if c.sources == nil {
        c.BuildCaches()
        c.BuildSourceList()
        c.BuildDepCache()
    }

    // Download items from repositories
    for _, source := range c.sources {
        if source.Type == "deb-src" {
            continue // We are interested only in binary packages
        }
        acq.Add(NewMetaIndexItem(source))
    }

    // Wait for all items to be downloaded to return
    err := acq.Run()
    if err != nil {
        fmt.Printf("E: Unable to fetch resources\n\t%s\n", err)
        os.Exit(1)
    }
}

// As we have implemented before, the cache content is populated
// from the `Done()` methods of the different types of `Item`.
// We need to expose additional methods to easily add or retrieve
// these packages and their state.

func (c *CacheFile) AddPackage(p *Package) {
    c.cache.packages[p.Name()] = p
}

func (c *CacheFile) GetPackage(name string) *Package {
    if p, ok := c.cache.packages[name]; ok {
        return p
    }
    return nil
}

func (c *CacheFile) GetPackages() []*Package {
    values := make([]*Package, 0, len(c.cache.packages))
    for _, v := range c.cache.packages {
        values = append(values, v)
    }
    return values
}

func (c *CacheFile) GetState(pkg *Package) *StateCache {
    var state *StateCache
    state, ok := c.depCache.states[pkg.Name()]
    if !ok {
        // Only the state of installed packages is present.
        // We defer the initialization for other packages until
        // the first access.
        state = &StateCache{
            CandidateVersion: pkg.Version(),
            flagInstall:      false,
        }
        c.depCache.states[pkg.Name()] = state
    }
    return state
}

///////////////////////////////////////////////////////////

// We are almost done with the Apt cache.
// We have discussed several times about the state we keep about each package
// without explaining what it means.

type StateCache struct {
    // The version that can be installed determined using sources.
    CandidateVersion string
    // The version currently installed determined using the Dpkg database.
    CurrentVersion string
    // A flag to determine if the package is marked for installation.
    flagInstall bool
}

func (s *StateCache) Upgradable() bool {
    return s.CurrentVersion != "" &&
        s.CandidateVersion != "" && s.CurrentVersion != s.CandidateVersion
}

func (s *StateCache) Install() bool {
    return s.flagInstall
}

func (s *StateCache) Installed() bool {
    return s.CurrentVersion != ""
}

// When installing a package, we must make sure its dependencies
// are already installed or we need to install them first.
// The logic is rather complicated as many things can go wrong
// with dependency management like conflicts between two packages.
// For this article, we will use a very basic approach.
// We ignore versions completely and install each missing dependencies
// without checking if it brokes other packages. This is another
// reason why you must not run this code on your host directly :).

func (c *CacheFile) MarkForInstallation(pkgName string) {
    pkg := c.GetPackage(pkgName)
    if pkg == nil {
        fmt.Printf("E: Unable to locate package %s\n", pkgName)
        os.Exit(1)
    }

    state := c.GetState(pkg)
    if state.Installed() || state.Install() {
        // Already installed or marked for installation
        return
    }

    // Make sure to mark the package before checking its dependencies
    // to prevent infinite cycles
    state.CandidateVersion = pkg.Version()
    state.flagInstall = true

    // Mark dependencies recursively
    for _, dep := range pkg.Depends() {
        c.MarkForInstallation(dep.Name)
    }

    // Add dependencies first in the installation sequence order
    c.depCache.order = append(c.depCache.order, pkgName)
}

// We end this section with an utility method to report the total
// number of packages that will be installed.
// This number differs commonly as packages have dependencies
// that must be installed and we will use this method to notify
// the user that more packages will be installed as the ones
// passed in argument.

func (c *CacheFile) InstCount() int {
    count := 0
    for _, state := range c.depCache.states {
        if state.Install() {
            count++
        }
    }
    return count
}

///////////////////////////////////////////////////////////

//
// Main
//

// We have everything we need to implement the command `apt install`.
// We will integrate everything we have covered so far.

func main() {
    var pkgNames []string
    // The command `apt install` can be called without any package to install.
    if len(os.Args) > 1 {
        pkgNames = append(pkgNames, os.Args[1:]...)
    }

    // Load the Cache
    cache := &CacheFile{}
    cache.Open()

    // Search for the packages to install
    pkgs := make(map[string]*Package)
    for _, pkgName := range pkgNames {
        // The command `apt install` also supports `.deb` file.
        // We ignore this for simplicity to avoid
        // duplicating code from the previous parts of this blog post.
        // Check https://github.com/julien-sobczak/linux-packages-under-the-hood
        // for a more complete implementation.

        cache.MarkForInstallation(pkgName)
        pkgs[pkgName] = cache.GetPackage(pkgName)
    }

    // Print out the list of additional packages to install
    if cache.InstCount() != len(pkgNames) {
        var extras []string
        for _, pkg := range cache.GetPackages() {
            state := cache.GetState(pkg)
            if !state.Install() {
                continue
            }
            if _, ok := pkgs[pkg.Name()]; !ok {
                extras = append(extras, pkg.Name())
            }
        }
        fmt.Printf(
            "The following additional packages will be installed:\n\t%s\n",
            strings.Join(extras, " "))
    }

    // Print out the list of suggested packages
    var suggests []string
    for _, pkg := range cache.GetPackages() {
        state := cache.GetState(pkg)

        // Just look at the ones we want to install
        if !state.Install() {
            continue
        }

        // Get the suggestions for the candidate version
        for _, dependency := range pkg.Suggests() {
            suggests = append(suggests, dependency.Name)
        }
    }
    if len(suggests) > 0 {
        fmt.Printf("Suggested packages:\n\t%s\n", strings.Join(suggests, " "))
    }

    err := InstallPackages(cache)
    if err != nil {
        fmt.Printf("E: %s\n", err)
        os.Exit(1)
    }
}

func InstallPackages(cache *CacheFile) error {
    acq := NewPkgAcquire(cache)

    // 1. Download package archives
    for _, pkgName := range cache.depCache.order {
        pkg := cache.GetPackage(pkgName)
        acq.Add(NewPackageItem(pkg))
    }
    err := acq.Run()
    if err != nil {
        return err
    }

    // 2. Run the command `dpkg -i` to install them
    var archives []string
    for _, pkgName := range cache.depCache.order {
        pkg := cache.GetPackage(pkgName)
        archives = append(archives, pkg.cacheFilepath)
    }

    // We delegate to the dpkg command to avoid repeating the previous code
    // but the complete code source of this repository reuse the same code.
    // Check https://github.com/julien-sobczak/linux-packages-under-the-hood
    out, err := exec.Command("dpkg", "-i", strings.Join(archives, " ")).Output()
    if err != nil {
        return err
    }
    fmt.Print(string(out))

    return nil
}

///////////////////////////////////////////////////////////

// Helpers

// gpgDecode checks the GPP signature of a clearsigned document and
// returns the content.
func gpgDecode(filename string, publicKey string) ([]byte, error) {
    // Open gpg clearsigned document
    r, err := os.Open(filename)
    if err != nil {
        return nil, fmt.Errorf("error opening public key: %s", err)
    }
    defer r.Close()

    // Read the content
    data, err := ioutil.ReadAll(r)
    if err != nil {
        return nil, err
    }

    // Decode the content
    b, _ := clearsign.Decode(data)
    if b == nil {
        return nil, fmt.Errorf("not PGP signed")
    }

    // Open the public key to validate the signature
    rk, err := os.Open(publicKey)
    if err != nil {
        return nil, fmt.Errorf("error opening public key: %s", err)
    }
    defer r.Close()
    keyring, err := openpgp.ReadKeyRing(rk) // binary
    if err != nil {
        return nil, fmt.Errorf("failed to parse public key: %v", err)
    }

    // Check the signature using the public key
    _, err = openpgp.CheckDetachedSignature(keyring,
        bytes.NewBuffer(b.Bytes), b.ArmoredSignature.Body)
    if err != nil {
        return nil, err
    }

    return b.Plaintext, nil
}