Implemented 3rd party package policy to no break SSU.

[hildon-application-manager:mainline.git] / src / apt-worker.cc

/*
 * This file is part of the hildon-application-manager.
 *
 * Parts of this file are derived from apt.  Apt is copyright 1997,
 * 1998, 1999 Jason Gunthorpe and others.
 *
 * Copyright (C) 2005, 2006, 2007, 2008 Nokia Corporation.  All Rights reserved.
 *
 * Contact: Marius Vollmer <marius.vollmer@nokia.com>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version
 * 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 *
 */

/* This is the process that runs as root and does all the work.

   It is started from a separate program (as opposed to being forked
   directly from the GUI process) since that allows us to use sudo for
   starting it.

   This process communicates with the GUI process via some named pipes
   that are created by that process.  You can't really use it from the
   command line.

   It will output stuff to stdin and stderr, which the GUI process is
   supposed to catch and put into its log.

   The program tries hard not to exit prematurely.  Once the
   connection between the GUI process and this process has been
   established, the apt-worker is supposed to stick around until that
   connection is broken, even if it has to fail every request send to
   it.  This allows the user to try and fix the system after something
   went wrong, although the options are limited, of course.  The best
   example is a corrupted /etc/apt/sources.list: even tho you can't do
   anything related to packages, you still need the apt-worker to
   correct /etc/apt/sources.list itself in the UI.
*/

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <assert.h>
#include <stdarg.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/statvfs.h>
#include <sys/types.h>
#include <sys/fcntl.h>
#include <errno.h>
#include <dirent.h>
#include <signal.h>
#include <ftw.h>

#include <fstream>

#include <apt-pkg/init.h>
#include <apt-pkg/error.h>
#include <apt-pkg/tagfile.h>
#include <apt-pkg/pkgcache.h>
#include <apt-pkg/pkgcachegen.h>
#include <apt-pkg/sourcelist.h>
#include <apt-pkg/acquire.h>
#include <apt-pkg/acquire-item.h>
#include <apt-pkg/cachefile.h>
#include <apt-pkg/strutl.h>
#include <apt-pkg/sptr.h>
#include <apt-pkg/packagemanager.h>
#include <apt-pkg/deblistparser.h>
#include <apt-pkg/debversion.h>
#include <apt-pkg/dpkgpm.h>
#include <apt-pkg/debsystem.h>
#include <apt-pkg/orderlist.h>
#include <apt-pkg/algorithms.h>
#include <apt-pkg/metaindex.h>
#include <apt-pkg/debmetaindex.h>
#include <apt-pkg/policy.h>
#include <apt-pkg/md5.h>
#include <apt-pkg/sha1.h>
#include <apt-pkg/sha256.h>

#include <glib/glist.h>
#include <glib/gstring.h>
#include <glib/gstrfuncs.h>
#include <glib/gmem.h>
#include <glib/gfileutils.h>
#include <glib/gslist.h>
#include <glib/gkeyfile.h>

#include "apt-worker-proto.h"
#include "confutils.h"

#include "update-notifier-conf.h"

using namespace std;

static void save_operation_record (const char *package,
                                   const char *download_root);
static void erase_operation_record ();
static xexp *read_operation_record ();

/* Table of contents.
 
   COMPILE-TIME CONFIGURATION
   
   RUN-TIME CONFIGURATION

   GENERAL UTILITIES

   COMMUNICATING WITH THE FRONTEND

   STARTUP AND COMMAND DISPATCHER

   CACHE HANDLING
*/


/** COMPILE-TIME CONFIGURATION
 */

/* Defining this to non-zero will also recognize packages in the
   "maemo" section as user packages.  There are still packages
   floating around that follow this old rule.
*/
#define ENABLE_OLD_MAEMO_SECTION_TEST 1

/* Requests up to this size are put into a stack allocated buffer.
 */
#define FIXED_REQUEST_BUF_SIZE 4096

/* The location where we keep our lock.
 */
#define APT_WORKER_LOCK "/var/lib/hildon-application-manager/apt-worker-lock"

/* Temporary catalogues and temporary sources.list */
#define TEMP_CATALOGUE_CONF "/var/lib/hildon-application-manager/catalogues.temp"
#define TEMP_APT_SOURCE_LIST "/etc/apt/sources.list.d/hildon-application-manager-temp.list"

/* APT CACHE ARCHIVES DIRECTORIES */
#define DEFAULT_DIR_CACHE_ARCHIVES "archives/"
#define ALT_DIR_CACHE_ARCHIVES ".apt-archive-cache/"

/* Files related to the 'check for updates' process */
#define FAILED_CATALOGUES_FILE "/var/lib/hildon-application-manager/failed-catalogues"

/* Domain names associated with "OS" and "Nokia" updates */
#define OS_UPDATES_DOMAIN_NAME "nokia-system"
#define NOKIA_UPDATES_DOMAIN_NAME "nokia-certified"

/* Where we keep a journal of the current operation
 */
#define CURRENT_OPERATION_FILE "/var/lib/hildon-application-manager/current-operation"

/* You know what this means.
 */
/*#define DEBUG*/
/*#define DEBUG_COMMANDS*/

#ifdef DEBUG
#define DBG log_stderr
#else
#define DBG(...)
#endif

/** RUN-TIME CONFIGURATION
 */

/* Setting this to true will break the lock of the dpkg status
   database if necessary.
*/
bool flag_break_locks = false;

/* Setting this to true will not ignore package versions from a wrong
   domain.
 */
bool flag_allow_wrong_domains = false;

/* Setting this to true will use the normal apt-get algorithms for
   installing/removing packages instead of our home-grown ones.
*/
bool flag_use_apt_algorithms = false;

/* Setting this to false will not use MMC to save the packages when
   downloading them.
*/
bool flag_download_packages_to_mmc = false;

/** GENERAL UTILITIES
 */

void
log_stderr (const char *fmt, ...)
{
  va_list args;
  va_start (args, fmt);
  fprintf (stderr, "apt-worker: ");
  vfprintf (stderr, fmt, args);
  va_end (args);
  fprintf (stderr, "\n");
}

/** APT WORKER MULTI STATE MANAGEMENT
 */

/* Inside this process, domains are identified with small integers.
 */

typedef signed char domain_t;

struct domain_info {
  const char *name;
  xexp *conf;
  int trust_level;
  bool is_certified;
};

xexp *domain_conf = NULL;
domain_info *domains = NULL;
int domains_number = 0;
time_t domains_last_modified = -1;

#define DOMAIN_INVALID  -1
#define DOMAIN_UNSIGNED  0
#define DOMAIN_SIGNED    1 

#define DOMAIN_DEFAULT DOMAIN_UNSIGNED

static time_t
file_last_modified (const char *file_name)
{
  struct stat buf;

  if (stat (file_name, &buf) == -1)
    {
      perror ("error retriving file info");
      return -1;
    }

  return buf.st_mtime;
}

static void
read_domain_conf ()
{
  delete[] domains;
  xexp_free (domain_conf);

  domain_conf = read_domains ();

  int n_domains = 2;
  if (domain_conf)
    n_domains += xexp_length (domain_conf);

  domains = new domain_info[n_domains];

  /* Setup the two implicit domains.
   */
  domains[0].name = "unsigned";
  domains[0].conf = NULL;
  domains[0].trust_level = 0;
  domains[0].is_certified = false;
    
  domains[1].name = "signed";
  domains[1].conf = NULL;
  domains[1].trust_level = 1;
  domains[1].is_certified = false;

  int i = 2;
  if (domain_conf)
    {
      for (xexp *d = xexp_first (domain_conf); d; d = xexp_rest (d))
        {
          if (!xexp_is (d, "domain"))
            continue;

          domains[i].name = xexp_aref_text (d, "name");
          if (domains[i].name == NULL)
            continue;

          domains[i].trust_level = xexp_aref_int (d, "trust-level", 2);
          domains[i].is_certified = xexp_aref_bool (d, "certified");
          domains[i].conf = d;

          i += 1;
        }
    }

  /* Update domains number and last modified timestamp */
  domains_number = i;
  domains_last_modified = file_last_modified (PACKAGE_DOMAINS);
}

static domain_t
find_domain_by_tag (const char *tag, const char *val)
{
  for (int i = 0; i < domains_number; i++)
    {
      if (domains[i].conf == NULL)
        continue;

      for (xexp *x = xexp_aref (domains[i].conf, tag);
           x;
           x = xexp_aref_rest (x, tag))
        {
          if (xexp_is_text (x) && g_str_has_suffix (xexp_text (x), val))
            return i;
        }
    }

  return DOMAIN_SIGNED;
}

static domain_t
find_domain_by_key (const char *key)
{
  return find_domain_by_tag ("key", key);
}

static domain_t
find_domain_by_uri (const char *uri)
{
  return find_domain_by_tag ("uri", uri);
}

class myCacheFile;

/* This class implements a global static cache managing for
 *  apt-worker. */
class AptWorkerCache
{
public:
  AptWorkerCache ();
  static void Initialize ();
  static AptWorkerCache * GetCurrent ();
  
  bool init_cache_after_request;  
  myCacheFile *cache;
  pkgDepCache::ActionGroup *action_group;
  static AptWorkerCache *current;
  static bool global_initialized;
};

AptWorkerCache *AptWorkerCache::current = 0;

bool AptWorkerCache::global_initialized = false;

AptWorkerCache::AptWorkerCache ()
  : init_cache_after_request (false), cache (0)
{
}

AptWorkerCache *
AptWorkerCache::GetCurrent (void)
{
  return current;
}  

/* Initialization of apt worker cache. It initializes the
 * APT subsystem, and then gets the current instance. */
void
AptWorkerCache::Initialize (void)
{
  if (!global_initialized)
    {
      if (pkgInitConfig (*_config) == false ||
          pkgInitSystem (*_config, _system) == false)
        {
          _error->DumpErrors ();
          return;
        }

      _config->Set ("DPkg::Options::", "--force-confold");
      _config->Set ("Dir::Log", "var/log");
      _config->Set ("Dir::Log::Terminal", "");
      global_initialized = true;
    }

  current = new AptWorkerCache;
}
  
/* This struct describes some status flags for specific packages.
 * myCacheFile includes an array of these, with an entry per
 * package.
 */
typedef struct extra_info_struct
{
  bool autoinst : 1;
  bool related : 1;
  bool soft : 1;
  domain_t cur_domain, new_domain;
};

class myPolicy : public pkgPolicy {

protected:
  myCacheFile *my_cache_file;
  int *pf_domain;

public:
  myPolicy (pkgCache *Owner, myCacheFile *cache_file)
    : pkgPolicy (Owner), my_cache_file (cache_file)
  {
    pf_domain = new int[Owner->Head().PackageFileCount];
  }

  void InitDomains ();

  virtual pkgCache::VerIterator GetCandidateVer(pkgCache::PkgIterator Pkg);
};

class myCacheFile : public pkgCacheFile {

public:
  bool Open (OpProgress &Progress, bool WithLock = true);

  void load_extra_info ();
  void save_extra_info ();

  extra_info_struct *extra_info;

  myCacheFile ()
  {
    extra_info = NULL;
  }

  ~myCacheFile ()
  {
    delete[] extra_info;
  }
};

static void set_sources_for_get_domain (pkgSourceList *sources);
static int get_domain (pkgIndexFile*);

void
myPolicy::InitDomains ()
{
  for (pkgCache::PkgFileIterator I = Cache->FileBegin();
       I != Cache->FileEnd(); I++)
    pf_domain[I->ID] = DOMAIN_UNSIGNED;

  pkgSourceList List;
  if (!List.ReadMainList ())
    {
      _error->DumpErrors();
      return;
    }

  set_sources_for_get_domain (&List);

  for (pkgCache::PkgFileIterator I = Cache->FileBegin();
       I != Cache->FileEnd(); I++)
    {
      // Locate the associated index files so we can find its domain
      pkgIndexFile *Indx;
      if (List.FindIndex(I,Indx) || _system->FindIndex(I,Indx))
        {
          pf_domain[I->ID] = get_domain (Indx);
          DBG ("%s: %s", Indx->Describe(true).c_str(),
               domains[pf_domain[I->ID]].name);
        }
    }
  
  set_sources_for_get_domain (NULL);
}

static bool domain_dominates_or_is_equal (int a, int b);

pkgCache::VerIterator 
myPolicy::GetCandidateVer (pkgCache::PkgIterator Pkg)
{
  // Look for a package pin and evaluate it.
  signed Max = GetPriority(Pkg);
  pkgCache::VerIterator Pref = GetMatch(Pkg);
  
  /* Falling through to the default version.. Setting Max to zero
     effectively excludes everything <= 0 which are the non-automatic
     priorities.. The status file is given a prio of 100 which will exclude
     not-automatic sources, except in a single shot not-installed mode.
     The second pseduo-status file is at prio 1000, above which will permit
     the user to force-downgrade things.
     
     The user pin is subject to the same priority rules as default 
     selections. Thus there are two ways to create a pin - a pin that
     tracks the default when the default is taken away, and a permanent
     pin that stays at that setting.
  */
  for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false; Ver++)
    {
      for (pkgCache::VerFileIterator VF = Ver.FileList(); VF.end() == false;
           VF++)
        {
          /* If this is the status file, and the current version is not the
             version in the status file (ie it is not installed, or somesuch)
             then it is not a candidate for installation, ever. This weeds
             out bogus entries that may be due to config-file states, or
             other. */
          if ((VF.File()->Flags & pkgCache::Flag::NotSource) == pkgCache::Flag::NotSource &&
              Pkg.CurrentVer() != Ver)
            continue;

          /* If requested, skip versions from the wrong domain, but
             only for sources.
           */

          if (!flag_allow_wrong_domains
              && ((VF.File()->Flags & pkgCache::Flag::NotSource)
                  != pkgCache::Flag::NotSource))
            {
              if (!domain_dominates_or_is_equal
                  (pf_domain[VF.File()->ID],
                   my_cache_file->extra_info[Pkg->ID].cur_domain))
                {
                  log_stderr ("Ignoring version from wrong domain: %s %s",
                              Pkg.Name(), Ver.VerStr());
                  log_stderr ("  %s", VF.File().FileName());
                  continue;
                }
            }
          
          signed Prio = PFPriority[VF.File()->ID];
          if (Prio > Max)
            {
              Pref = Ver;
              Max = Prio;
            }    
        }      
      
      if (Pkg.CurrentVer() == Ver && Max < 1000)
        {
          /* Elevate our current selection (or the status file itself)
             to the Pseudo-status priority. */
          if (Pref.end() == true)
            Pref = Ver;
          Max = 1000;
          
          // Fast path optimize.
          if (StatusOverride == false)
            break;
        }       
    }
  return Pref;
}

bool
myCacheFile::Open (OpProgress &Progress, bool WithLock)
{
  if (BuildCaches(Progress,WithLock) == false)
    return false;
  
  // The policy engine
  myPolicy *pol = new myPolicy (Cache, this);
  Policy = pol;
  if (_error->PendingError() == true)
    return false;
  if (ReadPinFile(*Policy) == false)
    return false;
  
  pol->InitDomains ();
  
  load_extra_info ();

  // Create the dependency cache
  DCache = new pkgDepCache(Cache,Policy);
  if (_error->PendingError() == true)
    return false;
  
  DCache->Init(&Progress);
  Progress.Done();
  if (_error->PendingError() == true)
    return false;
  
  return true;
}

/* Save the 'extra_info' of the cache.  We first make a copy of the
   Auto flags in our own extra_info storage so that CACHE_RESET
   will reset the Auto flags to the state last saved with this
   function.
*/

void
myCacheFile::save_extra_info ()
{
  if (mkdir ("/var/lib/hildon-application-manager", 0777) < 0
      && errno != EEXIST)
    {
      log_stderr ("/var/lib/hildon-application-manager: %m");
      return;
    }

  FILE *f = fopen ("/var/lib/hildon-application-manager/autoinst", "w");
  if (f)
    {
      pkgDepCache &cache = *DCache;

      for (pkgCache::PkgIterator pkg = cache.PkgBegin(); !pkg.end (); pkg++)
        {
          if (cache[pkg].Flags & pkgCache::Flag::Auto)
            {
              extra_info[pkg->ID].autoinst = true;
              fprintf (f, "%s\n", pkg.Name ());
            }
          else
            extra_info[pkg->ID].autoinst = false;
        }
      fflush (f);
      fsync (fileno (f));
      fclose (f);
    }

  for (domain_t i = 0; i < domains_number; i++)
    {
      char *name =
        g_strdup_printf ("/var/lib/hildon-application-manager/domain.%s",
                         domains[i].name);
      
      FILE *f = fopen (name, "w");
      if (f)
        {
          pkgDepCache &cache = *DCache;

          for (pkgCache::PkgIterator pkg = cache.PkgBegin();
               !pkg.end (); pkg++)
            {
              if (extra_info[pkg->ID].cur_domain == i)
                fprintf (f, "%s\n", pkg.Name ());
            }
          fflush (f);
          fsync (fileno (f));
          fclose (f);
        }
    }
}

/* Load the 'extra_info'.  You need to call CACHE_RESET to
   transfer the auto flag into the actual cache.  */

void
myCacheFile::load_extra_info ()
{
  pkgCache &cache = *Cache;

  int package_count = cache.Head().PackageCount;

  extra_info = new extra_info_struct[package_count];

  for (int i = 0; i < package_count; i++)
    {
      extra_info[i].autoinst = false;
      extra_info[i].cur_domain = DOMAIN_DEFAULT;
    }

  FILE *f = fopen ("/var/lib/hildon-application-manager/autoinst", "r");
  if (f)
    {
      char *line = NULL;
      size_t len = 0;
      ssize_t n;

      while ((n = getline (&line, &len, f)) != -1)
        {
          if (n > 0 && line[n-1] == '\n')
            line[n-1] = '\0';

          pkgCache::PkgIterator pkg = cache.FindPkg (line);
          if (!pkg.end ())
            {
              DBG ("auto: %s", pkg.Name ());
              extra_info[pkg->ID].autoinst = true;
            }
        }

      free (line);
      fclose (f);
    }

  for (domain_t i = 0; i < domains_number; i++)
    {
      char *name =
        g_strdup_printf ("/var/lib/hildon-application-manager/domain.%s",
                         domains[i].name);

      FILE *f = fopen (name, "r");
      if (f)
        {
          char *line = NULL;
          size_t len = 0;
          ssize_t n;

          while ((n = getline (&line, &len, f)) != -1)
            {
              if (n > 0 && line[n-1] == '\n')
                line[n-1] = '\0';

              pkgCache::PkgIterator pkg = cache.FindPkg (line);
              if (!pkg.end ())
                {
                  // DBG ("%s: %s (%d)", domains[i].name, pkg.Name (), pkg->ID);
                  extra_info[pkg->ID].cur_domain = i;
                }
            }

          free (line);
          fclose (f);
        }

      g_free (name);
    }
}

/* ALLOC_BUF and FREE_BUF can be used to manage a temporary buffer of
   arbitrary size without having to allocate memory from the heap when
   the buffer is small.
   
   The way to use them is to allocate a buffer of 'normal' but fixed
   size statically or on the stack and the use ALLOC_BUF when the
   actual size of the needed buffer is known.  If the actual size is
   small enough, ALLOC_BUF will use the fixed size buffer, otherwise
   it will allocate a new one.  FREE_BUF will free that buffer.
*/

/* Return a pointer to LEN bytes of free storage.  When LEN is less
   than or equal to FIXED_BUF_LEN return FIXED_BUF, otherwise a newly
   allocated block of memory is returned.  ALLOC_BUF never return
   NULL.
*/
char *
alloc_buf (int len, char *fixed_buf, int fixed_buf_len)
{
  if (len <= fixed_buf_len)
    return fixed_buf;
  else
    return new char[len];
}

/* Free the block of memory pointed to by BUF if it is different from
   FIXED_BUF.
*/
void
free_buf (char *buf, char *fixed_buf)
{
  if (buf != fixed_buf)
    delete[] buf;
}

/* Open FILENAME with FLAGS, or die.
 */
static int
must_open (char *filename, int flags)
{
  int fd = open (filename, flags);
  if (fd < 0)
    {
      perror (filename);
      exit (1);
    }
  return fd;
}

static void
must_set_flags (int fd, int flags)
{
  if (fcntl (fd, F_SETFL, flags) < 0)
    {
      perror ("apt-worker fcntl");
      exit (1);
    }
}

static void
block_for_read (int fd)
{
  fd_set set;
  FD_ZERO (&set);
  FD_SET (fd, &set);

  if (select (fd+1, &set, NULL, NULL, NULL) < 0)
    {
      perror ("apt-worker select");
      exit (1);
    }
}

static int
read_byte (int fd)
{
  unsigned char byte;
  if (read (fd, &byte, 1) == 1)
    return byte;
  return -1;
}

/* DRAIN_FD reads all bytes from FD that are available.
*/
static void
drain_fd (int fd)
{
  while (read_byte (fd) >= 0)
    ;
}

/* Get a lock as with GetLock from libapt-pkg, breaking it if needed
   and allowed by flag_break_locks.

   We do this so that the users can not lock themselves out.  We break
   locks instead of not locking since noisily breaking a lock is
   better than silently corrupting stuff.
 */
int
ForceLock (string File, bool Errors = true)
{
  int lock_fd = GetLock (File, false);
  if (lock_fd >= 0)
    return lock_fd;

  if (flag_break_locks)
    {
      int res = unlink (File.c_str ());
      if (res < 0 && errno != ENOENT)
        log_stderr ("Can't remove %s: %m", File.c_str ());
      else if (res == 0)
        log_stderr ("Forcing %s", File.c_str ());
    }

  return GetLock (File, Errors);
}


/** COMMUNICATING WITH THE FRONTEND.
 
   The communication with the frontend happens over four
   unidirectional fifos: requests are read from INPUT_FD and responses
   are sent back via OUTPUT_FD.  No new request is read until the
   response to the current one has been completely sent.

   The data read from INPUT_FD must follow the request format
   specified in <apt-worker-proto.h>.  The data written to OUTPUT_FD
   follows the response format specified there.

   The CANCEL_FD is polled periodically and when something is
   available to be read, the current operation is aborted.  There is
   currently no meaning defined for the actual bytes that are sent,
   the mere arrival of a byte triggers the abort.

   When using the libapt-pkg PackageManager, it is configured in such
   a way that it sends it "pmstatus:" message lines to STATUS_FD.
   Other asynchronous status reports are sent as spontaneous
   APTCMD_STATUS responses via OUTPUT_FD.  'Spontaneous' should mean
   that no request is required to receive APTCMD_STATUS responses.  In
   fact, APTCMD_STATUS requests are treated as an error by the
   apt-worker.

   Logging and debug output, and output from dpkg and the maintainer
   scripts appears normally on stdout and stderr of the apt-worker
   process.
*/

int input_fd, output_fd, status_fd, cancel_fd;

/* MUST_READ and MUST_WRITE read and write blocks of raw bytes from
   INPUT_FD and to OUTPUT_FD.  If they return, they have succeeded and
   read or written the whole block.
*/

void
must_read (void *buf, size_t n)
{
  int r;

  while (n > 0)
    {
      r = read (input_fd, buf, n);
      if (r < 0)
        {
          perror ("apt-worker read");
          exit (1);
        }
      else if (r == 0)
        {
          DBG ("exiting");
          exit (0);
        }
      n -= r;
      buf = ((char *)buf) + r;
    }
}

static void
must_write (void *buf, ssize_t n)
{
  if (n > 0 && write (output_fd, buf, n) != n)
    {
      perror ("apt-worker write");
      exit (1);
    }
}

/* This function sends a response on OUTPUT_FD with the given CMD and
   SEQ.  It either succeeds or does not return.
*/
void
send_response_raw (int cmd, int seq, void *response, size_t len)
{
  apt_response_header res = { cmd, seq, len };
  must_write (&res, sizeof (res));
  must_write (response, len);
}

/* Fabricate and send a APTCMD_STATUS response.  Parameters OP,
   ALREADY, and TOTAL are as specified in apt-worker-proto.h.

   A status response is only sent when there is enough change since
   the last time.  The following counts as 'enough': ALREADY has
   decreased, it has increased by more than MIN_CHANGE, it is equal to
   -1, LAST_TOTAL has changed, or OP has changed.
*/

void
send_status (int op, int already, int total, int min_change)
{

  static apt_proto_encoder status_response;
  static int last_op;
  static int last_already;
  static int last_total;

  if (already == -1 
      || already < last_already 
      || already >= last_already + min_change
      || total != last_total
      || op != last_op)
    {
      last_already = already;
      last_total = total;
      last_op = op;
      
      status_response.reset ();
      status_response.encode_int (op);
      status_response.encode_int (already);
      status_response.encode_int (total);
      send_response_raw (APTCMD_STATUS, -1, 
                         status_response.get_buf (),
                         status_response.get_len ());
    }
}


/** STARTUP AND COMMAND DISPATCHER.
 */

/* Since the apt-worker only works on a single command at a time, we
   use two global encoder and decoder engines that manage the
   parameters of the request and the result values of the response.

   Handlers of specific commands will read the parameters from REQUEST
   and put the results into RESPONSE.  The command dispatcher will
   prepare REQUEST before calling the command handler and ship out
   RESPONSE after it returned.
*/
apt_proto_decoder request;
apt_proto_encoder response;

void cmd_get_package_list ();
void cmd_get_package_info ();
void cmd_get_package_details ();
int cmd_check_updates (bool with_status = true);
void cmd_get_catalogues ();
void cmd_set_catalogues ();
void cmd_add_temp_catalogues ();
void cmd_rm_temp_catalogues ();
void cmd_install_check ();
void cmd_download_package ();
void cmd_install_package ();
void cmd_remove_check ();
void cmd_remove_package ();
void cmd_clean ();
void cmd_get_file_details ();
void cmd_install_file ();
void cmd_save_backup_data ();
void cmd_get_system_update_packages ();
void cmd_reboot ();
void cmd_set_options ();
void cmd_set_env ();

int cmdline_check_updates (char **argv);
int cmdline_rescue (char **argv);

/** MANAGEMENT FOR FAILED CATALOGUES LOG FILE
 */

/* Since it's needed to save the full report (including errors) after
   any refresh of the catalogues list, four functions were implemented
   to take care of the writting/reading to/from disk process.
*/

static void save_failed_catalogues (xexp *catalogues);
static xexp *load_failed_catalogues ();
static void clean_failed_catalogues ();
static void clean_temp_catalogues ();
static xexp *merge_catalogues_with_errors (xexp *catalogues);

/** MANAGEMENT OF FILE WITH INFO ABOUT AVAILABLE UPDATES */

static void write_available_updates_file ();

/** MAPPING FUNCTION TO FILTER ERROR DETAILS
    IN CATALOGUES CONFIGURATION FILE
*/
static xexp *map_catalogue_error_details (xexp *x);


/* Commands can request the package cache to be refreshed by calling
   NEED_CACHE_INIT before they return.  The cache will then be
   reconstructed after sending the response and before starting to
   handle the next command.  In this way, the cache reconstruction
   happens in the background.

   XXX - However, APTCMD_STATUS messages are still being sent when the
         cache is reconstructed in the background and the UI has some
         ugly logic to deal with that.
*/

void cache_init (bool with_status = true);

void
need_cache_init ()
{
  AptWorkerCache *awc = AptWorkerCache::GetCurrent ();
  awc->init_cache_after_request = true;
}

#ifdef DEBUG_COMMANDS
static const char *cmd_names[] = {
  "NOOP",
  "STATUS",
  "GET_PACKAGE_LIST",
  "GET_PACKAGE_INFO",
  "GET_PACKAGE_DETAILS",
  "CHECK_UPDATES",
  "GET_CATALOGUES",
  "SET_CATALOGUES",
  "ADD_TEMP_CATALOGUES",
  "RM_TEMP_CATALOGUES",
  "INSTALL_CHECK",
  "INSTALL_PACKAGE",
  "REMOVE_CHECK",
  "REMOVE_PACKAGE",
  "GET_FILE_DETAILS",
  "INSTALL_FILE",
  "CLEAN",
  "SAVE_BACKUP_DATA",
  "GET_SYSTEM_UPDATE_PACKAGES",
  "FLASH_AND_REBOOT",
  "SET_OPTIONS",
  "SET_ENV"
};
#endif

void
handle_request ()
{
  apt_request_header req;
  char stack_reqbuf[FIXED_REQUEST_BUF_SIZE];
  char *reqbuf;
  AptWorkerCache * awc = 0;
  time_t last_modified = -1;

  must_read (&req, sizeof (req));

#ifdef DEBUG_COMMANDS
  DBG ("got req %s/%d/%d", cmd_names[req.cmd], req.seq, req.len);
#endif

  reqbuf = alloc_buf (req.len, stack_reqbuf, FIXED_REQUEST_BUF_SIZE);
  must_read (reqbuf, req.len);

  drain_fd (cancel_fd);

  request.reset (reqbuf, req.len);
  response.reset ();

  awc = AptWorkerCache::GetCurrent ();
  awc->init_cache_after_request = false; // let's reset it now

  /* Re-read domains conf file if modified */
  last_modified = file_last_modified (PACKAGE_DOMAINS);
  if (last_modified != domains_last_modified)
    read_domain_conf ();

  switch (req.cmd)
    {

    case APTCMD_NOOP:
      // Nothing to do.
      break;

    case APTCMD_GET_PACKAGE_LIST:
      cmd_get_package_list ();
      break;

    case APTCMD_GET_PACKAGE_INFO:
      cmd_get_package_info ();
      break;

    case APTCMD_GET_PACKAGE_DETAILS:
      cmd_get_package_details ();
      break;

    case APTCMD_CHECK_UPDATES:
      cmd_check_updates ();
      break;

    case APTCMD_GET_CATALOGUES:
      cmd_get_catalogues ();
      break;

    case APTCMD_SET_CATALOGUES:
      cmd_set_catalogues ();
      break;

    case APTCMD_ADD_TEMP_CATALOGUES:
      cmd_add_temp_catalogues ();
      break;

    case APTCMD_RM_TEMP_CATALOGUES:
      cmd_rm_temp_catalogues ();
      break;

    case APTCMD_INSTALL_CHECK:
      cmd_install_check ();
      break;

    case APTCMD_DOWNLOAD_PACKAGE:
      cmd_download_package ();
      break;

    case APTCMD_INSTALL_PACKAGE:
      cmd_install_package ();
      break;

    case APTCMD_REMOVE_CHECK:
      cmd_remove_check ();
      break;

    case APTCMD_REMOVE_PACKAGE:
      cmd_remove_package ();
      break;

    case APTCMD_CLEAN:
      cmd_clean ();
      break;

    case APTCMD_GET_FILE_DETAILS:
      cmd_get_file_details ();
      break;

    case APTCMD_INSTALL_FILE:
      cmd_install_file ();
      break;

    case APTCMD_SAVE_BACKUP_DATA:
      cmd_save_backup_data ();
      break;

    case APTCMD_GET_SYSTEM_UPDATE_PACKAGES:
      cmd_get_system_update_packages ();
      break;

    case APTCMD_REBOOT:
      cmd_reboot ();
      break;

    case APTCMD_SET_OPTIONS:
      cmd_set_options ();
      break;

    case APTCMD_SET_ENV:
      cmd_set_env ();
      break;

    default:
      log_stderr ("unrecognized request: %d", req.cmd);
      break;
    }

  _error->DumpErrors ();

  send_response_raw (req.cmd, req.seq,
                     response.get_buf (), response.get_len ());

#ifdef DEBUG_COMMANDS
  DBG ("sent resp %s/%d/%d",
       cmd_names[req.cmd], req.seq, response.get_len ());
#endif

  free_buf (reqbuf, stack_reqbuf);

  if (awc->init_cache_after_request)
    {
      cache_init (false);
      _error->DumpErrors ();
    }
}

static int index_trust_level_for_package (pkgIndexFile *index,
                                          const pkgCache::VerIterator &ver);

static const char *lc_messages;

static void
usage ()
{
  fprintf (stderr, "Usage: apt-worker check-for-updates [http_proxy]\n");
  fprintf (stderr, "       apt-worker rescue [package] [archives]\n");
  exit (1);
}

/* Try to get the lock specified by FILE.  If this fails because
   someone else has the lock, a string is returned with the content of
   the file.  Otherwise MY_CONTENT is written to the file and NULL is
   returned.

   Other kinds of failures (out of space, insufficient permissions,
   etc) will terminate this process.

   The lock will be released when this process exits.
*/

static char *
try_lock (const char *file, const char *my_content)
{
  int lock_fd = open (file, O_RDWR | O_CREAT, 0640);
  if (lock_fd < 0)
    {
      log_stderr ("Can't open %s: %m", file);
      exit (1);
    }

  SetCloseExec (lock_fd, true);

  struct flock fl;
  fl.l_type = F_WRLCK;
  fl.l_whence = SEEK_SET;
  fl.l_start = 0;
  fl.l_len = 0;

  if (fcntl (lock_fd, F_SETLK, &fl) == -1)
    {
      char buf[256];
      int n;
      
      if (errno == ENOLCK)
        {
          log_stderr ("locking not supported on %s: %m", file);
          exit (1);
        }
     
      /* We didn't get the lock.
       */

      n = read (lock_fd, buf, 255);
      if (n < 0)
        {
          log_stderr ("can't read lock %s: %m", file);
          exit (1);
        }

      buf[n] = '\0';
      return g_strdup (buf);
    }

  /* We have the lock.
   */

  if (ftruncate (lock_fd, 0) < 0)
    {
      log_stderr ("can't truncate lock %s: %m", file);
      exit (1);
    }
    
  int n = strlen (my_content);
  if (write (lock_fd, my_content, n) != n)
    {
      log_stderr ("can't write lock %s: %m", file);
      exit (1);
    }
     
  return NULL;
}

static void
get_apt_worker_lock (bool weak)
{
  char *mine = g_strdup_printf ("%c %d\n", weak? 'w' : 's', getpid ());
  char *his = NULL;
  int termination_attempts = 0;
  int lock_attempts = 0;

  while (true)
    {
      g_free (his);
      his = try_lock (APT_WORKER_LOCK, mine);
      
      if (his)
        {
          char his_type;
          int his_pid;
          
          if (sscanf (his, "%c %d", &his_type, &his_pid) != 2)
            {
              log_stderr ("can't parse lock.");
              exit (1);
            }

          if (weak || his_type != 'w')
            {
              if (lock_attempts < 5)
                {
                  lock_attempts++;
                  sleep (1);
                  continue;
                }
              else
                {
                  log_stderr ("too weak to get lock from %d.", his_pid);
                  exit (1);
                }
            }
          else if (termination_attempts < 5)
            {
              termination_attempts += 1;
              log_stderr ("terminating %d to get lock.", his_pid);
              kill (his_pid, SIGTERM);
              sleep (1);
              continue;
            }
          else
            {
              /* The big hammer.
               */
              log_stderr ("killing %d to get lock.", his_pid);
              kill (his_pid, SIGKILL);
              unlink (APT_WORKER_LOCK);
              sleep (1);
              continue;
            }
        }
      else
        {
          /* It's ours.
           */
          g_free (mine);
          return;
        }
    }
}

/* MMC default mountpoints */
#define INTERNAL_MMC_MOUNTPOINT  "/home/user/MyDocs"
#define REMOVABLE_MMC_MOUNTPOINT "/media/mmc1"

static void
misc_init ()
{
  lc_messages = getenv ("LC_MESSAGES");
  DBG ("LC_MESSAGES %s", lc_messages);

  DBG ("OSSO_PRODUCT_HARDWARE %s", getenv ("OSSO_PRODUCT_HARDWARE"));

  load_system_settings ();
  read_domain_conf ();

  AptWorkerCache::Initialize ();

  cache_init (false);

#ifdef HAVE_APT_TRUST_HOOK
  apt_set_index_trust_level_for_package_hook (index_trust_level_for_package);
#endif

  clean_temp_catalogues ();

  // initialize the MMC mount points with defaults
  setenv ("INTERNAL_MMC_MOUNTPOINT", INTERNAL_MMC_MOUNTPOINT, 1);
  setenv ("REMOVABLE_MMC_MOUNTPOINT", REMOVABLE_MMC_MOUNTPOINT, 1);
}

void
set_options (const char *options)
{
  if (strchr (options, 'B'))
    flag_break_locks = true;

  if (strchr (options, 'D'))
    flag_allow_wrong_domains = true;

  if (strchr (options, 'M'))
    flag_download_packages_to_mmc = true;

  if (strchr (options, 'A'))
    flag_use_apt_algorithms = true;
}

void
cmd_set_options ()
{
  const char *options = request.decode_string_in_place ();
  set_options (options);
}

void
cmd_set_env ()
{
  const char *http_proxy = request.decode_string_in_place ();
  const char *https_proxy = request.decode_string_in_place ();
  const char *internal_mmc = request.decode_string_in_place ();
  const char *removable_mmc = request.decode_string_in_place ();

  if (http_proxy)
    {
      setenv ("http_proxy", http_proxy, 1);
      DBG ("http_proxy: %s", http_proxy);
    }

  if (https_proxy)
    {
      setenv ("https_proxy", https_proxy, 1);
      DBG ("https_proxy: %s", https_proxy);
    }

  if (internal_mmc)
    {
      setenv ("INTERNAL_MMC_MOUNTPOINT", internal_mmc, 1);
      DBG ("INTERNAL_MMC_MOUNTPOINT: %s", internal_mmc);
    }

  if (removable_mmc)
    {
      setenv ("REMOVABLE_MMC_MOUNTPOINT", removable_mmc, 1);
      DBG ("REMOVABLE_MMC_MOUNTPOINT: %s", removable_mmc);
    }
}

char*
is_fifo (const char *filename)
{
  struct stat statstruct;

  if ((stat (filename, &statstruct) == 0)
      && (S_ISFIFO (statstruct.st_mode)))
    return g_strdup (filename);

  return NULL;
}

int
main (int argc, char **argv)
{
  if (argc == 1)
    usage ();

  argv += 1;
  argc -= 1;

  if (!strcmp (argv[0], "backend"))
    {
      const char *options;

      if (argc != 6)
        {
          log_stderr ("wrong invocation");
          exit (1);
        }

      DBG ("starting up");

      char *input_pipe = is_fifo (argv[1]);
      char *output_pipe = is_fifo (argv[2]);
      char *status_pipe = is_fifo (argv[3]);
      char *cancel_pipe = is_fifo (argv[4]);

      if (!(input_pipe && output_pipe && status_pipe && cancel_pipe))
        {
          g_free (input_pipe);
          g_free (output_pipe);
          g_free (status_pipe);
          g_free (cancel_pipe);

          log_stderr ("wrong fifo pipes specified");
          exit (1);
        }

      input_fd = must_open (input_pipe, O_RDONLY | O_NONBLOCK);
      cancel_fd = must_open (cancel_pipe, O_RDONLY | O_NONBLOCK);
      output_fd = must_open (output_pipe, O_WRONLY);
      status_fd = must_open (status_pipe, O_WRONLY);

      g_free (input_pipe);
      g_free (output_pipe);
      g_free (status_pipe);
      g_free (cancel_pipe);

      /* This tells the frontend that the fifos are open.
       */
      send_status (op_general, 0, 0, -1);

      /* This blocks until the frontend has opened our input fifo for
         writing.
      */
      block_for_read (input_fd);

      /* Reset the O_NONBLOCK flag for the input_fd since we want to block
         until a new request arrives.  The cancel_fd remains in
         non-blocking mode since we just poll it periodically.
      */
      must_set_flags (input_fd, O_RDONLY);

      options = argv[5];

      DBG ("starting with pid %d, in %d, out %d, stat %d, cancel %d, options %s",
           getpid (), input_fd, output_fd, status_fd, cancel_fd,
           options);

      set_options (options);

      /* Don't let our heavy lifting starve the UI.
       */
      errno = 0;
      if (nice (20) == -1 && errno != 0)
        log_stderr ("nice: %m");

      get_apt_worker_lock (false);
      misc_init ();

      while (true)
        handle_request ();

      return 0;
    }
  else if (!strcmp (argv[0], "check-for-updates"))
    {
      get_apt_worker_lock (true);
      misc_init ();
      return cmdline_check_updates (argv);
    }
  else if (!strcmp (argv[0], "rescue"))
    {
      return cmdline_rescue (argv);
    }
  else if (!strcmp (argv[0], "sleep"))
    {
      get_apt_worker_lock (argv[1] == NULL);
      while (true)
        {
          fprintf (stderr, "sleeping...\n");
          sleep (5);
        }
    }
  else
    usage ();
}

/** CACHE HANDLING

    This section contains some general purpose functions to maintain
    the cache of the package database.

    The package cache can represent both the 'current' situation
    (i.e., the union of the information from /var/lib/dpkg/status and
    the various Packages files downloaded from repositories) and a
    'desired' situation.

    A operation such as installing a package is performed by modifying
    the 'desired' situation in the cache and if that leads to a
    consistent configuration, the 'current' situation is brought in
    line with the 'desired' one by downloading the needed archives and
    running dpkg in an approriate way.

    We have our own idea of what should happen when a new package (or
    a new version of a package) is installed, for example, and the
    functions in this section implement this idea.  These principal
    functions are available:

    We remember which operation the cache currently represents.  That
    way, we can avoid recomputing it when the frontend requests the
    same operation multiple times in a row (which it likes to do).

    - cache_init

    This function creates or recreates the cache from
    /var/lib/dpkg/status and the various Packages file from the
    repositories.

    - ensure_cache

    This function tries to make sure that there is a valid
    PACKAGE_CACHE to work with.  It returns true when it succeeds and
    PACKAGE_CACHE is non-NULL then.  The idea is that if the cache
    couldn't be created in the past because of some transient error,
    it might be able to create it now.  Thus, every command handler
    that needs a cache should call ensure_cache.  When ensure_cache
    actually does some work, it will send STATUS messages if it was
    specified with its only parameter.

    - cache_reset ()

    This function resets the 'desired' state of the cache to be
    identical to the 'current' one.

    - mark_for_install ()

    This function modifies the 'desired' state of the cache to reflect
    the installation of the given package.  It will try to achieve a
    consistent 'desired' configuration by installing missing
    dependencies etc.  In general, it implements our own installation
    smartness.

    - mark_for_remove ()

    This function modifies the 'desired' state of the cache to reflect
    the removal of the given package.  As with mark_for_install,
    mark_for_removal implements our own removal smartness.
 */

/* We only report real progress information when reconstructing the
   cache and during downloads.  Only downloads can be cancelled.

   The following two classes allow us to hook into libapt-pkgs
   progress reporting mechanism.  Instances of UPDATE_PROGESS are used
   for cache related activities, and instances of DOWNLOAD_STATUS are
   used when 'acquiring' things.
*/

class UpdateProgress : public OpProgress
{
  bool with_status;

  virtual void
  Update ()
  {
    if (with_status)
      send_status (op_general, (int)Percent, 100, 5);
  }

public:
  UpdateProgress (bool ws) : with_status (ws) { }
};

class DownloadStatus : public pkgAcquireStatus
{
  virtual bool
  MediaChange (string Media, string Drive)
  {
    return false;
  }

  virtual bool
  Pulse (pkgAcquire *Owner)
  {
    pkgAcquireStatus::Pulse (Owner);

    send_status (op_downloading, (int)CurrentBytes, (int)TotalBytes, 1000);

    /* The cancel_fd is in non-blocking mode.
     */
    if (read_byte (cancel_fd) >= 0)
      return false;

    return true;
  }
};

bool
is_user_section (const char *section, const char *end)
{
  if (section == NULL)
    return false;

#if ENABLE_OLD_MAEMO_SECTION_TEST
  if (end-section > 6 && !strncmp (section, "maemo/", 6))
    return true;
#endif
  
  return end-section > 5 && !strncmp (section, "user/", 5);
}

bool
is_user_package (const pkgCache::VerIterator &ver)
{
  const char *section = ver.Section ();

  if (section == NULL)
    return false;

  return is_user_section (section, section + strlen (section));
}

/* Our own version of debSystem.  We override the Lock member function
   to be able to break locks and to avoid failing when dpkg has left a
   journal.
*/

class mydebSystem : public debSystem
{
  // For locking support
  int LockFD;
  unsigned LockCount;

public:

  virtual signed Score (Configuration const &Cnf);
  virtual bool Lock ();
  virtual bool UnLock (bool NoErrors);
  
  mydebSystem ();
};

mydebSystem::mydebSystem ()
  : debSystem ()
{
   Label = "handsfree Debian dpkg interface";
}

signed
mydebSystem::Score (Configuration const &Cnf)
{
  return debSystem::Score (Cnf) + 10;  // Pick me, pick me, pick me!
}

bool
mydebSystem::Lock ()
{
  /* This is a modified copy of debSystem::Lock, which in turn is a
     copy of the behavior of dpkg.
  */

  // Disable file locking
  if (_config->FindB("Debug::NoLocking",false) == true || LockCount > 1)
    {
      LockCount++;
      return true;
    }

  // Create the lockfile, breaking the lock if requested.
  string AdminDir = flNotFile(_config->Find("Dir::State::status"));
  LockFD = ForceLock(AdminDir + "lock");
  if (LockFD == -1)
    {
      if (errno == EACCES || errno == EAGAIN)
        return _error->Error("Unable to lock the administration directory (%s), "
                             "is another process using it?",AdminDir.c_str());
      else
        return _error->Error("Unable to lock the administration directory (%s), "
                             "are you root?",AdminDir.c_str());
    }

  LockCount++;
      
  return true;
}

// System::UnLock - Drop a lock                                         /*{{{*/
// ---------------------------------------------------------------------
/* */
bool mydebSystem::UnLock(bool NoErrors)
{
   if (LockCount == 0 && NoErrors == true)
      return false;
   
   if (LockCount < 1)
      return _error->Error("Not locked");
   if (--LockCount == 0)
   {
      close(LockFD);
      LockCount = 0;
   }
   
   return true;
}
                                                                        /*}}}*/
mydebSystem mydebsystem;

static void
clear_dpkg_updates ()
{
  string File = flNotFile(_config->Find("Dir::State::status")) + "updates/";
  DIR *DirP = opendir(File.c_str());
  if (DirP == 0)
    return;
   
  /* We ignore any files that are not all digits, this skips .,.. and 
     some tmp files dpkg will leave behind.. */

  for (struct dirent *Ent = readdir(DirP); Ent != 0; Ent = readdir(DirP))
    {
      bool ignore = false;

      for (unsigned int I = 0; Ent->d_name[I] != 0; I++)
        {
          // Check if its not a digit..
          if (isdigit(Ent->d_name[I]) == 0)
            {
              ignore = true;
              break;
            }
        }

      if (!ignore)
        {
          log_stderr ("Running 'dpkg --configure dpkg' "
                      "to clean up the journal.");
          system ("dpkg --configure dpkg");
          break;
        }
    }

   closedir(DirP);
}

void cache_reset ();

/* The operation represented by the cache.
 */
static char *current_cache_package = NULL;
static bool current_cache_is_install;

static bool
check_cache_state (const char *package, bool is_install)
{
  if (current_cache_package
      && current_cache_is_install == is_install
      && strcmp (current_cache_package, package) == 0)
    return true;

  if (current_cache_package)
    cache_reset ();

  current_cache_package = g_strdup (package);
  current_cache_is_install = is_install;
  return false;
}

/* Initialize libapt-pkg if this has not been done already and
   (re-)create PACKAGE_CACHE.  If the cache can not be created,
   PACKAGE_CACHE is set to NULL and an appropriate message is output.
   */
void
cache_init (bool with_status)
{
  AptWorkerCache *awc = AptWorkerCache::GetCurrent ();

  /* Closes the cache, to prevent getting blocked by other locks in
   * dpkg structures. If we don't do it, changing the apt worker state
   * does not remove the dpkg state lock and then fails on trying to
   * run dpkg */
  /* @todo do we really keep doing this? */
  if (awc->cache)
    {
      DBG ("closing");
      delete awc->action_group;
      awc->cache->Close ();
      delete awc->cache;
      awc->cache = 0;
      DBG ("done");
    }

  /* We need to dump the errors here since any pending errors will
     cause the following operations to fail.
  */
  _error->DumpErrors ();

  /* Clear out the dpkg journal before construction the cache.
   */
  clear_dpkg_updates ();

  UpdateProgress progress (with_status);
  awc->cache = new myCacheFile;

  DBG ("init.");
  if (!awc->cache->Open (progress))
    {
      DBG ("failed.");
      _error->DumpErrors ();
      delete awc->cache;
      awc->cache = 0;
    }

  if (awc->cache)
    {
      /* We create a ActionGroup here that is active for the whole
         lifetime of the cache.  This prevents libapt-pkg from
         performing certain expensive operations that we don't need to
         be done intermediately, such as garbage collection.
      */
      pkgDepCache &cache = *awc->cache;
      awc->action_group = new pkgDepCache::ActionGroup (cache);
    }

  cache_reset ();

  if (awc->cache)
    write_available_updates_file ();
}

bool
ensure_cache (bool with_status)
{
  AptWorkerCache * awc = 0;
  
  awc = AptWorkerCache::GetCurrent ();
  if (awc->cache == NULL)
    cache_init (with_status);

  return awc->cache != NULL;
}

/* Determine whether a package was installed automatically to satisfy
   a dependency.
*/
bool
is_auto_package (pkgCache::PkgIterator &pkg)
{
  AptWorkerCache *awc = AptWorkerCache::GetCurrent ();
  pkgDepCache &cache = *(awc->cache);
  
  return (cache[pkg].Flags & pkgCache::Flag::Auto) != 0;
}

/* Determine whether a package is related to the current operation.
*/
bool
is_related (pkgCache::PkgIterator &pkg)
{
  AptWorkerCache *awc = AptWorkerCache::GetCurrent ();
  return awc->cache->extra_info[pkg->ID].related;
}

void
mark_related (const pkgCache::VerIterator &ver)
{
  AptWorkerCache *awc = AptWorkerCache::GetCurrent ();
  const pkgCache::PkgIterator &pkg = ver.ParentPkg();

  if (awc->cache->extra_info[pkg->ID].related)
    return;

  awc->cache->extra_info[pkg->ID].related = true;

  pkgDepCache &cache = *awc->cache;

  if (pkg.State() == pkgCache::PkgIterator::NeedsUnpack)
    cache.SetReInstall (pkg, true);

  /* When there are some packages that might need configuring or
     unpacking, we also mark all dependencies of this package as
     related so that we try to unpack/configure them as well.
  */
  if (cache.BadCount () > 0)
    {
      for (pkgCache::DepIterator D = ver.DependsList(); D.end() == false;
           D++)
        {
          const pkgCache::PkgIterator &dep_pkg = D.TargetPkg ();
          const pkgCache::VerIterator &dep_ver = dep_pkg.CurrentVer ();
          if (!dep_ver.end())
            mark_related (dep_ver);
        }
    }
}

/* Revert the cache to its initial state.  More concretely, all
   packages are marked as 'keep' and 'unrelated'.

   XXX - let libapt-pkg handle the auto flags.
*/
void
cache_reset_package (pkgCache::PkgIterator &pkg)
{
  AptWorkerCache *awc = AptWorkerCache::GetCurrent ();
  pkgDepCache &cache = *(awc->cache);

  cache.MarkKeep (pkg);

  if (awc->cache->extra_info[pkg->ID].autoinst)
    cache[pkg].Flags |= pkgCache::Flag::Auto;
  else
    cache[pkg].Flags &= ~pkgCache::Flag::Auto;
  
  awc->cache->extra_info[pkg->ID].related = false;
  awc->cache->extra_info[pkg->ID].soft = false;
}

static bool
any_newly_or_related_broken ()
{
  AptWorkerCache *awc = AptWorkerCache::GetCurrent ();
  if (awc->cache == NULL)
    return false;

  pkgDepCache &cache = *(awc->cache);
  for (pkgCache::PkgIterator pkg = cache.PkgBegin(); !pkg.end (); pkg++)
    {
      if (cache[pkg].InstBroken() &&
          (!cache[pkg].NowBroken() || is_related (pkg)))
        return true;
    }
  return false;
}

void
cache_reset ()
{
  AptWorkerCache *awc = AptWorkerCache::GetCurrent ();
  if (awc->cache == NULL)
    return;

  pkgDepCache &cache = *(awc->cache);

  for (pkgCache::PkgIterator pkg = cache.PkgBegin(); !pkg.end (); pkg++)
    cache_reset_package (pkg);

  g_free (current_cache_package);
  current_cache_package = NULL;
}

/* Try to fix packages that have been broken by undoing soft changes.

   This is not really complicated, the code only looks impenetrable
   because of libapt-pkg's data structures.

   For each package that is broken for the planned operation, we try
   to fix it by undoing the removal of softly removed packages that it
   depends on.  We do this in a loop since a package that has been put
   back might be broken itself and be in need of fixing.
*/
void
fix_soft_packages ()
{
  AptWorkerCache *awc = AptWorkerCache::GetCurrent ();
  if (awc->cache == NULL)
    return;

  pkgDepCache &cache = *(awc->cache);

  bool something_changed;

  do 
    {
      DBG ("FIX");

      something_changed = false;
      for (pkgCache::PkgIterator pkg = cache.PkgBegin(); !pkg.end (); pkg++)
        {
          if (cache[pkg].InstBroken())
            {
              pkgCache::DepIterator Dep =
                cache[pkg].InstVerIter(cache).DependsList();
              for (; Dep.end() != true;)
                {
                  // Grok or groups
                  pkgCache::DepIterator Start = Dep;
                  bool Result = true;
                  for (bool LastOR = true;
                       Dep.end() == false && LastOR == true;
                       Dep++)
                    {
                      LastOR = ((Dep->CompareOp & pkgCache::Dep::Or)
                                == pkgCache::Dep::Or);
                    
                      if ((cache[Dep] & pkgDepCache::DepInstall)
                          == pkgDepCache::DepInstall)
                        Result = false;
                    }
                
                  // Dep is satisfied okay.
                  if (Result == false)
                    continue;

                  // Try to fix it by putting back the first softly
                  // removed target

                  for (bool LastOR = true;
                       Start.end() == false && LastOR == true;
                       Start++)
                    {
                      LastOR = ((Start->CompareOp & pkgCache::Dep::Or)
                                == pkgCache::Dep::Or);
                    
                      pkgCache::PkgIterator Pkg = Start.TargetPkg ();

                      if (((cache[Start] & pkgDepCache::DepInstall)
                           != pkgDepCache::DepInstall)
                          && !Pkg.end()
                          && cache[Pkg].Delete()
              && awc->cache->extra_info[Pkg->ID].soft)
                        {
                          DBG ("= %s", Pkg.Name());
                          cache_reset_package (Pkg);
                          something_changed = true;
                          break;
                        }
                    }
                }
            }
        }
    } while (something_changed);
}

/* Determine whether PKG replaces TARGET.
 */
static bool
package_replaces (pkgCache::PkgIterator &pkg,
                  pkgCache::PkgIterator &target)
{
  AptWorkerCache *awc = AptWorkerCache::GetCurrent ();
  pkgDepCache &cache = *(awc->cache);

  pkgCache::DepIterator Dep = cache[pkg].InstVerIter(cache).DependsList();
  for (; Dep.end() != true; Dep++)
    {
      if (Dep->Type == pkgCache::Dep::Replaces)
        {
          SPtrArray<pkgCache::Version *> List = Dep.AllTargets();
          for (pkgCache::Version **I = List; *I != 0; I++)
            {
              pkgCache::VerIterator Ver(cache,*I);
              pkgCache::PkgIterator Pkg = Ver.ParentPkg();
          
              if (Pkg == target)
                return true;
            }
        }
    }
  return false;
}

#if 0
/* Determine whether PKG is a critical dependency of other packages
   thata re going to be installed.
 */
static bool
package_is_needed (pkgCache::PkgIterator &pkg)
{
  AptWorkerCache *awc = AptWorkerCache::GetCurrent ();
  pkgDepCache &cache = *(awc->cache);

  pkgCache::DepIterator Dep = pkg.RevDependsList();
  for (; Dep.end() != true; Dep++)
    {
      if (Dep->Type == pkgCache::Dep::PreDepends
          || Dep->Type == pkgCache::Dep::Depends)
        {
          pkgCache::PkgIterator other_pkg = Dep.ParentPkg();
          pkgCache::VerIterator other_ver = Dep.ParentVer();
          pkgCache::VerIterator inst_ver = cache[other_pkg].InstVerIter(cache);

          if (other_ver == inst_ver)
            return true;
        }
    }
  return false;
}
#endif

/* Mark a package for installation, using a 'no-surprises' approach
   suitable for the Application Manager.

   Concretely, installing a package will never automatically remove
   other packages.  Thus, we undo the removals scheduled by
   MarkInstall.  Doing this will break the original package, but that
   is what we want.
*/

static void mark_for_remove_1 (pkgCache::PkgIterator &pkg, bool soft);

static void
mark_for_install_1 (pkgCache::PkgIterator &pkg, int level)
{
  AptWorkerCache *awc = AptWorkerCache::GetCurrent ();
  pkgDepCache &cache = *(awc->cache);

  /* This check is just to be extra robust against infinite
     recursions.  They shouldn't happen, but you never know...
  */
  if (level > 100)
    return;

  mark_related (cache[pkg].CandidateVerIter(cache));

  /* Avoid recursion if package is already marked for installation but
     try to fix it when it is broken.
   */
  if (cache[pkg].Mode == pkgDepCache::ModeInstall
      && !cache[pkg].InstBroken ())
    return;

  DBG ("+ %s", pkg.Name());

  /* Now mark it and return if that fails.  Both ModeInstall and
     ModeKeep are fine.  ModeKeep only happens for broken packages.
   */
  cache.MarkInstall (pkg, false);
  if (cache[pkg].Mode != pkgDepCache::ModeInstall
      && cache[pkg].Mode != pkgDepCache::ModeKeep)
    return;

  /* Try to satisfy dependencies.  We can't use MarkInstall with
     AutoInst == true since we don't like how it handles conflicts,
     and we have our own way of uninstalling packages.

     The code below is lifted from pkgDepCache::MarkInstall.  Sorry
     for introducing this mess here.
  */

  pkgCache::DepIterator Dep = cache[pkg].InstVerIter(cache).DependsList();
  for (; Dep.end() != true;)
    {
      // Grok or groups
      pkgCache::DepIterator Start = Dep;
      bool Result = true;
      unsigned Ors = 0;
      for (bool LastOR = true; Dep.end() == false && LastOR == true;
           Dep++,Ors++)
        {
          LastOR = (Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or;

          if ((cache[Dep] & pkgDepCache::DepInstall) == pkgDepCache::DepInstall)
            Result = false;
        }
      
      // Dep is satisfied okay.
      if (Result == false)
        continue;

      /* Check if this dep should be consider for install. If it is a user
         defined important dep and we are installed a new package then 
         it will be installed. Otherwise we only worry about critical deps */
      if (cache.IsImportantDep(Start) == false)
        continue;

      if (pkg->CurrentVer != 0 && Start.IsCritical() == false)
        continue;
      
      /* If we are in an or group locate the first or that can 
         succeed. We have already cached this.. */
      for (; Ors > 1 
             && (cache[Start] & pkgDepCache::DepCVer) != pkgDepCache::DepCVer;
           Ors--)
        Start++;

      /* This bit is for processing the possibilty of an install/upgrade
         fixing the problem */
      SPtrArray<pkgCache::Version *> List = Start.AllTargets();
      if ((cache[Start] & pkgDepCache::DepCVer) == pkgDepCache::DepCVer)
        {
          // Right, find the best version to install..
          pkgCache::Version **Cur = List;
          pkgCache::PkgIterator P = Start.TargetPkg();
          pkgCache::PkgIterator InstPkg(cache,0);
         
          // See if there are direct matches (at the start of the list)
          for (; *Cur != 0 && (*Cur)->ParentPkg == P.Index(); Cur++)
            {
              pkgCache &pkgcache = cache.GetCache ();
              pkgCache::PkgIterator Pkg(pkgcache,
                                        pkgcache.PkgP + (*Cur)->ParentPkg);
              if (cache[Pkg].CandidateVer != *Cur)
                continue;
              InstPkg = Pkg;
              break;
            }

          // Select the highest priority providing package
          if (InstPkg.end() == true)
            {
              pkgPrioSortList(cache,Cur);
              for (; *Cur != 0; Cur++)
                {
                  pkgCache &pkgcache = cache.GetCache ();
                  pkgCache::PkgIterator
                    Pkg(pkgcache,pkgcache.PkgP + (*Cur)->ParentPkg);
                  if (cache[Pkg].CandidateVer != *Cur)
                    continue;
                  InstPkg = Pkg;
                  break;
                }
            }
          
          if (InstPkg.end() == false)
            {
              mark_for_install_1 (InstPkg, level + 1);

              // Set the autoflag, after MarkInstall because
              // MarkInstall unsets it
              if (P->CurrentVer == 0)
                cache[InstPkg].Flags |= pkgCache::Flag::Auto;
            }

          continue;
        }

      /* For conflicts/replaces combinations we de-install the package
         with mark_for_remove, but only if it is a non-user package.
         (Conflicts and Replaces may not have or groups.)
      */
      if (Start->Type == pkgCache::Dep::Conflicts
          || Start->Type == pkgCache::Dep::Obsoletes)
        {
          for (pkgCache::Version **I = List; *I != 0; I++)
            {
              pkgCache::VerIterator Ver(cache,*I);
              pkgCache::PkgIterator target = Ver.ParentPkg();

              if (!is_user_package (Ver)
                  && package_replaces (pkg, target))
                mark_for_remove_1 (target, true);
            }
          continue;
        }
    }
}

static void
mark_for_install (pkgCache::PkgIterator &pkg)
{
  DBG ("INSTALL %s", pkg.Name());

  if (flag_use_apt_algorithms)
    {
      AptWorkerCache *awc = AptWorkerCache::GetCurrent ();
      pkgDepCache &Cache = *(awc->cache);
      pkgDepCache::StateCache &State = Cache[pkg];

      pkgProblemResolver Fix(&Cache);

      Fix.Clear(pkg);
      Fix.Protect(pkg);   

      Cache.MarkInstall(pkg,false);
      if (State.Install() == false)
        {
          if (pkg->CurrentVer && pkg.CurrentVer().Downloadable())
            Cache.SetReInstall(pkg,true);
        } 

      // Install it with autoinstalling enabled (if we not respect the minial
      // required deps or the policy)
      if (State.InstBroken() == true || State.InstPolicyBroken() == true)
        Cache.MarkInstall(pkg,true);

      Fix.InstallProtect();
      if (Fix.Resolve(true) == false)
         _error->Discard();
    }
  else
    {
      mark_for_install_1 (pkg, 0);
      fix_soft_packages ();
    }
}

/* Mark every upgradeable non-user package for installation.
 */
static void
mark_sys_upgrades ()
{
  AptWorkerCache *awc = AptWorkerCache::GetCurrent ();
  pkgDepCache &cache = *(awc->cache);

  DBG ("UPGRADE");

  for (pkgCache::PkgIterator p = cache.PkgBegin (); !p.end (); p++)
    {
      if (!p.CurrentVer().end()
          && !is_user_package (p.CurrentVer())
          && cache[p].Keep())
        mark_for_install_1 (p, 0);
    }
  fix_soft_packages ();
}

/* Mark the named package for installation.  This function also
   handles magic packages like "magic:sys".
*/

static bool
mark_named_package_for_install (const char *package)
{
  if (check_cache_state (package, true))
    return true;

  AptWorkerCache *awc = AptWorkerCache::GetCurrent ();
  if (!strcmp (package, "magic:sys"))
    {
      mark_sys_upgrades ();
      return true;
    }
  else
    {
      pkgDepCache &cache = *(awc->cache);
      pkgCache::PkgIterator pkg = cache.FindPkg (package);
      if (!pkg.end())
        {
          mark_for_install (pkg);
          return true;
        }
      else
        return false;
    }
}

/* Mark a package for removal and also remove as many of the packages
   that it depends on as possible.
*/
static void
mark_for_remove_1 (pkgCache::PkgIterator &pkg, bool soft)
{
  AptWorkerCache *awc = AptWorkerCache::GetCurrent ();
  pkgDepCache &cache = *(awc->cache);

  if (cache[pkg].Delete ())
    return;

  DBG ("- %s%s", pkg.Name(), soft? " (soft)" : "");

  cache.MarkDelete (pkg);
  cache[pkg].Flags &= ~pkgCache::Flag::Auto;
  awc->cache->extra_info[pkg->ID].soft = soft;

  if (!cache[pkg].Delete ())
    return;

  // Now try to remove all non-user, auto-installed dependencies of
  // this package.

  pkgCache::VerIterator cur = pkg.CurrentVer ();
  if (cur.end ())
    return;

  for (pkgCache::DepIterator dep = cur.DependsList(); dep.end() == false;
       dep++)
    {
      if (dep->Type == pkgCache::Dep::PreDepends ||
          dep->Type == pkgCache::Dep::Depends)
        {
          pkgCache::PkgIterator p = dep.TargetPkg ();
          if (!p.end ()
              && is_auto_package (p)
              && !p.CurrentVer().end()
              && !is_user_package (p.CurrentVer()))
            mark_for_remove_1 (p, true);
        }
    }
}

static void
mark_for_remove (pkgCache::PkgIterator &pkg)
{
  DBG ("REMOVE %s", pkg.Name());

  if (check_cache_state (pkg.Name (), false))
    return;

  if (flag_use_apt_algorithms)
    {
      AptWorkerCache *awc = AptWorkerCache::GetCurrent ();
      pkgDepCache &Cache = *(awc->cache);

      pkgProblemResolver Fix(&Cache);

      Fix.Clear(pkg);
      Fix.Protect(pkg);   

      Fix.Remove(pkg);
      Cache.MarkDelete (pkg,false);

      Fix.InstallProtect();
      if (Fix.Resolve(true) == false)
         _error->Discard();
    }
  else
    {
      mark_for_remove_1 (pkg, false);
      fix_soft_packages ();
    }
}

/* Getting the package record in a nicely parsable form.
 */

struct package_record {
  pkgRecords Recs;
  pkgRecords::Parser &P;
  pkgTagSection section;
  bool valid;

  package_record (pkgCache::VerIterator &ver);

  bool has (const char *tag);
  string get_string (const char *tag);
  char *get (const char *tag);
  int get_int (const char *tag, int def);

  string get_localized_string (const char *tag);
};

package_record::package_record (pkgCache::VerIterator &ver)
  : Recs (*(AptWorkerCache::GetCurrent ()->cache)),
    P (Recs.Lookup (ver.FileList ()))
{
  const char *start, *stop;
  P.GetRec (start, stop);

  /* NOTE: pkTagSection::Scan only succeeds when the record ends in
           two newlines, but pkgRecords::Parser::GetRec does not
           include the second newline in its returned region.
           However, that second newline is always there, so we just
           pass one more character to Scan.
  */
  
  valid = section.Scan (start, stop-start+1);
}

bool
package_record::has (const char *tag)
{
  unsigned pos;
  return valid && section.Find (tag, pos);
}

string
package_record::get_string (const char *tag)
{
  if (valid)
    return section.FindS (tag);
  else
    return string ("");
}
 
int
all_white_space (const char *text)
{
  while (*text)
    if (!isspace (*text++))
      return 0;
  return 1;
}

char *
package_record::get (const char *tag)
{
  if (!valid)
    return NULL;

  string res = get_string (tag);
  if (all_white_space (res.c_str ()))
    return NULL;
  else
    return g_strdup (res.c_str());
}

int
package_record::get_int (const char *tag, int def)
{
  if (!valid)
    return def;

  return section.FindI (tag, def);
}

string
package_record::get_localized_string (const char *tag)
{
  if (lc_messages && *lc_messages)
    {
      char *locale_tag = g_strdup_printf ("%s-%s", tag, lc_messages);

      if (has (locale_tag))
        {
          string res = get_string (locale_tag);
          g_free (locale_tag);
          return res;
        }
      g_free (locale_tag);
    }

  return get_string (tag);
}

/** COMMAND HANDLERS
 */

/* APTCMD_GET_PACKAGE_LIST 

   The get_package_list command can do some filtering and we have a
   few utility functions for implementing the necessary checks.  The
   check generally take cache iterators to identify a package or a
   version.
 */

bool
name_matches_pattern (pkgCache::PkgIterator &pkg,
                      const char *pattern)
{
  bool match = false;
  char **words = g_strsplit (pattern, " ", 0);
  int i;

  if (words == NULL)
    return false;

  for (i = 0; words[i] != NULL; i++)
    if (strcasestr (pkg.Name(), words[i]))
      match = true;
    else
      {
        match = false;
        break;
      }

  g_strfreev (words);
  return match;
}

bool
description_matches_pattern (pkgCache::VerIterator &ver,
                             const char *pattern)
{
  bool match = false;
  char **words = g_strsplit (pattern, " ", 0);
  package_record rec (ver);
  const char *desc = rec.P.LongDesc().c_str();
  int i;

  if (words == NULL)
    return false;

  for (i = 0; words[i] != NULL; i++)
    if (strcasestr (desc, words[i]))  // XXX - UTF8?
      match = true;
    else
      {
        match = false;
        break;
      }

  g_strfreev (words);
  return match;
}

static string
get_description (int summary_kind,
                 pkgCache::PkgIterator &pkg,
                 package_record &rec)
{
  string res;

  if (summary_kind == 1 && !pkg.CurrentVer().end())
    res = rec.get_localized_string ("Maemo-Upgrade-Description");

  if (res.empty())
    {
      /* XXX - support apt's own method of localizing descriptions as
               well.
      */
      res = rec.get_localized_string ("Description");
    }

  return res;
}

static string
get_short_description (int summary_kind,
                       pkgCache::PkgIterator &pkg,
                       package_record &rec)
{
  string res = get_description (summary_kind, pkg, rec);
  string::size_type pos = res.find('\n');
  if (pos != string::npos)
    return string (res,0,pos);
  return res;
}

static string
get_long_description (int summary_kind,
                      pkgCache::PkgIterator &pkg,
                      package_record &rec)
{
  return get_description (summary_kind, pkg, rec);
}

static char *
get_icon (package_record &rec)
{
  return rec.get ("Maemo-Icon-26");
}

struct flag_struct {
  const char *name;
  int flag;
} flag_names[] = {
  { "close-apps",       pkgflag_close_apps },
  { "suggest-backup",   pkgflag_suggest_backup },
  { "reboot",           pkgflag_reboot },
  { "system-update",    pkgflag_system_update },
  { "flash-and-reboot", pkgflag_flash_and_reboot },
  { NULL,               0 }
};

static int
get_flags (package_record &rec)
{
  int flags = 0;
  char *flag_string = rec.get ("Maemo-Flags");
  char *ptr = flag_string, *tok;
  while ((tok = strsep (&ptr, ",")))
    {
      for (int i = 0; flag_names[i].name != NULL; i++)
        if (tokens_equal (flag_names[i].name, tok))
          {
            flags |= flag_names[i].flag;
            break;
          }
    }
  g_free (flag_string);

  return flags;
}

static string
get_pretty_name (package_record &rec)
{
  return rec.get_localized_string ("Maemo-Display-Name");
}

static int64_t
get_required_free_space (package_record &rec)
{
  return 1024 * (int64_t) rec.get_int ("Maemo-Required-Free-Space", 0);
}

static void
encode_version_info (int summary_kind,
                     pkgCache::VerIterator &ver, bool include_size)
{
  package_record rec (ver);
  char *icon;

  response.encode_string (ver.VerStr ());
  if (include_size)
    response.encode_int64 (ver->InstalledSize);
  response.encode_string (ver.Section ());
  string pretty = get_pretty_name (rec);
  response.encode_string (pretty.empty()? NULL : pretty.c_str());
  pkgCache::PkgIterator pkg = ver.ParentPkg();
  response.encode_string 
    (get_short_description (summary_kind, pkg, rec).c_str());
  icon = get_icon (rec);
  response.encode_string (icon);
  g_free (icon);
}

static void
encode_empty_version_info (bool include_size)
{
  response.encode_string (NULL);
  if (include_size)
    response.encode_int64 (0);
  response.encode_string (NULL);
  response.encode_string (NULL);
  response.encode_string (NULL);
  response.encode_string (NULL);
}

void
cmd_get_package_list ()
{
  AptWorkerCache *awc = AptWorkerCache::GetCurrent ();
  bool only_user = request.decode_int ();
  bool only_installed = request.decode_int ();
  bool only_available = request.decode_int ();
  const char *pattern = request.decode_string_in_place ();
  bool show_magic_sys = request.decode_int ();

  if (!ensure_cache (true))
    {
      response.encode_int (0);
      return;
    }

  response.encode_int (1);
  pkgDepCache &cache = *(awc->cache);

  for (pkgCache::PkgIterator pkg = cache.PkgBegin(); !pkg.end (); pkg++)
    {
      int flags = 0;

      /* Get installed and candidate iterators for current package */
      pkgCache::VerIterator installed = pkg.CurrentVer ();
      pkgCache::VerIterator candidate = cache[pkg].CandidateVerIter(cache);

      // s