path: root/src/userinstalled.c

/*
 * Copyright (c) 2017, SUSE LLC.
 *
 * This program is licensed under the BSD license, read LICENSE.BSD
 * for further information
 */

/* Functions that help getting/setting userinstalled packages. */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

#include "solver.h"
#include "solver_private.h"
#include "bitmap.h"
#include "pool.h"
#include "util.h"
#include "poolarch.h"
#include "linkedpkg.h"

static int
get_userinstalled_cmp(const void *ap, const void *bp, void *dp)
{
  return *(Id *)ap - *(Id *)bp;
}

static int
get_userinstalled_cmp_names(const void *ap, const void *bp, void *dp)
{
  Pool *pool = dp;
  return strcmp(pool_id2str(pool, *(Id *)ap), pool_id2str(pool, *(Id *)bp));
}

static int
get_userinstalled_cmp_namearch(const void *ap, const void *bp, void *dp)
{
  Pool *pool = dp;
  int r;
  r = strcmp(pool_id2str(pool, ((Id *)ap)[0]), pool_id2str(pool, ((Id *)bp)[0]));
  if (r)
    return r;
  return strcmp(pool_id2str(pool, ((Id *)ap)[1]), pool_id2str(pool, ((Id *)bp)[1]));
}

static void
get_userinstalled_sort_uniq(Pool *pool, Queue *q, int flags)
{
  Id lastp = -1, lasta = -1;
  int i, j;
  if (q->count < ((flags & GET_USERINSTALLED_NAMEARCH) ? 4 : 2))
    return;
  if ((flags & GET_USERINSTALLED_NAMEARCH) != 0)
    solv_sort(q->elements, q->count / 2, 2 * sizeof(Id), get_userinstalled_cmp_namearch, pool);
  else if ((flags & GET_USERINSTALLED_NAMES) != 0)
    solv_sort(q->elements, q->count, sizeof(Id), get_userinstalled_cmp_names, pool);
  else
    solv_sort(q->elements, q->count, sizeof(Id), get_userinstalled_cmp, 0);
  if ((flags & GET_USERINSTALLED_NAMEARCH) != 0)
    {
      for (i = j = 0; i < q->count; i += 2)
	if (q->elements[i] != lastp || q->elements[i + 1] != lasta)
	  {
	    q->elements[j++] = lastp = q->elements[i];
	    q->elements[j++] = lasta = q->elements[i + 1];
	  }
    }
  else
    {
      for (i = j = 0; i < q->count; i++)
	if (q->elements[i] != lastp)
	  q->elements[j++] = lastp = q->elements[i];
    }
  queue_truncate(q, j);
}

static void
namearch2solvables(Pool *pool, Queue *q, Queue *qout, int job)
{
  int i;
  if (!pool->installed)
    return;
  for (i = 0; i < q->count; i += 2)
    {
      Id p, pp, name = q->elements[i], arch = q->elements[i + 1];
      FOR_PROVIDES(p, pp, name)
	{
	  Solvable *s = pool->solvables + p;
	  if (s->repo != pool->installed || s->name != name || (arch && s->arch != arch))
	    continue;
	  if (job)
	    queue_push(qout, job);
	  queue_push(qout, p);
	}
    }
}

void
solver_get_userinstalled(Solver *solv, Queue *q, int flags)
{
  Pool *pool = solv->pool;
  Id p, p2, pp;
  Solvable *s;
  Repo *installed = solv->installed;
  int i, j;
  Map userinstalled;
  
  map_init(&userinstalled, 0);
  queue_empty(q);
  /* first process jobs */
  for (i = 0; i < solv->job.count; i += 2)
    {
      Id how = solv->job.elements[i];
      Id what, select;
      if (installed && (how & SOLVER_JOBMASK) == SOLVER_USERINSTALLED)
	{
	  if (!userinstalled.size)
	    map_grow(&userinstalled, installed->end - installed->start);
	  what = solv->job.elements[i + 1];
	  select = how & SOLVER_SELECTMASK;
	  if (select == SOLVER_SOLVABLE_ALL || (select == SOLVER_SOLVABLE_REPO && what == installed->repoid))
	    {
	      FOR_REPO_SOLVABLES(installed, p, s)
	        MAPSET(&userinstalled, p - installed->start);
	    }
	  FOR_JOB_SELECT(p, pp, select, what)
	    if (pool->solvables[p].repo == installed)
	      MAPSET(&userinstalled, p - installed->start);
	  continue;
	}
      if ((how & SOLVER_JOBMASK) != SOLVER_INSTALL)
	continue;
      if ((how & SOLVER_NOTBYUSER) != 0)
	continue;
      what = solv->job.elements[i + 1];
      select = how & SOLVER_SELECTMASK;
      FOR_JOB_SELECT(p, pp, select, what)
        if (solv->decisionmap[p] > 0)
	  {
	    queue_push(q, p);
#ifdef ENABLE_LINKED_PKGS
	    if (has_package_link(pool, pool->solvables + p))
	      {
		int j;
		Queue lq;
		queue_init(&lq);
		find_package_link(pool, pool->solvables + p, 0, &lq, 0, 0);
		for (j = 0; j < lq.count; j++)
		  if (solv->decisionmap[lq.elements[j]] > 0)
		    queue_push(q, lq.elements[j]);
	      }
#endif
	  }
    }
  /* now process updates of userinstalled packages */
  if (installed && userinstalled.size)
    {
      for (i = 1; i < solv->decisionq.count; i++)
	{
	  p = solv->decisionq.elements[i];
	  if (p <= 0)
	    continue;
	  s = pool->solvables + p;
	  if (!s->repo)
	    continue;
	  if (s->repo == installed)
	    {
	      if (MAPTST(&userinstalled, p - installed->start))
		queue_push(q, p);
	      continue;
	    }
	  /* new package, check if we replace a userinstalled one */
	  FOR_PROVIDES(p2, pp, s->name)
	    {
	      Solvable *ps = pool->solvables + p2;
	      if (p2 == p || ps->repo != installed || !MAPTST(&userinstalled, p2 - installed->start))
		continue;
	      if (!pool->implicitobsoleteusesprovides && s->name != ps->name)
		continue;
	      if (pool->implicitobsoleteusescolors && !pool_colormatch(pool, s, ps))
		continue;
	      queue_push(q, p);
	      break;
	    }
	  if (!p2 && s->repo != installed && s->obsoletes)
	    {
	      Id obs, *obsp = s->repo->idarraydata + s->obsoletes;
	      while ((obs = *obsp++) != 0)
		{
		  FOR_PROVIDES(p2, pp, obs)
		    {
		      Solvable *ps = pool->solvables + p2;
		      if (p2 == p || ps->repo != installed || !MAPTST(&userinstalled, p2 - installed->start))
			continue;
		      if (!pool->obsoleteusesprovides && !pool_match_nevr(pool, ps, obs))
			continue;
		      if (pool->obsoleteusescolors && !pool_colormatch(pool, s, ps)) 
			continue;
		      queue_push(q, p); 
		      break;
		    }
		  if (p2)
		    break;
		}
	    }
	}
    }
  map_free(&userinstalled);

  /* convert to desired output format */
  if ((flags & GET_USERINSTALLED_NAMEARCH) != 0)
    {
      int qcount = q->count;
      queue_insertn(q, 0, qcount, 0);
      for (i = j = 0; i < qcount; i++)
	{
	  s = pool->solvables + q->elements[i + qcount];
	  q->elements[j++] = s->name;
	  q->elements[j++] = s->arch;
	}
    }
  else if ((flags & GET_USERINSTALLED_NAMES) != 0)
    {
      for (i = 0; i < q->count; i++)
	{
	  s = pool->solvables + q->elements[i];
	  q->elements[i] = s->name;
	}
    }
  /* sort and unify */
  get_userinstalled_sort_uniq(pool, q, flags);

  /* invert if asked for */
  if ((flags & GET_USERINSTALLED_INVERTED) != 0)
    {
      /* first generate queue with all installed packages */
      Queue invq;
      queue_init(&invq);
      for (i = 1; i < solv->decisionq.count; i++)
	{
	  p = solv->decisionq.elements[i];
	  if (p <= 0)
	    continue;
	  s = pool->solvables + p;
	  if (!s->repo)
	    continue;
	  if ((flags & GET_USERINSTALLED_NAMEARCH) != 0)
	    queue_push2(&invq, s->name, s->arch);
	  else if ((flags & GET_USERINSTALLED_NAMES) != 0)
	    queue_push(&invq, s->name);
	  else
	    queue_push(&invq, p);
	}
      /* push q on invq, just in case... */
      queue_insertn(&invq, invq.count, q->count, q->elements);
      get_userinstalled_sort_uniq(pool, &invq, flags);
      /* subtract queues (easy as they are sorted and invq is a superset of q) */
      if ((flags & GET_USERINSTALLED_NAMEARCH) != 0)
	{
	  if (q->count)
	    {
	      for (i = j = 0; i < invq.count; i += 2)
		if (invq.elements[i] == q->elements[j] && invq.elements[i + 1] == q->elements[j + 1])
		  {
		    invq.elements[i] = invq.elements[i + 1] = 0;
		    j += 2;
		    if (j >= q->count)
		      break;
		  }
	      queue_empty(q);
	    }
	  for (i = 0; i < invq.count; i += 2)
	    if (invq.elements[i])
	      queue_push2(q, invq.elements[i], invq.elements[i + 1]);
	}
      else
	{
	  if (q->count)
	    {
	      for (i = j = 0; i < invq.count; i++)
		if (invq.elements[i] == q->elements[j])
		  {
		    invq.elements[i] = 0;
		    if (++j >= q->count)
		      break;
		  }
	      queue_empty(q);
	    }
	  for (i = 0; i < invq.count; i++)
	    if (invq.elements[i])
	      queue_push(q, invq.elements[i]);
	}
      queue_free(&invq);
    }
}

void
pool_add_userinstalled_jobs(Pool *pool, Queue *q, Queue *job, int flags)
{
  int i;

  if ((flags & GET_USERINSTALLED_INVERTED) != 0)
    {
      Queue invq;
      Id p, lastid;
      Solvable *s;
      int bad;
      if (!pool->installed)
	return;
      queue_init(&invq);
      if ((flags & GET_USERINSTALLED_NAMEARCH) != 0)
	flags &= ~GET_USERINSTALLED_NAMES;	/* just in case */
      FOR_REPO_SOLVABLES(pool->installed, p, s)
	queue_push(&invq, flags & GET_USERINSTALLED_NAMES ? s->name : p);
      if ((flags & GET_USERINSTALLED_NAMEARCH) != 0)
	{
	  /* for namearch we convert to packages */
	  namearch2solvables(pool, q, &invq, 0);
	  get_userinstalled_sort_uniq(pool, &invq, flags);
	  namearch2solvables(pool, q, &invq, 0);
	  flags = 0;
	}
      else
	{
	  queue_insertn(&invq, invq.count, q->count, q->elements);
	  get_userinstalled_sort_uniq(pool, &invq, flags);
	  /* now the fun part, add q again, sort, and remove all dups */
	  queue_insertn(&invq, invq.count, q->count, q->elements);
	}
      if (invq.count > 1)
	{
	  if ((flags & GET_USERINSTALLED_NAMES) != 0)
	    solv_sort(invq.elements, invq.count, sizeof(Id), get_userinstalled_cmp_names, pool);
	  else
	    solv_sort(invq.elements, invq.count, sizeof(Id), get_userinstalled_cmp, 0);
	}
      lastid = -1;
      bad = 1;
      for (i = 0; i < invq.count; i++)
	{
	  if (invq.elements[i] == lastid)
	    {
	      bad = 1;
	      continue;
	    }
	  if (!bad)
	    queue_push2(job, SOLVER_USERINSTALLED | (flags & GET_USERINSTALLED_NAMES ? SOLVER_SOLVABLE_NAME : SOLVER_SOLVABLE), lastid);
	  bad = 0;
	  lastid = invq.elements[i];
	}
      if (!bad)
	queue_push2(job, SOLVER_USERINSTALLED | (flags & GET_USERINSTALLED_NAMES ? SOLVER_SOLVABLE_NAME : SOLVER_SOLVABLE), lastid);
      queue_free(&invq);
    }
  else
    {
      if (flags & GET_USERINSTALLED_NAMEARCH)
	namearch2solvables(pool, q, job, SOLVER_USERINSTALLED | SOLVER_SOLVABLE);
      else
	{
	  for (i = 0; i < q->count; i++)
	    queue_push2(job, SOLVER_USERINSTALLED | (flags & GET_USERINSTALLED_NAMES ? SOLVER_SOLVABLE_NAME : SOLVER_SOLVABLE), q->elements[i]);
	}
    }
}