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);
  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);

  /* 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);
  dpkg_ar_member_put_mem(ar, "debian-binary", deb_magic, strlen(deb_magic));
  dpkg_ar_member_put_file(ar, adminmember, gzfd, -1);

  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);

  close(gzfd);

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

  dpkg_ar_close(ar);

  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()
}

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

  modstatdb_open(msdbrw_readonly);

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

  process_queue();

  trigproc_run_deferred();
  modstatdb_shutdown();

  return 0;
}

void process_archive(const char *filename) {
  …
  cidir = get_control_dir(cidir);
  pid = subproc_fork();
  if (pid == 0) {
    cidirrest[-1] = '\0';
    execlp("dpkg-deb", "dpkg-deb", "--control", filename, cidir, NULL);
    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;
  /** The error flag bitmask. */
  enum pkgeflag eflag;
  enum pkgstatus status;
  enum pkgpriority priority;

  struct pkgbin installed;
  struct pkgbin available;

  struct fsys_namenode_list *files;
  bool files_list_valid;

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

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

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

  if (oldversionstatus == PKG_STAT_INSTALLED) {
    pkg_set_eflags(pkg, PKG_EFLAG_REINSTREQ);
    pkg_set_status(pkg, PKG_STAT_HALFCONFIGURED);
    modstatdb_note(pkg);
    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");
    else /* Downgrade => no fallback */
      maintscript_installed(pkg, PRERMFILE, "pre-removal",
                            "upgrade",
                            versiondescribe(&pkg->available.version,
                                            vdew_nonambig),
                            NULL);
    pkg_set_status(pkg, PKG_STAT_UNPACKED);
    oldversionstatus = PKG_STAT_UNPACKED;
    modstatdb_note(pkg);
  }
  …
}

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) {
    maintscript_new(pkg, PREINSTFILE, "pre-installation", cidir, cidirrest,
                    "install", NULL);
  } else if (oldversionstatus == PKG_STAT_CONFIGFILES) {
    maintscript_new(pkg, PREINSTFILE, "pre-installation", cidir, cidirrest,
                    "install",
                    versiondescribe(&pkg->installed.version, vdew_nonambig),
                    versiondescribe(&pkg->available.version, vdew_nonambig),
                    NULL);
  } else {
    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);

  /* 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);

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

  /* 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);

  ...
}

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

  modstatdb_open(msdbrw_readonly);

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

  process_queue();

  trigproc_run_deferred();
  modstatdb_shutdown();

  return 0;
}

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


/*
 * 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;
int sincenothing = 0;

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);
  }

  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);
  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);
    }

    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);

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

----
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"
}