/* Chrysalide - Outil d'analyse de fichiers binaires
* project.c - gestion d'un groupe de fichiers binaires
*
* Copyright (C) 2015-2017 Cyrille Bagard
*
* This file is part of Chrysalide.
*
* Chrysalide 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 3 of the License, or
* (at your option) any later version.
*
* Chrysalide 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 Chrysalide. If not, see .
*/
#include "project.h"
#include
#include
#include
#include
#include "loading.h"
#include "../common/xml.h"
#include "../core/global.h"
#include "../core/logs.h"
#include "../core/params.h"
/* ------------------------- DEFINITION D'UN PROJET INTERNE ------------------------- */
/* Suivi du chargement de contenus binaires */
typedef struct _loading_params
{
union
{
const gid_t *exp_gid; /* Identifiant d'exploration */
const gid_t **exp_gids; /* Identifiants d'exploration */
};
size_t exp_count; /* Quantitié d'identifiants */
size_t resolved; /* Compteur de résolutions */
xmlDoc *xdoc; /* Structure XML chargée ? */
xmlXPathContext *context; /* Eventuel contexte XML */
} loading_params;
/* Projet d'étude regroupant les binaires analysés (instance) */
struct _GStudyProject
{
GObject parent; /* A laisser en premier */
char *filename; /* Lieu d'enregistrement */
loading_params *ld_params; /* Infos d'accompagnement */
size_t ld_count; /* Quantité de ces infos */
GMutex ld_mutex; /* Encadrement des accès */
GLoadedContent **contents; /* Contenus chargés et intégrés*/
size_t count; /* Quantité de ces contenus */
GMutex mutex; /* Encadrement des accès */
};
/* Projet d'étude regroupant les binaires analysés (classe) */
struct _GStudyProjectClass
{
GObjectClass parent; /* A laisser en premier */
/* Signaux */
void (* content_added) (GStudyProject *, GLoadedContent *);
void (* content_removed) (GStudyProject *, GLoadedContent *);
};
/* Initialise la classe des projets d'étude. */
static void g_study_project_class_init(GStudyProjectClass *);
/*Initialise une instance de projet d'étude. */
static void g_study_project_init(GStudyProject *);
/* Supprime toutes les références externes. */
static void g_study_project_dispose(GStudyProject *);
/* Procède à la libération totale de la mémoire. */
static void g_study_project_finalize(GStudyProject *);
/* ------------------------ INTEGRATION DE CONTENUS BINAIRES ------------------------ */
/* Prépare le suivi d'une nouvelle phase d'intégration. */
static loading_params *g_study_project_prepare_content_loading(GStudyProject *);
/* Efface le suivi d'une phase d'intégration obsolète. */
static void g_study_project_destroy_content_loading(GStudyProject *, loading_params *);
/* Retrouve les infos de chargements liées à une exploration. */
static loading_params *g_study_project_find_exploration(GStudyProject *, gid_t, const gid_t **);
/* Assure l'intégration de contenus listés dans du XML. */
static void g_study_project_recover_binary_contents(GStudyProject *, xmlDoc *, xmlXPathContext *);
/* Note la fin d'une phase d'exploration de contenu. */
static void on_new_content_explored(GContentExplorer *, gid_t, GStudyProject *);
/* Note la fin d'une phase de resolution de contenu. */
static void on_new_content_resolved(GContentResolver *, gid_t, GStudyProject *);
/* Réceptionne la recette d'une analyse de contenu. */
static void on_loaded_content_analyzed(GLoadedContent *, gboolean, GStudyProject *);
/* ---------------------------------------------------------------------------------- */
/* DEFINITION D'UN PROJET INTERNE */
/* ---------------------------------------------------------------------------------- */
/* Indique le type défini pour un projet d'étude. */
G_DEFINE_TYPE(GStudyProject, g_study_project, G_TYPE_OBJECT);
/******************************************************************************
* *
* Paramètres : klass = classe à initialiser. *
* *
* Description : Initialise la classe des projets d'étude. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_study_project_class_init(GStudyProjectClass *klass)
{
GObjectClass *object; /* Autre version de la classe */
object = G_OBJECT_CLASS(klass);
object->dispose = (GObjectFinalizeFunc/* ! */)g_study_project_dispose;
object->finalize = (GObjectFinalizeFunc)g_study_project_finalize;
g_signal_new("content-added",
G_TYPE_STUDY_PROJECT,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(GStudyProjectClass, content_added),
NULL, NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE, 1, G_TYPE_OBJECT);
g_signal_new("content-removed",
G_TYPE_STUDY_PROJECT,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(GStudyProjectClass, content_removed),
NULL, NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE, 1, G_TYPE_OBJECT);
}
/******************************************************************************
* *
* Paramètres : project = instance à initialiser. *
* *
* Description : Initialise une instance de projet d'étude. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_study_project_init(GStudyProject *project)
{
GContentExplorer *explorer; /* Explorateur de contenus */
GContentResolver *resolver; /* Resolveur de contenus */
project->filename = NULL;
project->ld_params = NULL;
project->ld_count = 0;
g_mutex_init(&project->ld_mutex);
project->contents = NULL;
project->count = 0;
g_mutex_init(&project->mutex);
explorer = get_current_content_explorer();
g_signal_connect(explorer, "explored", G_CALLBACK(on_new_content_explored), project);
g_object_unref(G_OBJECT(explorer));
resolver = get_current_content_resolver();
g_signal_connect(resolver, "resolved", G_CALLBACK(on_new_content_resolved), project);
g_object_unref(G_OBJECT(resolver));
}
/******************************************************************************
* *
* Paramètres : binary = instance d'objet GLib à traiter. *
* *
* Description : Supprime toutes les références externes. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_study_project_dispose(GStudyProject *project)
{
GContentExplorer *explorer; /* Explorateur de contenus */
GContentResolver *resolver; /* Resolveur de contenus */
size_t i; /* Boucle de parcours */
explorer = get_current_content_explorer();
g_signal_handlers_disconnect_by_func(explorer, G_CALLBACK(on_new_content_explored), project);
g_object_unref(G_OBJECT(explorer));
resolver = get_current_content_resolver();
g_signal_handlers_disconnect_by_func(resolver, G_CALLBACK(on_new_content_resolved), project);
g_object_unref(G_OBJECT(resolver));
g_mutex_lock(&project->ld_mutex);
while (project->ld_count > 0)
g_study_project_destroy_content_loading(project, project->ld_params);
if (project->ld_params != NULL)
free(project->ld_params);
g_mutex_unlock(&project->ld_mutex);
g_mutex_clear(&project->ld_mutex);
g_mutex_lock(&project->mutex);
for (i = 0; i < project->count; i++)
g_object_unref(G_OBJECT(project->contents[i]));
if (project->contents != NULL)
free(project->contents);
g_mutex_unlock(&project->mutex);
g_mutex_clear(&project->mutex);
G_OBJECT_CLASS(g_study_project_parent_class)->dispose(G_OBJECT(project));
}
/******************************************************************************
* *
* Paramètres : binary = instance d'objet GLib à traiter. *
* *
* Description : Procède à la libération totale de la mémoire. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_study_project_finalize(GStudyProject *project)
{
if (project->filename != NULL)
free(project->filename);
G_OBJECT_CLASS(g_study_project_parent_class)->finalize(G_OBJECT(project));
}
/******************************************************************************
* *
* Paramètres : - *
* *
* Description : Crée un nouveau projet vierge. *
* *
* Retour : Instance mise en place. *
* *
* Remarques : - *
* *
******************************************************************************/
GStudyProject *g_study_project_new(void)
{
GStudyProject *result; /* Composant à retourner */
result = g_object_new(G_TYPE_STUDY_PROJECT, NULL);
return result;
}
/******************************************************************************
* *
* Paramètres : filename = chemin d'accès au fichier à charger. *
* *
* Description : Crée un projet à partir du contenu XML d'un fichier. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
GStudyProject *g_study_project_open(const char *filename)
{
GStudyProject *result; /* Adresse à retourner */
xmlDoc *xdoc; /* Structure XML chargée */
xmlXPathContext *context; /* Contexte pour les XPath */
if (!open_xml_file(filename, &xdoc, &context)) return NULL;
result = g_study_project_new();
result->filename = strdup(filename);
g_study_project_recover_binary_contents(result, xdoc, context);
return result;
}
/******************************************************************************
* *
* Paramètres : project = project à sauvegarder. *
* filename = nom de fichier à utiliser ou NULL pour l'existant.*
* *
* Description : Procède à l'enregistrement d'un projet donné. *
* *
* Retour : true si l'enregistrement s'est déroule sans encombre. *
* *
* Remarques : - *
* *
******************************************************************************/
bool g_study_project_save(GStudyProject *project, const char *filename)
{
bool result; /* Bilan à retourner */
xmlDocPtr xdoc; /* Document XML à créer */
xmlXPathContextPtr context; /* Contexte pour les recherches*/
const char *final; /* Lieu d'enregistrement final */
size_t root_count; /* Quantité d'origines */
size_t i; /* Boucle de parcours */
GBinContent *content; /* Contenu brut à manipuler */
GBinContent *root; /* Contenu d'origine à traiter */
const gchar *hash; /* Empreinte d'un contenu */
char *access; /* Chemin pour une sous-config.*/
xmlXPathObjectPtr xobject; /* Cible d'une recherche */
const char *format; /* Format associé à un élément */
/* Forme générale */
result = create_new_xml_file(&xdoc, &context);
if (result)
result = (ensure_node_exist(xdoc, context, "/ChrysalideProject") != NULL);
if (result)
result = add_string_attribute_to_node(xdoc, context, "/ChrysalideProject", "version", PROJECT_XML_VERSION);
if (result)
result = (ensure_node_exist(xdoc, context, "/ChrysalideProject/RootContents") != NULL);
if (result)
result = (ensure_node_exist(xdoc, context, "/ChrysalideProject/LoadedContents") != NULL);
final = filename != NULL ? filename : project->filename;
/* Inscriptions des contenus */
root_count = 0;
g_mutex_lock(&project->mutex);
for (i = 0; i < project->count && result; i++)
{
content = g_loaded_content_get_content(project->contents[i]);
/* Racine */
root = g_binary_content_get_root(content);
hash = g_binary_content_get_checksum(root);
asprintf(&access, "/ChrysalideProject/RootContents/Content[@hash='%s']", hash);
xobject = get_node_xpath_object(context, access);
free(access);
if (XPATH_OBJ_NODES_COUNT(xobject) == 0)
{
asprintf(&access, "/ChrysalideProject/RootContents/Content[position()=%zu]", ++root_count);
if (result)
result = (ensure_node_exist(xdoc, context, access) != NULL);
if (result)
{
hash = g_binary_content_get_checksum(content);
result = add_string_attribute_to_node(xdoc, context, access, "hash", hash);
}
if (result)
result = g_binary_content_save(root, xdoc, context, access, final);
free(access);
}
if(xobject != NULL)
xmlXPathFreeObject(xobject);
/* Charge utile */
asprintf(&access, "/ChrysalideProject/LoadedContents/Content[position()=%zu]", i + 1);
if (result)
result = (ensure_node_exist(xdoc, context, access) != NULL);
if (result)
{
hash = g_binary_content_get_checksum(content);
result = add_string_attribute_to_node(xdoc, context, access, "hash", hash);
}
if (result)
{
format = g_loaded_content_get_format_name(project->contents[i]);
result = add_string_attribute_to_node(xdoc, context, access, "format", format);
}
if (result)
result = g_loaded_content_save(project->contents[i], xdoc, context, access);
free(access);
g_object_unref(G_OBJECT(content));
}
g_mutex_unlock(&project->mutex);
/* Sauvegarde finale */
if (result)
result = save_xml_file(xdoc, final);
if (result && filename != NULL)
{
if (project->filename != NULL) free(project->filename);
project->filename = strdup(filename);
}
close_xml_file(xdoc, context);
return result;
}
/******************************************************************************
* *
* Paramètres : project = project à consulter. *
* *
* Description : Indique le chemin du fichier destiné à la sauvegarde. *
* *
* Retour : Chemin de fichier pour l'enregistrement ou NULL si indéfini. *
* *
* Remarques : - *
* *
******************************************************************************/
const char *g_study_project_get_filename(const GStudyProject *project)
{
return project->filename;
}
/* ---------------------------------------------------------------------------------- */
/* INTEGRATION DE CONTENUS BINAIRES */
/* ---------------------------------------------------------------------------------- */
/******************************************************************************
* *
* Paramètres : project = projet dont le contenu est à compléter. *
* *
* Description : Prépare le suivi d'une nouvelle phase d'intégration. *
* *
* Retour : Nouvelle structure de suivi prête à être complétée. *
* *
* Remarques : - *
* *
******************************************************************************/
static loading_params *g_study_project_prepare_content_loading(GStudyProject *project)
{
loading_params *result; /* Trouvaille à retourner */
assert(!g_mutex_trylock(&project->ld_mutex));
project->ld_params = (loading_params *)realloc(project->ld_params,
++project->ld_count * sizeof(loading_params));
result = &project->ld_params[project->ld_count - 1];
return result;
}
/******************************************************************************
* *
* Paramètres : project = projet dont le contenu est à compléter. *
* params = paramètres de chargemeent à supprimer. *
* *
* Description : Efface le suivi d'une phase d'intégration obsolète. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_study_project_destroy_content_loading(GStudyProject *project, loading_params *params)
{
GContentExplorer *explorer; /* Explorateur de contenus */
GContentResolver *resolver; /* Resolveur de contenus */
size_t i; /* Boucle de parcours */
size_t index; /* Indice des paramètres */
assert(!g_mutex_trylock(&project->ld_mutex));
/* Supression des groupes de travail */
explorer = get_current_content_explorer();
resolver = get_current_content_resolver();
if (params->exp_count == 1)
{
g_content_resolver_delete_group(resolver, *params->exp_gid);
g_content_explorer_delete_group(explorer, *params->exp_gid);
}
else
{
for (i = 0; i < params->exp_count; i++)
{
g_content_resolver_delete_group(resolver, *params->exp_gids[i]);
g_content_explorer_delete_group(explorer, *params->exp_gids[i]);
}
free(params->exp_gids);
}
g_object_unref(G_OBJECT(explorer));
g_object_unref(G_OBJECT(resolver));
/* Fermture de l'éventuel fichier XML de chargement */
if (params->xdoc != NULL)
close_xml_file(params->xdoc, params->context);
/* Réorganisation de la liste */
index = params - project->ld_params;
if ((index + 1) < project->ld_count)
memmove(&project->ld_params[index], &project->ld_params[index + 1],
(project->ld_count - index - 1) * sizeof(loading_params));
project->ld_params = (loading_params *)realloc(project->ld_params,
--project->ld_count * sizeof(loading_params));
}
/******************************************************************************
* *
* Paramètres : project = projet dont le contenu est à consulter. *
* gid = identifiant du groupe d'exploration recherché. *
* ptr = pointeur vers la valeur d'origine externe. *
* *
* Description : Retrouve les infos de chargements liées à une exploration. *
* *
* Retour : Informations trouvées ou NULL en cas d'échec. *
* *
* Remarques : - *
* *
******************************************************************************/
static loading_params *g_study_project_find_exploration(GStudyProject *project, gid_t gid, const gid_t **ptr)
{
loading_params *result; /* Trouvaille à retourner */
const gid_t *value; /* Raccourci de confort */
size_t i; /* Boucle de parcours #1 */
size_t k; /* Boucle de parcours #2 */
assert(!g_mutex_trylock(&project->ld_mutex));
result = NULL;
value = NULL;
for (i = 0; i < project->ld_count && result == NULL; i++)
{
if (project->ld_params[i].exp_count == 1)
{
value = project->ld_params[i].exp_gid;
if (*value == gid)
result = &project->ld_params[i];
}
else
for (k = 0; k < project->ld_params[i].exp_count && result == NULL; k++)
{
value = project->ld_params[i].exp_gids[k];
if (*value == gid)
result = &project->ld_params[i];
}
}
if (ptr != NULL)
{
assert(result == NULL || value != NULL);
*ptr = (result == NULL ? NULL : value);
}
return result;
}
/******************************************************************************
* *
* Paramètres : project = projet dont le contenu est à compléter. *
* xdoc = structure XML en cours d'édition. *
* context = contexte à utiliser pour les recherches. *
* *
* Description : Assure l'intégration de contenus listés dans du XML. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_study_project_recover_binary_contents(GStudyProject *project, xmlDoc *xdoc, xmlXPathContext *context)
{
loading_params *params; /* Informations de chargement */
xmlXPathObjectPtr xobject; /* Cible d'une recherche */
size_t count; /* Nombre de contenus premiers */
GContentExplorer *explorer; /* Explorateur de contenus */
size_t explored; /* Qté. d'explorations lancées */
size_t i; /* Boucle de parcours */
char *access; /* Chemin pour un contenu */
GBinContent *content; /* Contenu binaire retrouvé */
xobject = get_node_xpath_object(context, "/ChrysalideProject/RootContents/Content");
count = XPATH_OBJ_NODES_COUNT(xobject);
if (count > 0)
{
explorer = get_current_content_explorer();
g_mutex_lock(&project->ld_mutex);
params = g_study_project_prepare_content_loading(project);
if (count > 1)
params->exp_gids = (const gid_t **)malloc(count * sizeof(gid_t *));
params->resolved = 0;
params->xdoc = xdoc;
params->context = context;
explored = 0;
for (i = 0; i < XPATH_OBJ_NODES_COUNT(xobject); i++)
{
asprintf(&access, "/ChrysalideProject/RootContents/Content[position()=%zu]", i + 1);
content = g_binary_content_new_from_xml(context, access, project->filename);
free(access);
if (content == NULL)
{
log_variadic_message(LMT_ERROR, _("Unable to load the root content #%zu ; skipping..."), i);
continue;
}
if (count == 1)
{
params->exp_gid = g_content_explorer_create_group(explorer, content);
explored++;
}
else
params->exp_gids[explored++] = g_content_explorer_create_group(explorer, content);
g_object_unref(G_OBJECT(content));
}
params->exp_count = explored;
g_mutex_unlock(&project->ld_mutex);
g_object_unref(G_OBJECT(explorer));
}
if(xobject != NULL)
xmlXPathFreeObject(xobject);
}
/******************************************************************************
* *
* Paramètres : project = projet dont le contenu est à compléter. *
* content = contenu binaire à mémoriser pour le projet. *
* *
* Description : Assure l'intégration de contenus binaires dans un projet. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_study_project_discover_binary_content(GStudyProject *project, GBinContent *content)
{
loading_params *params; /* Informations de chargement */
GContentExplorer *explorer; /* Explorateur de contenus */
explorer = get_current_content_explorer();
g_mutex_lock(&project->ld_mutex);
params = g_study_project_prepare_content_loading(project);
params->exp_gid = g_content_explorer_create_group(explorer, content);
params->exp_count = 1;
params->resolved = 0;
params->xdoc = NULL;
params->context = NULL;
g_mutex_unlock(&project->ld_mutex);
g_object_unref(G_OBJECT(explorer));
}
/******************************************************************************
* *
* Paramètres : explorer = gestionnaire d'explorations à consulter. *
* gid = groupe d'exploration concerné. *
* project = projet avide des résultats des opérations. *
* *
* Description : Note la fin d'une phase d'exploration de contenu. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void on_new_content_explored(GContentExplorer *explorer, gid_t gid, GStudyProject *project)
{
const gid_t *gid_ptr; /* Référence vers l'origine */
loading_params *params; /* Informations de chargement */
GBinContent **available; /* Contenus binaires présents */
size_t count; /* Quantité de ces contenus */
const wgroup_id_t *wid; /* Groupe de tâches */
GContentResolver *resolver; /* Resolveur de contenus */
size_t i; /* Boucle de parcours */
g_mutex_lock(&project->ld_mutex);
params = g_study_project_find_exploration(project, gid, &gid_ptr);
/* S'il s'agit bien d'une exploration nouvelle */
if (params != NULL)
{
wid = g_content_explorer_get_group_work_id(explorer, gid);
available = g_content_explorer_get_all(explorer, gid, &count);
assert(count > 0);
resolver = get_current_content_resolver();
g_content_resolver_create_group(resolver, wid, gid_ptr, available, count);
g_object_unref(G_OBJECT(resolver));
for (i = 0; i < count; i++)
g_object_unref(G_OBJECT(available[i]));
free(available);
}
g_mutex_unlock(&project->ld_mutex);
}
/******************************************************************************
* *
* Paramètres : resolver = gestionnaire de résolutions à consulter. *
* gid = groupe d'exploration concerné. *
* project = projet avide des résultats des opérations. *
* *
* Description : Note la fin d'une phase de resolution de contenu. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void on_new_content_resolved(GContentResolver *resolver, gid_t gid, GStudyProject *project)
{
loading_params *params; /* Informations de chargement */
GLoadedContent **available; /* Contenus chargés valables */
size_t count; /* Quantité de ces contenus */
size_t i; /* Boucle de parcours */
GBinContent *content; /* Contenu brut à manipuler */
const gchar *hash; /* Empreinte d'un contenu */
const char *format; /* Format associé à un élément */
char *access; /* Chemin pour une sous-config.*/
xmlXPathObjectPtr xobject; /* Cible d'une recherche */
bool status; /* Bilan d'une restauration */
g_mutex_lock(&project->ld_mutex);
params = g_study_project_find_exploration(project, gid, NULL);
/* S'il s'agit bien d'une exploration nouvelle */
if (params != NULL)
{
available = g_content_resolver_get_all(resolver, gid, &count);
/* Rechargement à partir d'XML ? */
if (params->xdoc != NULL)
{
assert(params->context != NULL);
for (i = 0; i < count; i++)
{
content = g_loaded_content_get_content(available[i]);
hash = g_binary_content_get_checksum(content);
g_object_unref(G_OBJECT(content));
format = g_loaded_content_get_format_name(available[i]);
asprintf(&access, "/ChrysalideProject/LoadedContents/Content[@hash='%s' and @format='%s']",
hash, format);
xobject = get_node_xpath_object(params->context, access);
if (XPATH_OBJ_NODES_COUNT(xobject) > 0)
{
status = g_loaded_content_restore(available[i], params->xdoc, params->context, access);
if (!status)
log_variadic_message(LMT_ERROR,
_("Unable to reload binary from XML (hash=%s) ; skipping..."), hash);
else
{
/**
* S'il s'agit des résultats de la dernière exploration,
* alors les groupes contenant les éléments chargés vont
* être libéré, potentiellement pendant l'analyse.
*
* On temporise en incrémentant les références.
*/
g_object_ref(G_OBJECT(available[i]));
g_signal_connect(available[i], "analyzed", G_CALLBACK(on_loaded_content_analyzed), project);
g_loaded_content_analyze(available[i]);
}
}
free(access);
if(xobject != NULL)
xmlXPathFreeObject(xobject);
g_object_unref(G_OBJECT(available[i]));
}
}
/* Découverte(s) initiale(s) ? */
else
{
for (i = 0; i < count; i++)
{
/**
* S'il s'agit des résultats de la dernière exploration,
* alors les groupes contenant les éléments chargés vont
* être libéré, potentiellement pendant l'analyse.
*
* On temporise en incrémentant les références.
*/
g_object_ref(G_OBJECT(available[i]));
g_signal_connect(available[i], "analyzed", G_CALLBACK(on_loaded_content_analyzed), project);
g_loaded_content_analyze(available[i]);
g_object_unref(G_OBJECT(available[i]));
}
}
/* Dans tous les cas... */
if (available != NULL)
free(available);
/* Si c'était la dernière résolution... */
if (++params->resolved == params->exp_count)
g_study_project_destroy_content_loading(project, params);
}
g_mutex_unlock(&project->ld_mutex);
}
/******************************************************************************
* *
* Paramètres : content = contenu chargé et analysé. *
* success = bilan d'une analyse menée. *
* project = projet avide des résultats des opérations. *
* *
* Description : Réceptionne la recette d'une analyse de contenu. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void on_loaded_content_analyzed(GLoadedContent *content, gboolean success, GStudyProject *project)
{
const char *desc; /* Description du contenu */
desc = g_loaded_content_describe(content, true);
if (success)
{
g_study_project_attach_content(project, content);
log_variadic_message(LMT_INFO, _("Content from '%s' has been analyzed successfully!"), desc);
}
else
log_variadic_message(LMT_ERROR, _("Failed to load '%s'"), desc);
g_object_ref(G_OBJECT(content));
}
/******************************************************************************
* *
* Paramètres : project = project à manipuler. *
* content = contenu chargé à associer au projet actuel. *
* *
* Description : Attache un contenu donné à un projet donné. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_study_project_attach_content(GStudyProject *project, GLoadedContent *content)
{
g_mutex_lock(&project->mutex);
project->contents = (GLoadedContent **)realloc(project->contents,
++project->count * sizeof(GLoadedContent *));
project->contents[project->count - 1] = content;
g_object_ref(G_OBJECT(content));
g_mutex_unlock(&project->mutex);
g_signal_emit_by_name(project, "content-added", content);
}
/******************************************************************************
* *
* Paramètres : project = project à manipuler. *
* content = contenu chargé à dissocier du projet actuel. *
* *
* Description : Détache un contenu donné d'un projet donné. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_study_project_detach_content(GStudyProject *project, GLoadedContent *content)
{
size_t i; /* Boucle de parcours */
g_mutex_lock(&project->mutex);
for (i = 0; i < project->count; i++)
if (project->contents[i] == content) break;
if ((i + 1) < project->count)
memmove(&project->contents[i], &project->contents[i + 1],
(project->count - i - 1) * sizeof(GLoadedContent *));
project->contents = (GLoadedContent **)realloc(project->contents,
--project->count * sizeof(GLoadedContent *));
g_mutex_unlock(&project->mutex);
g_signal_emit_by_name(project, "content-removed", content);
g_object_unref(G_OBJECT(content));
}
/******************************************************************************
* *
* Paramètres : project = projet dont le contenu est à afficher. *
* *
* Description : Met en place un projet à l'écran. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_study_project_display(const GStudyProject *project)
{
#if 0
size_t i; /* Boucle de parcours #1 */
loaded_binary *handled; /* Binaire prise en compte */
size_t j; /* Boucle de parcours #2 */
for (i = 0; i < project->binaries_count; i++)
{
handled = project->binaries[i];
for (j = 0; j < handled->count; j++)
g_panel_item_dock(handled->items[j]);
}
#endif
}
/******************************************************************************
* *
* Paramètres : project = projet dont le contenu est à cacher. *
* *
* Description : Supprime de l'écran un projet en place. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_study_project_hide(const GStudyProject *project)
{
#if 0
size_t i; /* Boucle de parcours #1 */
loaded_binary *handled; /* Binaire prise en compte */
size_t j; /* Boucle de parcours #2 */
for (i = 0; i < project->binaries_count; i++)
{
handled = project->binaries[i];
for (j = 0; j < handled->count; j++)
g_panel_item_undock(handled->items[j]);
}
#endif
}
/******************************************************************************
* *
* Paramètres : project = projet dont le contenu est à afficher. *
* count = nombre de contenus pris en compte. [OUT] *
* *
* Description : Fournit l'ensemble des contenus associés à un projet. *
* *
* Retour : Liste à libérer de la mémoire. *
* *
* Remarques : - *
* *
******************************************************************************/
GLoadedContent **g_study_project_get_contents(GStudyProject *project, size_t *count)
{
GLoadedContent **result; /* Tableau à retourner */
size_t i; /* Boucle de parcours */
g_mutex_lock(&project->mutex);
*count = project->count;
result = (GLoadedContent **)calloc(*count, sizeof(GLoadedContent *));
for (i = 0; i < *count; i++)
{
result[i] = project->contents[i];
g_object_ref(G_OBJECT(result[i]));
}
g_mutex_unlock(&project->mutex);
return result;
}
/* ---------------------------------------------------------------------------------- */
/* GESTION GLOBALISEE DES PROJETS */
/* ---------------------------------------------------------------------------------- */
/******************************************************************************
* *
* Paramètres : - *
* *
* Description : Fournit le gestionnaire des projets connus. *
* *
* Retour : Instance de gestion unique. *
* *
* Remarques : - *
* *
******************************************************************************/
GtkRecentManager *get_project_manager(void)
{
static GtkRecentManager *result = NULL; /* Singleton à retourner */
if (result == NULL)
{
result = gtk_recent_manager_get_default();
//gtk_recent_manager_purge_items(result, NULL);
}
return result;
}
/******************************************************************************
* *
* Paramètres : project = projet à traiter. *
* *
* Description : Place un projet au sommet de la pile des projets récents. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void push_project_into_recent_list(const GStudyProject *project)
{
GtkRecentManager *manager; /* Gestionnaire global */
char *qualified; /* Chemin avec 'file://' */
GtkRecentData recent; /* Données complètes */
if (project->filename == NULL)
return;
/* Constitution de la liste des projets récents */
manager = get_project_manager();
qualified = (char *)calloc(strlen("file://") + strlen(project->filename) + 1, sizeof(char));
strcpy(qualified, "file://");
strcat(qualified, project->filename);
memset(&recent, 0, sizeof(GtkRecentData));
recent.mime_type = "application/chrysalide.project";
recent.app_name = "Chrysalide";
recent.app_exec = "chrysalide -p %f";
gtk_recent_manager_add_full(manager, qualified, &recent);
free(qualified);
/* Pour la prochaine ouverture du programme... */
g_generic_config_set_value(get_main_configuration(), MPK_LAST_PROJECT, project->filename);
}