/*

 * Copyright (C) 2008  Kristian Høgsberg <krh@redhat.com>

 * Copyright (C) 2008  Red Hat, Inc

 * Copyright (C) 2009, 2011, 2012, 2014, 2016  J. Ali Harlow <ali@juiblex.co.uk>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * 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 Street, Fifth Floor, Boston, MA 02110-1301 USA.

 */

#define _GNU_SOURCE

#include <stdlib.h>

#include <stdio.h>

#include <stdarg.h>

#include <string.h>

#include <errno.h>

#include <unistd.h>

#include <razor.h>

#include <glib.h>

#include <gio/gio.h>

#include "config.h"

#include "plover/plover.h"

#include "plover/transaction.h"

#include "plover/uri-handler.h"

#if HAVE_DLFCN_H

#define DEBUG_HOOK_RAZOR_SET		/* For debugging */

#endif

static char *rpm_filename(const char *name,const char *version,const char *arch)

{

    const char *v;

    v=strchr(version,':');	      /* Skip epoch */

    if (v)

	v++;

    else

	v=version;

    return g_strconcat(name,"-",v,".",arch,".rpm",NULL);

}

/*

 * Returns 0 on success, -1 on failure and 1 if a RAZOR_INSTALL_ACTION_COMMIT

 * is met (in which case the action is consumed).

 */

int plover_run_transaction(struct razor_transaction *trans,

  struct razor_install_iterator *ii,const char *root_uri,

  struct razor_set *system,PloverPackageSet *next,PloverRepository *upstream,

  struct razor_atomic *atomic,struct razor_relocations *relocations,

  enum razor_stage_type stage,GCancellable *cancellable)

{

    struct razor_package *pkg;

    enum razor_install_action action;

    struct razor_rpm *rpm;

    struct razor_error *error=NULL;

    const char *name,*version,*arch;

    gchar *t;

    int r,count;

    GError *tmp_error=NULL;

    PloverPackage *package;

    g_return_val_if_fail(plover__uri_validate(root_uri),-1);

    plover__uri_handler_init();

    if (!*root_uri)

	root_uri="file:/";

    switch(stage)

    {

	case RAZOR_STAGE_SCRIPTS_PRE:

	    printf("Running pre-transaction scripts\n");

	    break;

	case RAZOR_STAGE_FILES:

	    printf("Running Transaction\n");

	    break;

	case RAZOR_STAGE_SCRIPTS_POST:

	    printf("Running post-transaction scripts\n");

	    break;

	default:

	    /* Keep the compiler happy */

	    break;

    }

    while (razor_install_iterator_next(ii,&pkg,&action,&count))

    {

	if (g_cancellable_is_cancelled(cancellable))

	{

	    razor_atomic_abort(atomic,PLOVER_GENERAL_ERROR,

	      PLOVER_GENERAL_ERROR_CANCELLED,"Operation was cancelled");

	    return -1;

	}

	if (action==RAZOR_INSTALL_ACTION_REMOVE)

	{

	    razor_package_get_details(system,pkg,RAZOR_DETAIL_NAME,&name,

	      RAZOR_DETAIL_LAST);

	    if (stage==RAZOR_STAGE_FILES)

		printf("  Removing : %s ",name);

	    r=razor_package_remove(system,plover_package_set_get_razor(next),

	      atomic,pkg,root_uri,count,stage);

	    if (stage==RAZOR_STAGE_FILES)

		printf("\n");

	}

	else if (action==RAZOR_INSTALL_ACTION_ADD)

	{

	    package=plover_package_set_lookup(next,pkg);

	    rpm=plover_repository_open_rpm(upstream,package,&tmp_error);

	    if (!rpm)

	    {

		plover_propagate_g_error(&error,tmp_error);

		razor_atomic_propagate_error(atomic,error,NULL);

		return -1;

	    }

	    if (stage==RAZOR_STAGE_FILES)

		printf("  Installing : %s ",plover_package_get_name(package));

	    if (relocations)

		razor_rpm_set_relocations(rpm,relocations);

	    razor_transaction_fixup_package(trans,pkg,rpm);

	    r=razor_rpm_install(rpm,atomic,root_uri,1,stage);

	    razor_rpm_close(rpm);

	    if (stage==RAZOR_STAGE_FILES)

		printf("\n");

	}

	else if (action==RAZOR_INSTALL_ACTION_COMMIT)

	    return 1;

	else

	    r=0;

	if (razor_atomic_in_error_state(atomic))

	    return -1;

	else if (r)

	{

	    if (action==RAZOR_INSTALL_ACTION_REMOVE)

	    {

		razor_package_get_details(system,pkg,RAZOR_DETAIL_NAME,&name,

		  RAZOR_DETAIL_VERSION,&version,RAZOR_DETAIL_ARCH,&arch,

		  RAZOR_DETAIL_LAST);

	    }

	    else

	    {

		package=plover_package_set_lookup(next,pkg);

		name=plover_package_get_name(package);

		version=plover_package_get_version(package);

		arch=plover_package_get_arch(package);

	    }

	    /*

	     * If a pre or preun script fails, then we should

	     * treat that as a fatal error. post and postun

	     * script failures are treated as warnings. Be

	     * nice and tell the user _which_ script failed.

	     */

	    if (stage==RAZOR_STAGE_SCRIPTS_PRE)

	    {

		t=g_strconcat(action==RAZOR_INSTALL_ACTION_ADD?

		  "%pre":"%preun","(",name,"-",version,".",arch,

		  ") scriptlet failed",NULL);

		fprintf(stderr,"error: %s, exit status %d\n",t,r);

		razor_atomic_abort(atomic,PLOVER_SCRIPTLET_ERROR,r,t);

		g_free(t);

		return -1;

	    }

	    else

		fprintf(stderr,

		  "warning: %s(%s-%s.%s) scriptlet failed, exit status %d\n",

		  action==RAZOR_INSTALL_ACTION_ADD?"%post":"%postun",

		  name,version,arch,r);

	}

    }

    return 0;

}

gboolean plover_install_uri(const char *base_uri,const char *prefix,char **pkgs,

  GError **error)

{

    gboolean retval;

    PloverTransaction *transaction;

    g_return_val_if_fail(plover__uri_validate(base_uri),FALSE);

    transaction=plover_transaction_new_install_uri(base_uri,prefix,pkgs,error);

    if (!transaction)

	return FALSE;

    retval=plover_transaction_commit(transaction,NULL,error);

    g_object_unref(transaction);

    return retval;

}

gboolean plover_install(const char *base,const char *prefix,char **pkgs,

  GError **error)

{

    gboolean retval;

    GFile *file;

    gchar *base_uri;

    file=g_file_new_for_path(base);

    base_uri=g_file_get_uri(file);

    g_object_unref(file);

    retval=plover_install_uri(base_uri,prefix,pkgs,error);

    g_free(base_uri);

    return retval;

}

gboolean plover_update_uri(const char *base_uri,const char *prefix,char **pkgs,

  GError **error)

{

    gboolean retval;

    PloverTransaction *transaction;

    g_return_val_if_fail(plover__uri_validate(base_uri),FALSE);

    transaction=plover_transaction_new_update_uri(base_uri,prefix,pkgs,error);

    if (!transaction)

	return FALSE;

    retval=plover_transaction_commit(transaction,NULL,error);

    g_object_unref(transaction);

    return retval;

}

gboolean plover_update(const char *base,const char *prefix,char **pkgs,

  GError **error)

{

    gboolean retval;

    PloverTransaction *transaction;

    transaction=plover_transaction_new_update(base,prefix,pkgs,error);

    if (!transaction)

	return FALSE;

    retval=plover_transaction_commit(transaction,NULL,error);

    g_object_unref(transaction);

    return retval;

}

gboolean plover_remove(char **pkgs,GError **error)

{

    gboolean retval;

    GError *tmp_error=NULL;

    PloverTransaction *transaction;

    transaction=plover_transaction_new_remove(pkgs,&tmp_error);

    if (!transaction)

    {

	retval=g_error_matches(tmp_error,PLOVER_POSIX_ERROR,ENOENT);

	if (retval)

	{

	    g_error_free(tmp_error);

	    if (pkgs)

	    {

		g_set_error(error,PLOVER_GENERAL_ERROR,

		  PLOVER_GENERAL_ERROR_NO_SUCH_PACKAGE,"%s: %s",pkgs[0],

		  "Package not found");

		retval=FALSE;

	    }

	}

	else

	    g_propagate_error(error,tmp_error);

    }

    else

    {

	retval=plover_transaction_commit(transaction,NULL,error);

	g_object_unref(transaction);

    }

    return retval;

}

/*

 * Returns:

 *	 0 if there are any installed files that don't match prefix, or

 *	-1 if there are no installed files at all, or

 * 	 1 if there are installed files and they all match prefix.

 */

int plover_installed_files_match_prefix(const char *prefix)

{

    int len,matches=-1;

    const char *name;

    const char *install_root;

    struct razor_set *set;

    struct razor_package *package;

    struct razor_package_iterator *pi;

    struct razor_file_iterator *fi;

    plover__uri_handler_init();

    len=strlen(prefix);

    while(len && prefix[len-1]=='/')

	len--;

    install_root=g_getenv("RAZOR_ROOT");

    if (!install_root)

	install_root="file:///";

    set=razor_root_open_read_only(install_root,NULL);

    if (set)

    {

	pi=razor_package_iterator_create(set);

	while (matches &&

	  razor_package_iterator_next(pi,&package,RAZOR_DETAIL_LAST))

	{

	    fi=razor_file_iterator_create(set,package,0);

	    while (matches && razor_file_iterator_next(fi,&name))

	    {

		if (strncmp(name,prefix,len) ||

		  name[len]!='\0' && name[len]!='/')

		    matches=0;

		else

		    matches=1;

	    }

	    razor_file_iterator_destroy(fi);

	}

	razor_package_iterator_destroy(pi);

	razor_set_unref(set);

    }

    return matches;

}

#ifdef DEBUG_HOOK_RAZOR_SET

#include <fcntl.h>

#include <dlfcn.h>

struct razor_set_counter

{

    struct razor_set *set;

    int count;

};

static GList *counters;

static struct razor_set_counter *get_razor_set_counter(struct razor_set *set)

{

    GList *lnk;

    struct razor_set_counter *counter;

    for(lnk=counters;lnk;lnk=lnk->next)

    {

	counter=lnk->data;

	if (counter->set==set)

	    return counter;

    }

    counter=g_new(struct razor_set_counter,1);

    counter->set=set;

    counter->count=0;

    counters=g_list_prepend(counters,counter);

    return counter;

}

static void dump_razor_set_ref(struct razor_set *set)

{

    FILE *fp;

    gchar *filename;

    void *bt[16];

    size_t len;

    struct razor_set_counter *counter;

    filename=g_strdup_printf("razor-set-%p",set);

    fp=fopen(filename,"a");

    g_free(filename);

    counter=get_razor_set_counter(set);

    counter->count++;

    fprintf(fp,"Ref %p (%d refs)\n",set,counter->count);

    fflush(fp);

    len=backtrace(bt,G_N_ELEMENTS(bt));

    backtrace_symbols_fd(bt,len,fileno(fp));

    fprintf(fp,"\n");

    fclose(fp);

}

static void dump_razor_set_unref(struct razor_set *set)

{

    FILE *fp;

    gchar *filename;

    void *bt[16];

    size_t len;

    struct razor_set_counter *counter;

    filename=g_strdup_printf("razor-set-%p",set);

    fp=fopen(filename,"a");

    g_free(filename);

    counter=get_razor_set_counter(set);

    --counter->count;

    fprintf(fp,"Unref %p (%d refs)\n",set,counter->count);

    fflush(fp);

    len=backtrace(bt,G_N_ELEMENTS(bt));

    backtrace_symbols_fd(bt,len,fileno(fp));

    fprintf(fp,"\n");

    fclose(fp);

}

static void dump_razor_set_peek(struct razor_set *set)

{

    FILE *fp;

    gchar *filename;

    void *bt[16];

    size_t len;

    struct razor_set_counter *counter;

    filename=g_strdup_printf("razor-set-%p",set);

    fp=fopen(filename,"a");

    g_free(filename);

    counter=get_razor_set_counter(set);

    fprintf(fp,"Peek %p (%d refs)\n",set,counter->count);

    fflush(fp);

    len=backtrace(bt,G_N_ELEMENTS(bt));

    backtrace_symbols_fd(bt,len,fileno(fp));

    fprintf(fp,"\n");

    fclose(fp);

}

struct razor_set *razor_set_create_without_root(void)

{

    static struct razor_set *(*next)(void);

    struct razor_set *set;

    if (!next)

	next=dlsym(RTLD_NEXT,"razor_set_create_without_root");

    set=(*next)();

    dump_razor_set_ref(set);

    return set;

}

struct razor_set *razor_set_create(void)

{

    static struct razor_set *(*next)(void);

    struct razor_set *set;

    if (!next)

	next=dlsym(RTLD_NEXT,"razor_set_create");

    set=(*next)();

    dump_razor_set_ref(set);

    return set;

}

struct razor_set *razor_set_open(const char *uri,enum razor_set_flags flags,

  struct razor_error **error)

{

    static struct razor_set *(*next)(const char *uri,enum razor_set_flags flags,

      struct razor_error **error);

    struct razor_set *set;

    g_return_val_if_fail(plover__uri_validate(uri),NULL);

    if (!next)

	next=dlsym(RTLD_NEXT,"razor_set_open");

    set=(*next)(uri,flags,error);

    dump_razor_set_ref(set);

    return set;

}

void razor_set_unref(struct razor_set *set)

{

    static void (*next)(struct razor_set *set);

    if (!next)

	next=dlsym(RTLD_NEXT,"razor_set_unref");

    if (!set)

	abort();

    dump_razor_set_unref(set);

    (*next)(set);

}

struct razor_set *razor_set_ref(struct razor_set *set)

{

    static struct razor_set *(*next)(struct razor_set *set);

    if (!next)

	next=dlsym(RTLD_NEXT,"razor_set_ref");

    (*next)(set);

    dump_razor_set_ref(set);

    return set;

}

struct razor_set *

  razor_install_iterator_commit_set(struct razor_install_iterator *ii)

{

    static struct razor_set *(*next)(struct razor_install_iterator *ii);

    struct razor_set *set;

    if (!next)

	next=dlsym(RTLD_NEXT,"razor_install_iterator_commit_set");

    set=(*next)(ii);

    dump_razor_set_ref(set);

    return set;

}

struct razor_set *razor_transaction_commit(struct razor_transaction *trans)

{

    static struct razor_set *(*next)(struct razor_transaction *trans);

    struct razor_set *set;

    if (!next)

	next=dlsym(RTLD_NEXT,"razor_transaction_commit");

    set=(*next)(trans);

    dump_razor_set_ref(set);

    return set;

}

struct razor_set *razor_importer_finish(struct razor_importer *importer)

{

    static struct razor_set *(*next)(struct razor_importer *importer);

    struct razor_set *set;

    if (!next)

	next=dlsym(RTLD_NEXT,"razor_importer_finish");

    set=(*next)(importer);

    dump_razor_set_ref(set);

    return set;

}

struct razor_set *razor_root_open_read_only(const char *root_uri,

  struct razor_error **error)

{

    static struct razor_set *(*next)(const char *root_uri,

      struct razor_error **error);

    struct razor_set *set;

    g_return_val_if_fail(plover__uri_validate(root_uri),NULL);

    if (!next)

	next=dlsym(RTLD_NEXT,"razor_root_open_read_only");

    set=(*next)(root_uri,error);

    dump_razor_set_ref(set);

    return set;

}

struct razor_set *razor_root_get_system_set(struct razor_root *root)

{

    static struct razor_set *(*next)(struct razor_root *root);

    struct razor_set *set;

    if (!next)

	next=dlsym(RTLD_NEXT,"razor_root_get_system_set");

    set=(*next)(root);

    dump_razor_set_peek(set);

    return set;

}

#endif /* DEBUG_HOOK_RAZOR_SET */