//**********************************************************************************************************************************************************************************
//	Fichier BDD_ADMIN.C 
//
//	Contient les fonctions de supervision de la BDD (archivage, sauvegard,...)
//
//**********************************************************************************************************************************************************************************

// #define __DEBUG_ARCHIVAGE						//Décommenter cette ligne pour avoir les messages de debug concernant les fonctions d'archivage
 
// Include :
#include "main.h"

// Prototypes :
int32_t sauvegarde_bdd(void);
int8_t archivage_bdd(char * chaine_date_fin, uint8_t type);
 

// Variables globales :

 

//==================================================================================================================================================================
// Fonction	: 	Cette fonction génère un fichier de sauvegarde de la base de données. 
// 				Le fichier est stocké dans le répertoire d'upload pour pouvoir être remonté au serveur Koriolan via FTP ensuite (cette remontée ne fait pas partie de la présente fonction)
//				La base de données est sauvegardée en totalité (tous les enregistrements de toutes les tables) SAUF :
//					- les tables TB_Mesures_xxx : seuls les enregistrements dont le champ No_paquet est identique au No_paquet de TB_Systeme sont remontés.
//					- la table TB_Historique : seuls les enregistrements dont le champ No_paquet est identique au No_paquet de TB_Systeme sont remontés.
//				Le champ No_paquet de TB_Systeme est incrémenté dès la fin de l'archive (afin que les nouveaux enregistrements soient tagués avec ce nouveau n°)
// Reçoit 	: 	Rien
// Renvoit 	: 	0 si pas d'erreur. Valeur de retour du premier appel 'system()' qui est différent de 0.
//==================================================================================================================================================================
int32_t sauvegarde_bdd(void)
{
int32_t retour_commande;
char str_date[MAX_LONGUEUR_DATE_COURANTE];
char nom_fichier_sauvegarde[MAX_LONGUEUR_NOM_FICHIER_SAUVEGARDE_BDD];
FILE * ptr_fichier_sauvegarde;
char requete[MAX_LONGUEUR_REQUETE_MYSQL];
char commande[MAX_TAILLE_COMMANDE_SHELL];
char options[MAX_LONGUEUR_OPTION_COMMANDE_SAUVEGARDE_BDD];
char filtre_table[MAX_LONGUEUR_OPTION_COMMANDE_SAUVEGARDE_BDD];
char param[MAX_LONGUEUR_OPTION_COMMANDE_SAUVEGARDE_BDD];
struct {
	char nom[MAX_LONGUEUR_NOM_TABLE];							// Nom de la table (par exemple, TB_Mesures_capteurs')
} tables_fragmentees[MAX_NOMBRE_TABLES_FRAGMENTEES];
uint8_t	nb_tables_fragmentees;
MYSQL_RES *result = NULL;	
MYSQL_ROW row = NULL;
uint16_t i;
char tmp[MAX_LONGUEUR_BUFFER_TEMPORAIRE_DEBUG];


	sprintf(tmp, "Début de sauvegarde de la BDD avec n° de paquet = %i", systeme.no_paquet);
	affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_PAR_DEFAUT);

	// SDIR # 202 (début) :
	// Vérification qu'une phase d'archivage n'est pas en cours (si c'est le cas, on va décaler la sauvagarde pour éviter de surcharger inutilement le système) :
	if (get_pid_numbers_from_name(NOM_FICHIER_ARCHIVAGE, "") > 0)	// Il y a au moins 1 processus d'archivage en cours...
	{		
		systeme.compteur_sauvegarde_bdd = SYSTEME_TEMPO_REPORT_SAUVEGARDE;				// Dans ce cas, on relance une tempo courte (5s typique) avant de refaire une tentative. 

		sprintf(tmp, "Un processus [%s] a été détecté en cours d'exécution. La sauvegarde est temporisée pour %i secondes", NOM_FICHIER_ARCHIVAGE, systeme.compteur_sauvegarde_bdd);
		affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_ERREUR);

		return (-1);
	}
	// SDIR # 202 (fin)



	retour_commande = 0;
	
	// Calcul de la date et de l'heure, au bon format :
	date_courante(str_date, DATE_COURANTE_SANS_MS, FORMAT_DATE_COURANTE_FICHIER);

	// Nom du fichier de sauvegarde :
//	sprintf(nom_fichier_sauvegarde, "%s/%s_%s.sql", REPERTOIRE_SERVER_UPLOAD, NOM_FICHIER_SAUVEGARDE_BDD, str_date);								// SDIR #298
	sprintf(nom_fichier_sauvegarde, 																												// SDIR #298
			"%s/%02X%02X%02X%02X%02X%02X_%08i_%s.sql", 					// Le '%08i' permet de forcer le n° de paquet avec 8 chiffres commençant par 0. Sinon, '10' est trié avant '9' par exemple. 8 chiffres = 1 fichier par minutes pendant 190 ans...
			REPERTOIRE_SERVER_UPLOAD, 
			systeme.modules_physiques[0].adresse_mac[0], systeme.modules_physiques[0].adresse_mac[1], systeme.modules_physiques[0].adresse_mac[2], 
			systeme.modules_physiques[0].adresse_mac[3], systeme.modules_physiques[0].adresse_mac[4], systeme.modules_physiques[0].adresse_mac[5], 
			systeme.no_paquet, str_date);			// SDIR #298
	
	// Options de la commande de sauvegarde (utilisée sur la commande 'mysqldump' :
	sprintf(options, "--single-transaction --no-create-info --compact --complete-insert");
//	sprintf(options, "--single-transaction --skip-lock-tables --no-create-info --compact --complete-insert");	// SDIR # 202
	
	
	do	// Fake loop...
	{
		//-------------------------------------------------------------------------------------------
		// Remplissage de l'entête du fichier de sauvegarde (SDIR #292) :
		//-------------------------------------------------------------------------------------------
		ptr_fichier_sauvegarde = fopen(nom_fichier_sauvegarde, "w+");				// Ouverture du flux en lecture/écriture. Si le fichier existe, il sera alors écrasé et la position courante est fixée au début du fichier. Sinon le fichier sera créé.
		if (ptr_fichier_sauvegarde == NULL) 
		{
			printf("Ouverture du fichier de sauvegarde [ %s ] impossible. La sauvegarde est arrêtée !\n", nom_fichier_sauvegarde);
			retour_commande = -1;
			break;
		}
		
		// Attention : le format '# [nom_de_champ=valeur_du_champ]' est utilisé par la fonction 'upload_code.php' sur le serveur... 
		// Il est donc fortement conseillé de ne PAS modifier le format de ces trames d'entête !!!
		fprintf(ptr_fichier_sauvegarde, 
				"# [Adresse_mac=%02X:%02X:%02X:%02X:%02X:%02X]\n", 
				systeme.modules_physiques[0].adresse_mac[0], systeme.modules_physiques[0].adresse_mac[1], systeme.modules_physiques[0].adresse_mac[2], 
				systeme.modules_physiques[0].adresse_mac[3], systeme.modules_physiques[0].adresse_mac[4], systeme.modules_physiques[0].adresse_mac[5]);
		fprintf(ptr_fichier_sauvegarde, "# [Nom_du_bateau=%s]\n", systeme.nom_bateau);
		fprintf(ptr_fichier_sauvegarde, "# [No_paquet=%i]\n", systeme.no_paquet);
		fprintf(ptr_fichier_sauvegarde, "# [Date_fichier=%s]\n", str_date);
		fprintf(ptr_fichier_sauvegarde, "# [Version_soft_no_package=%s]\n", systeme.package_no_version);
		
		fclose(ptr_fichier_sauvegarde);
		
		// Fin de SDIR #292
		
		
		//-------------------------------------------------------------------------------------------
		// Recherche des tables fragmentées : TB_Mesures* et TB_Historique
		//-------------------------------------------------------------------------------------------
		nb_tables_fragmentees = 0;
		
		// Tables de mesures :
		sprintf(requete, "SHOW TABLES FROM shipheart LIKE 'TB_Mesures%%'"); 
		mysql_query(bdd.pointeur, requete);	
		result = mysql_store_result(bdd.pointeur);
		while((row = mysql_fetch_row(result)))
		{
			strcpy(tables_fragmentees[nb_tables_fragmentees ++].nom, row[0]);
		}
		mysql_free_result(result);
		
		// Table historique :
		strcpy(tables_fragmentees[nb_tables_fragmentees ++].nom, "TB_Historique");	
				
		// Vérification du nombre de tables max :
		if (nb_tables_fragmentees > MAX_NOMBRE_TABLES_FRAGMENTEES)
		{
			sprintf(tmp, "Le nombre de tables fragmentées (qui sont sauvegardées par fragment) est supérieur au nombre maxi (%i tables trouvées pour maxi = %i). La sauvegarde de la BDD est arrêté.", nb_tables_fragmentees, MAX_NOMBRE_TABLES_FRAGMENTEES);
			affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_ERREUR);
			retour_commande = -1;
			break;
		}
	
//printf("Le nombre de tables fragmentées trouvé est : %i \n", nb_tables_fragmentees);
//for (i = 0; i < nb_tables_fragmentees; i ++) printf("\tTable #%i: [%s]\n", i, tables_fragmentees[i].nom);
	
		//-------------------------------------------------------------------------------------------
		// Sauvegarde de toutes les tables, sauf TB_Mesures* et TB_Historique :
		//-------------------------------------------------------------------------------------------
		
		// Début de la commande de dump: 
		sprintf(commande, "mysqldump %s -u %s --password=%s %s ", options, BDD_USER, BDD_PASSWORD, BDD_DATABASE);
		
		// Suppression des tables fragmentées du dump :
		for (i = 0; i < nb_tables_fragmentees; i ++)
		{
			#pragma GCC diagnostic push
			#pragma GCC diagnostic ignored "-Wformat-overflow"
			sprintf(param, "--ignore-table=%s.%s ", BDD_DATABASE, tables_fragmentees[i].nom);		// Warning connu mais non justifié : tables_fragmentees[].nom : 50 car et param : 300 car
			#pragma GCC diagnostic pop

			strcat(commande, param);
		}

		// Fin de la commande :
		sprintf(param, ">> %s ", nom_fichier_sauvegarde);
		strcat(commande, param);

// printf("Commande shell = [%s]\n", commande);
	
		retour_commande = commande_shell(commande);
		if (retour_commande != 0) 
		{
			sprintf(tmp, "La commande de sauvegarde de toutes les tables non fragmentées [%s] a échoué avec le code %i", commande, retour_commande);
			affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_ERREUR);
			break;
		}


		//---------------------------------------------------------------------
		// Sauvegarde des derniers enregistrements des tables fragmentées :
		//---------------------------------------------------------------------
		for (i = 0; i < nb_tables_fragmentees; i ++)
		{
			// Ajout au fichier de sauvegarde des enregistrements de la table dont le No_paquet est égal à celui de TB_Systeme.No_paquet :
// NB : la requête pourrait être complétée d'un 'ORDER BY Date'	mais cela risque de prendre du temps et ne semble pas nécessaire...

			// Suppression des 'Type>0' pour TB_Mesures_circuits :
			if (strstr(tables_fragmentees[i].nom, "TB_Mesures_circuits") != NULL) strcpy(filtre_table, " AND Type=0");
			else strcpy(filtre_table, "");
			sprintf(commande, "mysqldump %s -u %s --password=%s %s %s --where=\"No_paquet=%i %s \" >> %s", options, BDD_USER, BDD_PASSWORD, BDD_DATABASE, tables_fragmentees[i].nom, systeme.no_paquet, filtre_table, nom_fichier_sauvegarde);	
//printf("Commande shell = [%s]\n", commande);
			retour_commande = commande_shell(commande);
			if (retour_commande != 0)
			{
				sprintf(tmp, "La commande de sauvegarde de la table fragmentée %s [%s] a échoué avec le code %i", tables_fragmentees[i].nom, commande, retour_commande);
				affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_ERREUR);
				break;		// Sortie de la boucle FOR
			}
		}	
		if (retour_commande != 0) break;

		//---------------------------------------------------------------------
		// Compression du fichier de sauvegarde :
		//---------------------------------------------------------------------
		// SDIR #170 : ajout du paramètre '-k' dans la commande de compresion afin de conserver le fichier SQL initial (sinon, il n'est pas conservé par GZIP)
		sprintf(commande, "gzip %s -k -S .%s", nom_fichier_sauvegarde, SUFFIXE_NOM_FICHIER_COMPRESSE_SAUVEGARDE_BDD);
//		sprintf(tmp, "Commande de compression = [%s]\n", commande);
//		affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_WARNING);
		retour_commande = commande_shell(commande);
		if (retour_commande != 0)
		{
			sprintf(tmp, "La commande de compression du fichier de sauvegarde [%s] a échoué avec le code %i", commande, retour_commande);
			affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_ERREUR);
			break;
		}

		//---------------------------------------------------------------------
		// Encryption du fichier de sauvegarde :
		//---------------------------------------------------------------------
		sprintf(commande, "openssl enc -aes-256-cbc -pbkdf2 -iter 10000 -md sha256 -in %s.%s -out %s.%s.%s -pass pass:%s", nom_fichier_sauvegarde, SUFFIXE_NOM_FICHIER_COMPRESSE_SAUVEGARDE_BDD, nom_fichier_sauvegarde, SUFFIXE_NOM_FICHIER_COMPRESSE_SAUVEGARDE_BDD, SUFFIXE_NOM_FICHIER_ENCRYPTE_SAUVEGARDE_BDD, BDD_PASSWORD);
//		sprintf(tmp, "Commande d'encryptage = [%s]\n", commande);
//		affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_WARNING);		
		retour_commande = commande_shell(commande);
		if (retour_commande != 0) 
		{
			sprintf(tmp, "La commande d'encryption du fichier de sauvegarde [%s] a échoué avec le code %i", commande, retour_commande);
			affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_ERREUR);
			break;
		}
		
		// SDIR #170 : cf jusqu'à la fin de la fake loop...
		//---------------------------------------------------------------------
		// Décryptage du fichier final :
		//---------------------------------------------------------------------
		sprintf(commande, "openssl enc -aes-256-cbc -pbkdf2 -iter 10000 -md sha256 -d -in %s.%s.%s -out %s/%s.sql.%s -pass pass:Mp7Hgf12bV9zm", nom_fichier_sauvegarde, SUFFIXE_NOM_FICHIER_COMPRESSE_SAUVEGARDE_BDD, SUFFIXE_NOM_FICHIER_ENCRYPTE_SAUVEGARDE_BDD, REPERTOIRE_TMP_BDD, NOM_FICHIER_CHECK_SAUVEGARDE, SUFFIXE_NOM_FICHIER_COMPRESSE_SAUVEGARDE_BDD);
//		sprintf(tmp, "Commande de décryptage temporaire = [%s]\n", commande);
//		affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_WARNING);		
		retour_commande = commande_shell(commande);
		if (retour_commande != 0) 
		{
			sprintf(tmp, "La commande de décrytage temporaire du fichier de sauvegarde [%s] a échoué avec le code %i", commande, retour_commande);
			affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_ERREUR);
			break;
		}
		
		//---------------------------------------------------------------------
		// Décompression du fichier temporaire :
		//---------------------------------------------------------------------
		sprintf(commande, "gzip -d -f %s/%s.sql.%s", REPERTOIRE_TMP_BDD, NOM_FICHIER_CHECK_SAUVEGARDE, SUFFIXE_NOM_FICHIER_COMPRESSE_SAUVEGARDE_BDD);
//		sprintf(tmp, "Commande de décompression temporaire = [%s]\n", commande);
//		affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_WARNING);
		retour_commande = commande_shell(commande);
		if (retour_commande != 0)
		{
			sprintf(tmp, "La commande de décompression temporaire [%s] a échoué avec le code %i", commande, retour_commande);
			affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_ERREUR);
			break;
		}
		
		//---------------------------------------------------------------------
		// Comparaison du fichier temporaire avec le fichier inital :
		//---------------------------------------------------------------------
		sprintf(commande, "diff -q %s %s/%s.sql", nom_fichier_sauvegarde, REPERTOIRE_TMP_BDD, NOM_FICHIER_CHECK_SAUVEGARDE);
//sprintf(commande, "diff -q %s %s/%s_test.sql", nom_fichier_sauvegarde, REPERTOIRE_TMP_BDD, NOM_FICHIER_CHECK_SAUVEGARDE);		

//		sprintf(tmp, "Commande de comparaison du fichier temporaire avec le fchier inital = [%s]\n", commande);
//		affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_WARNING);
		retour_commande = commande_shell(commande);
		if (retour_commande != 0)
		{
			sprintf(tmp, "La comparaison du fichier temporaire avec le fichier inital [%s] indique deux fichiers différents [%i]", commande, retour_commande);
			affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_ERREUR);
			break;
		}
		
	} while(0);
	

	//---------------------------------------------------------------------
	// Vérification que la sauvegarde s'est bien passée et retour :
	//---------------------------------------------------------------------
	if (retour_commande != 0) 								// Cas où au moins l'une des opérations de sauvegarde ne s'est pas bien passée
	{
		// Enregistrement dans l'historique :
		enregistrement_historique(TYPE_SOURCE_HISTORIQUE_SYSTEME, SYSTEME_ERREUR_SAUVEGARDE_BDD, 0, 0, tmp);
		
		// Suppression du fichier qui est incomplet, mais aussi du fichier compressé et du fichier encrypté car on ne sait pas où on s'est arrêté) :
		sprintf(commande, "%s", nom_fichier_sauvegarde);
		remove(commande);
		sprintf(commande, "%s.%s", nom_fichier_sauvegarde, SUFFIXE_NOM_FICHIER_COMPRESSE_SAUVEGARDE_BDD);
		remove(commande);
		sprintf(commande, "%s.%s.%s", nom_fichier_sauvegarde, SUFFIXE_NOM_FICHIER_COMPRESSE_SAUVEGARDE_BDD, SUFFIXE_NOM_FICHIER_ENCRYPTE_SAUVEGARDE_BDD);
		remove(commande);
				
		sprintf(tmp, "La sauvegarde de la BDD est abandonnée. Les fichiers créés ont été supprimés et les indicateurs de sauvegarde dans TB_Systeme ont été remis à leur valeur d'origine.");
		affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_ERREUR);
		// NB : en pratique, c'est le fait de ne PAS incrémenter le n° de paquet dans TB_Systeme qui permettra de reprendre les enregistrements qui étaient prévus dans cet archive dans la prochaine. 

		return(retour_commande);		
	}
	else 												// Cas normal, sans erreur :
	{
		// Incrémentation du No_paquet :
		systeme.no_paquet ++;
		sprintf(requete, "UPDATE TB_Systeme SET Valeur='%i' WHERE Nom='No_paquet' ", systeme.no_paquet);	
// printf("requête = [%s]\n", requete);
		mysql_query(bdd.pointeur, requete);	
		
		// Supression du fichier SQL (qui a été volontairement conservé via le paramètre '-k' de GZIP)...
		// ... et du fichier compressé (openssl ne peut pas "écraser" la source si elle est dans le même répertoire ; on le fait donc manuellement)...
		// ... si tout s'est bien passé  :
		sprintf(commande, "%s", nom_fichier_sauvegarde);
		remove(commande);
		sprintf(commande, "%s.%s", nom_fichier_sauvegarde, SUFFIXE_NOM_FICHIER_COMPRESSE_SAUVEGARDE_BDD);
		remove(commande);
	}
	
	affichage_debug(__FILE__, __LINE__, "Fin de sauvegarde de la BDD", TYPE_MESSAGE_DEBUG_PAR_DEFAUT);
	return(0);
}



//**********************************************************************************************************************************************************************************
//	Fonction ARCHIVAGE_BDD
//
//	Fonction :	Lance l'utilitaire 'archivage.php' situé dans '/utils'
//	Reçoit :	la chaine de date de fin de période à utiliser et le Type d'archivage à réaliser (de 0 à 3 ou 10 - cf bdd.h : BDD_TYPE_ARCHIVAGE_xxxx)
//	Retour :	-1 en cas d'erreur, 0 si Ok
//**********************************************************************************************************************************************************************************
int8_t archivage_bdd(char * chaine_date_fin, uint8_t type)
{
char commande[MAX_TAILLE_COMMANDE_SHELL];
time_t now;
struct tm maintenant;
int32_t pid_nb;
char suffixe_fichier_log[MAX_LONGUEUR_NOM_FICHIER];
char tmp[MAX_LONGUEUR_BUFFER_TEMPORAIRE_DEBUG];
	

	// Calcul de la date courante pour nommer le fichier de logs :
	time(&now);
	maintenant = *localtime(&now);

	// Vérification des paramètres & préparation du suffixe de fichier de logs :
	switch(type)
	{	
		case BDD_TYPE_ARCHIVAGE_1_HEURE :
		{
			sprintf(suffixe_fichier_log, "_h%02i", maintenant.tm_hour);
			break;
		}
		case BDD_TYPE_ARCHIVAGE_5_MINUTES :
		{
			sprintf(suffixe_fichier_log, "_min%02i", maintenant.tm_min);
			break;
		}
		case BDD_TYPE_ARCHIVAGE_PURGE_SEULE :
		{
			sprintf(suffixe_fichier_log, "_purge_demarrage");		// Cet appel n'étant fait qu'au démarrage (et donc à des heures/min non définies, on prend un nom générique qui sera donc écrasé à chaque démarrage)
			break;
		}
		case BDD_TYPE_ARCHIVAGE_1_HEURE_ET_PURGE :
		case BDD_TYPE_ARCHIVAGE_5_MINUTES_ET_PURGE :
		{
			sprintf(suffixe_fichier_log, "_purge_%02i_%02i", maintenant.tm_hour, maintenant.tm_min);
			break;
		}
		default : return (-1);
	}
	
	// Récupération du nombre de process incluant 'archivage.php' :
	pid_nb = get_pid_numbers_from_name(NOM_FICHIER_ARCHIVAGE, "");

	// Archivage si aucun processus équivalent n'est déjà en cours :
	if (pid_nb <= 0) 			// Il ny a aucun processus d'archivage en cours...
	{
		sprintf(commande, "sudo  nice -n 18 php %s/%s \"%s\" %i >%s/%s%s.txt &", REPERTOIRE_UTILS, NOM_FICHIER_ARCHIVAGE, chaine_date_fin, type, REPERTOIRE_LOGS, PREFIXE_NOM_FICHIER_ARCHIVAGE_LOG, suffixe_fichier_log);	// AVEC '&' de terminaison car c'était bien l'objectif, de faire exécuter cette tâche en tâche de fond...!
		commande_shell(commande);
	
		if (pid_nb == 0)
		{
			sprintf(tmp, "La commande d'archivage [%s] vient d'être lancée en tâche de fond car aucun processus d'archivage n'a été détecté en cours d'exécution", commande);
			affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_OK);
		}
		else		
		{
			sprintf(tmp, "Le retour de recherche de processus d'archivage en cours a détecté une erreur (%i). L'archivage demandé est exécuté quand même...", pid_nb);
			affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_WARNING);
		}
	}
	else 						// Il y a déjà un processus en cours :
	{
		sprintf(tmp, "Au moins un processus d'archivage a été détecté en cours d'exécution (nb = %i). L'archivage demandé n'est donc pas exécuté...", pid_nb);
		affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_WARNING);
		
		// NB : dans ce cas, on ne met pas à jour 'systeme.jour_dernier_archivage' afin qu'une nouvelle tentative soit effectuée dans 5 minutes...
	}
	

	//--------------------------------------- RETOUR ------------------------------------
	return(0);
}