Pierre/shipheart-appli
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

sauvegarde_bdd() : ajout du champ Origine_bdd dans l'en-tête (normale/factory/restauration), lu depuis TB_Systeme et remis à 'normale' une fois l'archive confirmée transmise (cf synthèse §35)

Browse Source
This commit is contained in:
Pierre
2026-09-30 12:12:44 +02:00
parent b03d779e0b
commit ec56421680
1 changed files with 32 additions and 311 deletions
Download Patch File Download Diff File Expand all files Collapse all files
sources/bdd_admin.c
+32 -311
View File
@@ -18,311 +18,6 @@ int8_t archivage_bdd(char * chaine_date_fin, uint8_t type);
// Variables globales : // 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 : Cette fonction génère un fichier de sauvegarde de la base de données. // 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 ship2net (récupéré via l'API shipheart_api, cf synthèse §32). // Le fichier est stocké dans le répertoire d'upload pour pouvoir être remonté au serveur ship2net (récupéré via l'API shipheart_api, cf synthèse §32).
@@ -341,12 +36,13 @@ int32_t sauvegarde_bdd(void)
{ {
int32_t retour_commande; int32_t retour_commande;
char str_date[MAX_LONGUEUR_DATE_COURANTE]; char str_date[MAX_LONGUEUR_DATE_COURANTE];
char nom_base[75]; // <Adresse_mac>_<Date_fichier>, sans extension ni empreinte char nom_base[75]; // <Adresse_mac>_<Date_fichier>, sans extension ni empreinte (inconnue à ce stade) - taille ajustée pour couvrir le pire cas (12+1+jusqu'à MAX_LONGUEUR_DATE_COURANTE) sans repousser le calcul GCC au pire cas sur nom_fichier_final au-delà du seuil (une taille plus généreuse, ex: 100, refait apparaître ce même avertissement plus bas dans la fonction)
char nom_fichier_sauvegarde[MAX_LONGUEUR_NOM_FICHIER_SAUVEGARDE_BDD]; char nom_fichier_sauvegarde[MAX_LONGUEUR_NOM_FICHIER_SAUVEGARDE_BDD];
char nom_fichier_final[MAX_LONGUEUR_NOM_FICHIER_SAUVEGARDE_BDD]; // Nom définitif, après renommage avec l'empreinte char nom_fichier_final[MAX_LONGUEUR_NOM_FICHIER_SAUVEGARDE_BDD]; // Nom définitif, après renommage avec l'empreinte
char chemin_temp_empreinte[MAX_LONGUEUR_NOM_FICHIER_SAUVEGARDE_BDD]; char chemin_temp_empreinte[MAX_LONGUEUR_NOM_FICHIER_SAUVEGARDE_BDD];
char empreinte[17]; // 16 caractères hexadécimaux + '\0' char empreinte[17]; // 16 caractères hexadécimaux + '\0'
char no_mmsi[16]; // "000000000" par défaut (9 chiffres) - cf TB_Configuration char no_mmsi[16]; // "000000000" par défaut (9 chiffres) - cf TB_Configuration
char origine_bdd[16]; // "normale" par défaut - cf TB_Systeme.Origine_bdd (synthèse §35)
FILE * ptr_fichier_sauvegarde; FILE * ptr_fichier_sauvegarde;
FILE * ptr_fichier_empreinte; FILE * ptr_fichier_empreinte;
char requete[MAX_LONGUEUR_REQUETE_MYSQL]; char requete[MAX_LONGUEUR_REQUETE_MYSQL];
@@ -395,6 +91,18 @@ char tmp[MAX_LONGUEUR_BUFFER_TEMPORAIRE_DEBUG];
else strcpy(no_mmsi, "000000000"); // Valeur par défaut si jamais introuvable (ne devrait normalement pas arriver) else strcpy(no_mmsi, "000000000"); // Valeur par défaut si jamais introuvable (ne devrait normalement pas arriver)
if (result != NULL) mysql_free_result(result); if (result != NULL) mysql_free_result(result);
// NOUVEAU : lecture de l'origine de la BDD locale (TB_Systeme.Origine_bdd), transmise dans l'en-tête (cf synthèse §35).
// Posée à 'factory' ou 'restauration' par la procédure de réinitialisation/restauration, APRÈS que celle-ci soit
// entièrement terminée (y compris, pour une restauration, après le rechargement de Bateau_data - sans quoi cette
// valeur serait écrasée par celle, ancienne, contenue dans la sauvegarde elle-même). Remise à 'normale' plus bas,
// une fois cette archive confirmée transmise avec succès - donc transmise une seule fois.
sprintf(requete, "SELECT Valeur FROM TB_Systeme WHERE Nom='Origine_bdd'");
mysql_query(bdd.pointeur, requete);
result = mysql_store_result(bdd.pointeur);
if ((result != NULL) && ((row = mysql_fetch_row(result)) != NULL)) strcpy(origine_bdd, row[0]);
else strcpy(origine_bdd, "normale"); // Valeur par défaut si jamais introuvable (ne devrait normalement pas arriver)
if (result != NULL) mysql_free_result(result);
// Nom de base du fichier - SANS empreinte (inconnue à ce stade, calculée plus bas) NI No_paquet (abandonné) : // Nom de base du fichier - SANS empreinte (inconnue à ce stade, calculée plus bas) NI No_paquet (abandonné) :
sprintf(nom_base, "%02X%02X%02X%02X%02X%02X_%s", sprintf(nom_base, "%02X%02X%02X%02X%02X%02X_%s",
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[0], systeme.modules_physiques[0].adresse_mac[1], systeme.modules_physiques[0].adresse_mac[2],
@@ -426,9 +134,10 @@ char tmp[MAX_LONGUEUR_BUFFER_TEMPORAIRE_DEBUG];
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[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.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, "# [Nom_du_bateau=%s]\n", systeme.nom_bateau);
fprintf(ptr_fichier_sauvegarde, "# [No_mmsi=%s]\n", no_mmsi); // NOUVEAU (cf synthèse §32.3/32.4)
fprintf(ptr_fichier_sauvegarde, "# [Date_fichier=%s]\n", str_date); fprintf(ptr_fichier_sauvegarde, "# [Date_fichier=%s]\n", str_date);
fprintf(ptr_fichier_sauvegarde, "# [Version_soft_no_package=%s]\n", systeme.package_no_version); fprintf(ptr_fichier_sauvegarde, "# [Version_soft_no_package=%s]\n", systeme.package_no_version);
fprintf(ptr_fichier_sauvegarde, "# [No_mmsi=%s]\n", no_mmsi); // NOUVEAU (cf synthèse §32.3/32.4) fprintf(ptr_fichier_sauvegarde, "# [Origine_bdd=%s]\n", origine_bdd); // NOUVEAU (cf synthèse §35)
fclose(ptr_fichier_sauvegarde); fclose(ptr_fichier_sauvegarde);
@@ -495,8 +204,10 @@ char tmp[MAX_LONGUEUR_BUFFER_TEMPORAIRE_DEBUG];
//--------------------------------------------------------------------- //---------------------------------------------------------------------
// Sauvegarde des derniers enregistrements des tables fragmentées : // Sauvegarde des derniers enregistrements des tables fragmentées :
// CHANGEMENT : le filtre passe de 'No_paquet=%i' à 'Archive=0' - le marquage effectif (Archive=1) n'a lieu que plus bas, une fois // CHANGEMENT : le filtre passe de 'No_paquet=%i' à 'Archive=0' - le
// l'archive entièrement validée (cf synthèse §32.4). Tant que ce marquage n'a pas eu lieu, ces mêmes lignes seront reprises par la // marquage effectif (Archive=1) n'a lieu que plus bas, une fois
// l'archive entièrement validée (cf synthèse §32.4). Tant que ce
// marquage n'a pas eu lieu, ces mêmes lignes seront reprises par la
// prochaine tentative en cas d'échec à n'importe quelle étape suivante. // prochaine tentative en cas d'échec à n'importe quelle étape suivante.
//--------------------------------------------------------------------- //---------------------------------------------------------------------
for (i = 0; i < nb_tables_fragmentees; i ++) for (i = 0; i < nb_tables_fragmentees; i ++)
@@ -633,9 +344,8 @@ char tmp[MAX_LONGUEUR_BUFFER_TEMPORAIRE_DEBUG];
{ {
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wformat-overflow" #pragma GCC diagnostic ignored "-Wformat-overflow"
sprintf(tmp, "Le marquage des lignes archivées de la table %s [%s] a échoué : %s", tables_fragmentees[i].nom, requete, mysql_error(bdd.pointeur)); sprintf(tmp, "Le marquage des lignes archivées de la table %s [%s] a échoué : %s", tables_fragmentees[i].nom, requete, mysql_error(bdd.pointeur)); // Warning connu mais non justifié, cf plus haut dans ce fichier
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_ERREUR); affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_ERREUR);
retour_commande = -1; retour_commande = -1;
break; // Sortie de la boucle FOR break; // Sortie de la boucle FOR
@@ -643,6 +353,17 @@ char tmp[MAX_LONGUEUR_BUFFER_TEMPORAIRE_DEBUG];
} }
if (retour_commande != 0) break; if (retour_commande != 0) break;
// NOUVEAU : remise à 'normale' - cette archive vient d'être confirmée transmise avec succès, le signal
// 'factory'/'restauration' n'a donc plus besoin d'être retransmis à la prochaine archive (cf synthèse §35) :
sprintf(requete, "REPLACE INTO TB_Systeme (Nom, Valeur) VALUES ('Origine_bdd', 'normale')");
if (mysql_query(bdd.pointeur, requete) != 0)
{
sprintf(tmp, "La remise à 'normale' de TB_Systeme.Origine_bdd a échoué : %s", mysql_error(bdd.pointeur));
affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_ERREUR);
retour_commande = -1;
break;
}
} while(0); } while(0);