/*

 * Copyright (C) 2010-2012, 2014  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.

 */

#include "config.h"

#include <stdlib.h>

#include <string.h>

#include <fcntl.h>

#include <errno.h>

#include <unistd.h>

#include <glib-object.h>

#include <razor.h>

#include "plover/plover.h"

#include "plover/package.h"

#include "plover/packageset.h"

#include "plover/uri-handler.h"

G_DEFINE_TYPE(PloverPackageSet,plover_package_set,G_TYPE_OBJECT);

typedef struct _PloverPackageSetPrivate {

    gchar *root_uri;

    struct razor_root *root;

    struct razor_set *set;

    GSList *packages;

    int no_details;

    gchar *guessed_prefix;

} PloverPackageSetPrivate;

#define PLOVER_PACKAGE_SET_GET_PRIVATE(obj)\

				G_TYPE_INSTANCE_GET_PRIVATE(obj,\

				  PLOVER_TYPE_PACKAGE_SET,\

				  PloverPackageSetPrivate)

enum {

    CHANGED=0,

    N_SIGNALS

};

static guint signals[N_SIGNALS];

static void plover_package_set_finalize(GObject *obj)

{

    PloverPackageSetPrivate *priv=PLOVER_PACKAGE_SET_GET_PRIVATE(obj);

    g_free(priv->guessed_prefix);

    g_free(priv->root_uri);

    G_OBJECT_CLASS(plover_package_set_parent_class)->finalize(obj);

}

static void plover_package_set_dispose(GObject *obj)

{

    PloverPackageSet *set=PLOVER_PACKAGE_SET(obj);

    PloverPackageSetPrivate *priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    if (priv->packages)

    {

	g_slist_foreach(priv->packages,(GFunc)g_object_unref,NULL);

	g_slist_free(priv->packages);

	priv->packages=NULL;

    }

    plover_package_set_close(set);

    G_OBJECT_CLASS(plover_package_set_parent_class)->dispose(obj);

}

static void plover_package_set_class_init(PloverPackageSetClass *klass)

{

    GObjectClass *oclass=G_OBJECT_CLASS(klass);

    plover__uri_handler_init();

    oclass->finalize=plover_package_set_finalize;

    oclass->dispose=plover_package_set_dispose;

    g_type_class_add_private(klass,sizeof(PloverPackageSetPrivate));

    signals[CHANGED]=g_signal_newv("changed",

      G_TYPE_FROM_CLASS(klass),G_SIGNAL_RUN_LAST,NULL,NULL,NULL,

      g_cclosure_marshal_VOID__VOID,G_TYPE_NONE,0,NULL);

}

static void plover_package_set_init(PloverPackageSet *set)

{

    PloverPackageSetPrivate *priv;

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    priv->no_details=-1;

}

PloverPackageSet *plover_package_set_new(void)

{

    return g_object_new(PLOVER_TYPE_PACKAGE_SET,NULL);

}

void plover_package_set_close(PloverPackageSet *set)

{

    PloverPackageSetPrivate *priv;

    g_return_if_fail(PLOVER_IS_PACKAGE_SET(set));

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    if (priv->set)

    {

	razor_set_unref(priv->set);

	priv->set=NULL;

    }

    if (priv->root)

    {

	razor_root_close(priv->root);

	priv->root=NULL;

    }

    if (priv->root_uri)

    {

	g_free(priv->root_uri);

	priv->root_uri=NULL;

    }

}

gboolean plover_package_set_open(PloverPackageSet *set,const char *root_uri,

  gboolean exclusive,GError **err)

{

    gboolean incompatible_lock=FALSE;

    struct razor_root *root=NULL;

    struct razor_set *system=NULL;

    PloverPackageSetPrivate *priv;

    struct razor_error *error=NULL;

    g_return_val_if_fail(PLOVER_IS_PACKAGE_SET(set),FALSE);

    g_return_val_if_fail(plover__uri_validate(root_uri),FALSE);

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    if (!root_uri || !*root_uri)

	root_uri="file:/";

    /*

     * If we're opening a different root_uri, then we can simply open the

     * new root first and then close the old root if we're successful.

     * Otherwise, if we're changing the lock type we have to close the

     * old lock first which allows for the possibility of failing to

     * re-open the old root on failure. That's unfortunate but appears

     * unavoidable; MS-Windows doesn't appear to have the ability to

     * either upgrade or downgrade a file lock.

     */

    if (!g_strcmp0(root_uri,priv->root_uri))

    {

	incompatible_lock=!priv->root!=!exclusive;

	if (incompatible_lock)

	    plover_package_set_close(set);

	else

	    return TRUE;

    }

    if (exclusive)

    {

	root=razor_root_open(root_uri,NULL);

	if (!root)

	{

	    if (razor_root_create(root_uri,&error))

	    {

		if (razor_error_get_domain(error)==RAZOR_GENERAL_ERROR &&

		  razor_error_get_code(error)==

		  RAZOR_GENERAL_ERROR_DATABASE_EXISTS)

		{

		    razor_error_free(error);

		    error=NULL;

		    root=razor_root_open(root_uri,&error);

		}                             

	    }

	    else

		root=razor_root_open(root_uri,&error);

	    if (!root)                        

	    {

		plover_propagate_razor_error(err,error);

		if (incompatible_lock)

		    (void)plover_package_set_open(set,root_uri,!exclusive,NULL);

		return FALSE;

	    }

	}

	system=razor_root_get_system_set(root);

	if (system)

	    razor_set_ref(system);

    }

    else

	system=razor_root_open_read_only(root_uri,&error);

    if (error)

    {

	g_set_error_literal(err,PLOVER_RAZOR_ERROR,RAZOR_GENERAL_ERROR_FAILED,

	  razor_error_get_msg(error));

	razor_error_free(error);

	if (incompatible_lock)

	    (void)plover_package_set_open(set,root_uri,!exclusive,NULL);

	return FALSE;

    }

    plover_package_set_close(set);

    priv->root=root;

    priv->set=system;

    priv->root_uri=g_strdup(root_uri);

    return TRUE;

}

const char *plover_package_set_get_install_root(PloverPackageSet *set)

{

    PloverPackageSetPrivate *priv;

    g_return_val_if_fail(PLOVER_IS_PACKAGE_SET(set),NULL);

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    return priv->root_uri;

}

gboolean plover_package_set_get_exclusive(PloverPackageSet *set)

{

    PloverPackageSetPrivate *priv;

    g_return_val_if_fail(PLOVER_IS_PACKAGE_SET(set),FALSE);

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    return !!priv->root;

}

gboolean plover_package_set_update(PloverPackageSet *set,struct razor_set *next,

  struct razor_atomic *atomic)

{

    gboolean retval;

    PloverPackageSetPrivate *priv;

    g_return_val_if_fail(PLOVER_IS_PACKAGE_SET(set),FALSE);

    g_return_val_if_fail(plover_package_set_get_exclusive(set) != FALSE,FALSE);

    g_return_val_if_fail(next != NULL,FALSE);

    g_return_val_if_fail(atomic != NULL,FALSE);

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    retval=!razor_root_update(priv->root,next,atomic);

    if (retval)

    {

	razor_set_unref(priv->set);

	priv->set=razor_root_get_system_set(priv->root);

	if (priv->set)

	    razor_set_ref(priv->set);

    }

    return retval;

}

PloverPackageSet *plover_package_set_new_from_installed(const char *root,

  GError **err)

{

    PloverPackageSet *set;

    set=plover_package_set_new();

    if (!plover_package_set_open(set,root,FALSE,err))

    {

	g_object_unref(set);

	return NULL;

    }

    return set;

}

PloverPackageSet *plover_package_set_new_from_razor(struct razor_set *razor)

{

    PloverPackageSet *set;

    PloverPackageSetPrivate *priv;

    g_return_val_if_fail(razor != NULL,NULL);

    set=plover_package_set_new();

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    priv->set=razor;

    razor_set_ref(priv->set);

    return set;

}

static gboolean

  plover_package_set_import_package(PloverRepository *repository,

  struct razor_relocations *relocations,struct razor_importer *importer,

  PloverPackage *package,GError **error)

{

    int i;

    struct razor_property_iterator *prop_iter;

    struct razor_file_iterator *file_iter;

    struct razor_rpm *rpm;

    struct razor_property *prop;

    const char *name,*version,*arch,*summary,*desc,*url,*license;

    const char *install_prefix;

    const char *const *prefixes;

    uint32_t flags;

    rpm=plover_repository_open_rpm(repository,package,error);

    if (!rpm)

	return FALSE;

    razor_relocations_set_rpm(relocations,rpm);

    name=plover_package_get_name(package);

    version=plover_package_get_version(package);

    arch=plover_package_get_arch(package);

    razor_importer_begin_package(importer,name,version,arch);

    summary=plover_package_get_summary(package);

    desc=plover_package_get_description(package);

    url=plover_package_get_URL(package);

    license=plover_package_get_license(package);

    razor_importer_add_details(importer,summary,desc,url,license);

    razor_rpm_get_details(rpm,RAZOR_DETAIL_PREFIXES,&prefixes,

      RAZOR_DETAIL_LAST);

    for(i=0;prefixes && prefixes[i];i++)

    {

	install_prefix=razor_relocations_apply(relocations,prefixes[i]);

	razor_importer_add_install_prefix(importer,install_prefix);

    }

    razor_rpm_close(rpm);

    prop_iter=plover_package_property_iterator_create(package);

    while (razor_property_iterator_next(prop_iter,&prop,&name,&flags,&version))

	razor_importer_add_property(importer,name,flags,version);

    razor_property_iterator_destroy(prop_iter);

    file_iter=plover_package_file_iterator_create(package,FALSE);

    while (razor_file_iterator_next(file_iter,&name))

    {

	name=razor_relocations_apply(relocations,name);

	razor_importer_add_file(importer,name);

    }

    razor_file_iterator_destroy(file_iter);

    razor_importer_finish_package(importer);

    return TRUE;

}

PloverPackageSet *

  plover_package_set_new_from_repository(PloverRepository *repository,

  struct razor_relocations *relocations,GError **error)

{

    struct razor_importer *importer;

    uint32_t header_version;

    GSList *packages,*lnk;

    PloverPackageSet *unrelocated,*set;

    PloverPackageSetPrivate *priv;

    PloverPackage *package;

    g_return_val_if_fail(PLOVER_IS_REPOSITORY(repository),NULL);

    unrelocated=plover_repository_get_package_set(repository);

    set=plover_package_set_new();

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    if (relocations)

    {

	importer=razor_importer_create();

	packages=plover_package_set_get_packages(unrelocated);

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

	{

	    package=lnk->data;

	    if (!plover_package_set_import_package(repository,relocations,

	      importer,package,error))

	    {

		razor_importer_destroy(importer);

		g_object_unref(set);

		return NULL;

	    }

	}

	priv->set=razor_importer_finish(importer);

	if (!priv->set)

	{

	    g_object_unref(set);

	    return NULL;

	}

	header_version=plover_package_set_get_header_version(unrelocated);

	if (header_version)

	    plover_package_set_set_header_version(set,header_version);

    }

    else

    {

	priv->set=plover_package_set_get_razor(unrelocated);

	razor_set_ref(priv->set);

    }

    return set;

}

PloverPackageSet *plover_package_set_new_from_yum(const char *base,

  struct razor_relocations *relocations,GError **error)

{

    PloverPackageSet *set;

    PloverRepository *repository;

    repository=plover_repository_new_from_yum(base,error);

    if (!repository)

	return NULL;

    set=plover_package_set_new_from_repository(repository,relocations,error);

    g_object_unref(repository);

    return set;

}

PloverPackageSet *plover_package_set_new_from_rpms(const char **filenames,

  GError **error)

{

    int i;

    PloverPackageSet *set;

    PloverPackageSetPrivate *priv;

    struct razor_importer *importer;

    struct razor_rpm *rpm;

    struct razor_error *tmp_error=NULL;

    GFile *file;

    gchar *uri;

    plover__uri_handler_init();

    importer=razor_importer_create();

    for(i=0;filenames[i];i++)

    {

	file=g_file_new_for_path(filenames[i]);

	uri=g_file_get_uri(file);

	g_object_unref(file);

	rpm=razor_rpm_open(uri,&tmp_error);

	g_free(uri);

	if (!rpm)

	{

	    razor_importer_destroy(importer);

	    plover_propagate_razor_error(error,tmp_error);

	    return NULL;

	}

	if (razor_importer_add_rpm(importer,rpm))

	{

	    g_set_error(error,PLOVER_RAZOR_ERROR,RAZOR_GENERAL_ERROR_FAILED,

	      "%s: failed to import",filenames[i]);

	    razor_importer_destroy(importer);

	    return NULL;

	}

	razor_rpm_close(rpm);

    }

    set=plover_package_set_new();

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    priv->set=razor_importer_finish(importer);

    return set;

}

uint32_t plover_package_set_get_header_version(PloverPackageSet *set)

{

    PloverPackageSetPrivate *priv;

    g_return_val_if_fail(PLOVER_IS_PACKAGE_SET(set),0);

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    if (priv->set)

	return razor_set_get_header_version(priv->set);

    else

	return 0;

}

gboolean plover_package_set_set_header_version(PloverPackageSet *set,

  uint32_t header_version)

{

    PloverPackageSetPrivate *priv;

    g_return_val_if_fail(PLOVER_IS_PACKAGE_SET(set),FALSE);

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    if (priv->set)

	return !razor_set_set_header_version(priv->set,header_version);

    else

	return FALSE;

}

struct razor_set *plover_package_set_get_razor(PloverPackageSet *set)

{

    PloverPackageSetPrivate *priv;

    g_return_val_if_fail(PLOVER_IS_PACKAGE_SET(set),NULL);

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    return priv->set;

}

GSList *plover_package_set_get_packages(PloverPackageSet *set)

{

    struct razor_package_iterator *iter;

    struct razor_package *pkg;

    PloverPackageSetPrivate *priv;

    PloverPackage *package;

    g_return_val_if_fail(PLOVER_IS_PACKAGE_SET(set),NULL);

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    if (priv->set && !priv->packages)

    {

	iter=razor_package_iterator_create(priv->set);

	while(razor_package_iterator_next(iter,&pkg,RAZOR_DETAIL_LAST))

	{

	    package=plover_package_new(priv->set,pkg);

	    priv->packages=g_slist_prepend(priv->packages,package);

	}

	razor_package_iterator_destroy(iter);

	priv->packages=g_slist_reverse(priv->packages);

    }

    return priv->packages;

}

PloverPackage *plover_package_set_lookup(PloverPackageSet *set,

  struct razor_package *razor_package)

{

    GSList *packages,*lnk;

    PloverPackage *package;

    g_return_val_if_fail(PLOVER_IS_PACKAGE_SET(set),NULL);

    packages=plover_package_set_get_packages(set);

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

    {

	package=lnk->data;

	if (plover_package_get_razor_package(package)==razor_package)

	    return package;

    }

    return NULL;

}

PloverPackage *plover_package_set_find_custom(PloverPackageSet *set,

  gconstpointer data,GCompareFunc func)

{

    GSList *packages,*lnk;

    g_return_val_if_fail(PLOVER_IS_PACKAGE_SET(set),NULL);

    packages=plover_package_set_get_packages(set);

    lnk=g_slist_find_custom(packages,data,func);

    return lnk?lnk->data:NULL;

}

static gint plover_package_set_compare(gconstpointer a,gconstpointer b)

{

    PloverPackage *pa=(void *)a,*pb=(void *)b;

    const char *sa,*sb;

    sa=plover_package_get_name(pa);

    sb=plover_package_get_name(pb);

    if (g_strcmp0(sa,sb))

	return 1;

    sa=plover_package_get_arch(pa);

    sb=plover_package_get_arch(pb);

    if (g_strcmp0(sa,sb))

	return 1;

    sa=plover_package_get_version(pa);

    sb=plover_package_get_version(pb);

    return !!g_strcmp0(sa,sb);

}

PloverPackage *plover_package_set_find_matching(PloverPackageSet *set,

  PloverPackage *template)

{

    g_return_val_if_fail(PLOVER_IS_PACKAGE_SET(set),NULL);

    return plover_package_set_find_custom(set,template,

      plover_package_set_compare);

}

/*

 * Some versions of razor have a bug which causes all detail strings

 * to be discarded. If such a version of razor is used to install or

 * update a package, then all the detail strings for the installed

 * set will be lost. This function tests for this condition and can

 * be used to present something more useful than blank details.

 */

gboolean plover_package_set_get_no_details(PloverPackageSet *set)

{

    PloverPackageSetPrivate *priv;

    PloverPackage *package;

    GSList *packages,*link;

    g_return_val_if_fail(PLOVER_IS_PACKAGE_SET(set),FALSE);

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    if (priv->no_details<0)

    {

	packages=plover_package_set_get_packages(set);

	if (packages)

	{

	    priv->no_details=0;

	    for(link=packages;link;link=link->next)

	    {

		package=link->data;

		priv->no_details+=2;

		if (*plover_package_get_summary(package))

		    priv->no_details--;

		if (*plover_package_get_license(package))

		    priv->no_details--;

		if (*plover_package_get_description(package))

		    priv->no_details--;

		if (*plover_package_get_URL(package))

		    priv->no_details--;

	    }

	    if (priv->no_details<0)	/* More than 50% of strings present */

		priv->no_details=0;

	}

    }

    return priv->no_details>0;

}

struct plover_package_set_prefix {

    gchar *path;

    guint count;

};

static GArray *plover_package_set_popchart_new(void)

{

    GArray *prefixes;

    prefixes=g_array_new(FALSE,FALSE,sizeof(struct plover_package_set_prefix));

    return prefixes;

}

static void plover_package_set_popchart_free(GArray *popchart)

{

    int i;

    struct plover_package_set_prefix *prefix;

    for(i=0;i<popchart->len;i++)

    {

	prefix=&g_array_index(popchart,struct plover_package_set_prefix,i);

	g_free(prefix->path);

    }

    g_array_free(popchart,TRUE);

}

static void plover_package_set_popchart_add(GArray *popchart,const char *path)

{

    int i;

    struct plover_package_set_prefix *prefix;

    for(i=popchart->len-1;i>=0;i--)

    {

	prefix=&g_array_index(popchart,struct plover_package_set_prefix,i);

	if (!strcmp(prefix->path,path))

	{

	    prefix->count++;

	    return;

	}

    }

    g_array_set_size(popchart,popchart->len+1);

    prefix=&g_array_index(popchart,struct plover_package_set_prefix,

      popchart->len-1);

    prefix->path=g_strdup(path);

    prefix->count=1;

}

static const char *plover_package_set_popchart_get_popular(GArray *popchart)

{

    int i;

    struct plover_package_set_prefix *prefix,*popular;

    if (!popchart->len)

	return NULL;

    popular=&g_array_index(popchart,struct plover_package_set_prefix,0);

    for(i=1;i<popchart->len;i++)

    {

	prefix=&g_array_index(popchart,struct plover_package_set_prefix,i);

	if (prefix->count>popular->count)

	    popular=prefix;

    }

    return popular->path;

}

static void plover_package_set_popchart_add_prefixes(PloverPackageSet *set,

  GArray *popchart)

{

    int i;

    PloverPackage *package;

    GSList *packages,*lnk;

    const char *const *prefixes;

    packages=plover_package_set_get_packages(set);

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

    {

	package=lnk->data;

	prefixes=plover_package_get_prefixes(package);

	for(i=0;prefixes[i];i++)

	    plover_package_set_popchart_add(popchart,prefixes[i]);

    }

}

static void plover_package_set_popchart_add_from_files(PloverPackageSet *set,

  GArray *popchart)

{

    int len;

    const char *name,*s;

    gchar *default_prefix,*path;

    struct razor_file_iterator *fi;

    GSList *packages,*lnk;

    PloverPackage *package;

    default_prefix=plover_comps_get_default_prefix(NULL);

    if (!default_prefix)

	return;

    len=strlen(default_prefix);

    packages=plover_package_set_get_packages(set);

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

    {

	package=lnk->data;

	fi=plover_package_file_iterator_create(package,FALSE);

	while (razor_file_iterator_next(fi,&name))

	{

	    if (g_str_has_prefix(name,default_prefix))

	    {

		for(s=name+len;*s;s++)

		    if (G_IS_DIR_SEPARATOR(*s))

			break;

		path=g_strndup(name,s-name);

		plover_package_set_popchart_add(popchart,path);

		g_free(path);

	    }

	}

	razor_file_iterator_destroy(fi);

    }

    g_free(default_prefix);

}

const char *plover_package_set_guess_prefix(PloverPackageSet *set,

  GError **error)

{

    GArray *popchart;

    const char *prefix;

    struct comps *comps;

    PloverPackageSetPrivate *priv;

    g_return_val_if_fail(PLOVER_IS_PACKAGE_SET(set),NULL);

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    if (!priv->guessed_prefix)

    {

	popchart=plover_package_set_popchart_new();

	plover_package_set_popchart_add_prefixes(set,popchart);

	prefix=plover_package_set_popchart_get_popular(popchart);

	if (prefix)

	    priv->guessed_prefix=g_strdup(prefix);

	else

	{

	    plover_package_set_popchart_add_from_files(set,popchart);

	    prefix=plover_package_set_popchart_get_popular(popchart);

	    if (prefix)

		priv->guessed_prefix=g_strdup(prefix);

	}

	plover_package_set_popchart_free(popchart);

    }

    if (!priv->guessed_prefix)

    {

	comps=plover_comps_new();

	plover_comps_set_vendor(comps,"Acme Corporation");

	priv->guessed_prefix=plover_comps_get_default_prefix(comps);

	plover_comps_free(comps);

    }

    return priv->guessed_prefix;

}

/*

 * Returns:

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

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

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

 */

int plover_package_set_files_match_prefix(PloverPackageSet *set,

  const char *prefix)

{

    int len,matches=-1;

    const char *name;

    struct razor_package *package;

    struct razor_package_iterator *pi;

    struct razor_file_iterator *fi;

    PloverPackageSetPrivate *priv;

    g_return_val_if_fail(PLOVER_IS_PACKAGE_SET(set),-1);

    priv=PLOVER_PACKAGE_SET_GET_PRIVATE(set);

    len=strlen(prefix);

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

	len--;

    if (priv->set)

    {

	pi=razor_package_iterator_create(priv->set);

	while (matches &&

	  razor_package_iterator_next(pi,&package,RAZOR_DETAIL_LAST))

	{

	    fi=razor_file_iterator_create(priv->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);

    }

    return matches;

}