v1.1 unmolested from original dl source

Src/Dc_Memory.c

+/***********************************************************************/
+/*                                                                     */
+/* Dc_Memory.c : Module pour la bibliothque de gestion de la mmoire. */
+/*                                                                     */
+/***********************************************************************/
+/*  Auteur : Olivier ZARDINI  *  Brutal Deluxe Software  *  Dec 2011   */
+/***********************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <malloc.h>
+#include <errno.h>
+
+#include "Dc_Shared.h"
+#include "Dc_Prodos.h"
+#include "Dc_Memory.h"
+
+/***************************************************/
+/*  my_Memory() :  Gestion des ressources mmoire. */
+/***************************************************/
+void my_Memory(int code, void *data, void *value)
+{
+  int i, index;
+  char *path;
+  char *message;
+  static int nb_entry;
+  static struct file_descriptive_entry *first_entry;
+  static struct file_descriptive_entry *last_entry;
+  static struct file_descriptive_entry **tab_entry;
+  struct file_descriptive_entry *current_entry;
+  struct file_descriptive_entry *next_entry;
+  struct file_descriptive_entry *delete_entry;
+  static int nb_directory;
+  static struct file_descriptive_entry *first_directory;
+  static struct file_descriptive_entry *last_directory;
+  static struct file_descriptive_entry **tab_directory;
+  struct file_descriptive_entry *current_directory;
+  struct file_descriptive_entry *next_directory;
+  struct file_descriptive_entry *delete_directory;
+  static int nb_filepath;
+  static struct file_path *first_filepath;
+  static struct file_path *last_filepath;
+  struct file_path *current_filepath;
+  struct file_path *next_filepath;
+  static int nb_error;
+  static struct error *first_error;
+  static struct error *last_error;
+  struct error *current_error;
+  struct error *next_error;
+
+  switch(code)
+    {
+      case MEMORY_INIT :
+        nb_entry = 0;
+        first_entry = NULL;
+        last_entry = NULL;
+        tab_entry = NULL;
+        nb_directory = 0;
+        first_directory = NULL;
+        last_directory = NULL;
+        tab_directory = NULL;
+        nb_filepath = 0;
+        first_filepath = NULL;
+        last_filepath = NULL;
+        nb_error = 0;
+        first_error = NULL;
+        last_error = NULL;
+        break;
+
+      case MEMORY_FREE :
+        my_Memory(MEMORY_FREE_ENTRY,NULL,NULL);
+        my_Memory(MEMORY_FREE_DIRECTORY,NULL,NULL);
+        my_Memory(MEMORY_FREE_FILE,NULL,NULL);
+        my_Memory(MEMORY_FREE_ERROR,NULL,NULL);
+        break;
+
+      /*********************************************/
+      /*  Liste chaine des structure entry : File */
+      /*********************************************/
+      case MEMORY_ADD_ENTRY :
+        current_entry = (struct file_descriptive_entry *) data;
+        if(current_entry == NULL)
+          return;
+
+        /* Ajoute  la fin de la liste */
+        if(first_entry == NULL)
+          first_entry = current_entry;
+        else
+          last_entry->next = current_entry;
+        last_entry = current_entry;
+        nb_entry++;
+        break;
+
+      case MEMORY_GET_ENTRY_NB :
+        *((int *)data) = nb_entry;
+        break;
+
+      case MEMORY_GET_ENTRY :
+        index = *((int *) data);
+        *((struct file_descriptive_entry **) value) = NULL;
+        if(index <= 0 || index > nb_entry)
+          return;
+
+        /* Recherche le index-nth entry */
+        for(i=1, current_entry = first_entry; i<index; i++)
+          current_entry = current_entry->next;
+        *((struct file_descriptive_entry **) value) = current_entry;
+        break;
+
+      case MEMORY_BUILD_ENTRY_TAB :
+        /* Libration */
+        if(tab_entry)
+          free(tab_entry);
+
+        /* Allocation */
+        tab_entry = (struct file_descriptive_entry **) calloc(1+nb_entry,sizeof(struct file_descriptive_entry *));
+        if(tab_entry == NULL)
+          break;
+
+        /* Remplissage */
+        for(i=0, current_entry = first_entry; current_entry; i++,current_entry=current_entry->next)
+          tab_entry[i] = current_entry;
+        break;
+
+      case MEMORY_REMOVE_ENTRY :
+        delete_entry = (struct file_descriptive_entry *) data;
+        if(delete_entry == NULL)
+          break;
+
+        /* Cas particulier : 1 seule structure */
+        if(nb_entry == 1 && first_entry == delete_entry)
+          {
+            first_entry = NULL;
+            last_entry = NULL;
+            nb_entry = 0;
+          }
+        else if(first_entry == delete_entry)
+          {
+            /* En 1re position */
+            first_entry = first_entry->next;
+            memmove(&tab_entry[0],&tab_entry[1],(nb_entry-1)*sizeof(struct file_descriptive_entry *));
+            nb_entry--;
+          }
+        else if(last_entry == delete_entry)
+          {
+            /* En dernire position */
+            tab_entry[nb_entry-2]->next = NULL;
+            last_entry = tab_entry[nb_entry-2];
+            nb_entry--;
+          }
+        else
+          {
+            /* Au milieu */
+            for(i=0; i<nb_entry; i++)
+              if(tab_entry[i] == delete_entry)
+                {
+                  tab_entry[i-1]->next = tab_entry[i]->next;
+                  memmove(&tab_entry[i],&tab_entry[i+1],(nb_entry-i-1)*sizeof(struct file_descriptive_entry *));
+                  nb_entry--;
+                  break;
+                }
+          }
+        break;
+
+      case MEMORY_FREE_ENTRY :
+        for(current_entry = first_entry; current_entry; )
+          {
+            next_entry = current_entry->next;
+            mem_free_entry(current_entry);
+            current_entry = next_entry;
+          }
+        if(tab_entry)
+          free(tab_entry);
+        nb_entry = 0;
+        first_entry = NULL;
+        last_entry = NULL;
+        tab_entry = NULL;
+        break;
+
+      /***********************************************/
+      /*  Liste chaine des structure entry : SubDir */
+      /***********************************************/
+      case MEMORY_ADD_DIRECTORY :
+        current_directory = (struct file_descriptive_entry *) data;
+        if(current_directory == NULL)
+          return;
+
+        /* Ajoute  la fin de la liste */
+        if(first_directory == NULL)
+          first_directory = current_directory;
+        else
+          last_directory->next = current_directory;
+        last_directory = current_directory;
+        nb_directory++;
+        break;
+
+      case MEMORY_GET_DIRECTORY_NB :
+        *((int *)data) = nb_directory;
+        break;
+
+      case MEMORY_GET_DIRECTORY :
+        index = *((int *) data);
+        *((struct file_descriptive_entry **) value) = NULL;
+        if(index <= 0 || index > nb_directory)
+          return;
+
+        /* Recherche le index-nth directory */
+        for(i=1, current_directory = first_directory; i<index; i++)
+          current_directory = current_directory->next;
+        *((struct file_descriptive_entry **) value) = current_directory;
+        break;
+
+      case MEMORY_BUILD_DIRECTORY_TAB :
+        /* Libration */
+        if(tab_directory)
+          free(tab_directory);
+
+        /* Allocation */
+        tab_directory = (struct file_descriptive_entry **) calloc(1+nb_directory,sizeof(struct file_descriptive_entry *));
+        if(tab_directory == NULL)
+          break;
+
+        /* Remplissage */
+        for(i=0, current_directory = first_directory; current_directory; i++,current_directory=current_directory->next)
+          tab_directory[i] = current_directory;
+        break;
+
+      case MEMORY_REMOVE_DIRECTORY :
+        delete_directory = (struct file_descriptive_entry *) data;
+        if(delete_directory == NULL)
+          break;
+
+        /* Cas particulier : 1 seule structure */
+        if(nb_directory == 1 && first_directory == delete_directory)
+          {
+            first_directory = NULL;
+            last_directory = NULL;
+            nb_directory = 0;
+          }
+        else if(first_directory == delete_directory)
+          {
+            /* En 1re position */
+            first_directory = first_directory->next;
+            memmove(&tab_directory[0],&tab_directory[1],(nb_directory-1)*sizeof(struct file_descriptive_entry *));
+            nb_directory--;
+          }
+        else if(last_directory == delete_directory)
+          {
+            /* En dernire position */
+            tab_directory[nb_directory-2]->next = NULL;
+            last_directory = tab_directory[nb_directory-2];
+            nb_directory--;
+          }
+        else
+          {
+            /* Au milieu */
+            for(i=0; i<nb_directory; i++)
+              if(tab_directory[i] == delete_directory)
+                {
+                  tab_directory[i-1]->next = tab_directory[i]->next;
+                  memmove(&tab_directory[i],&tab_directory[i+1],(nb_directory-i-1)*sizeof(struct file_descriptive_entry *));
+                  nb_directory--;
+                  break;
+                }
+          }
+        break;
+
+      case MEMORY_FREE_DIRECTORY :
+        for(current_directory = first_directory; current_directory; )
+          {
+            next_directory = current_directory->next;
+            mem_free_entry(current_directory);
+            current_directory = next_directory;
+          }
+        if(tab_directory)
+          free(tab_directory);
+        nb_directory = 0;
+        first_directory = NULL;
+        last_directory = NULL;
+        tab_directory = NULL;
+        break;
+
+      /*******************************************/
+      /*  Liste chaine des structure file_path  */
+      /*******************************************/
+      case MEMORY_ADD_FILE :
+        path = (char *) data;
+
+        /* Allocation mmoire */
+        current_filepath = (struct file_path *) calloc(1,sizeof(struct file_path));
+        if(current_filepath == NULL)
+          return;
+        current_filepath->path = strdup(path);
+        if(current_filepath->path == NULL)
+          {
+            free(current_filepath);
+            return;
+          }
+
+        /* Ajoute  la fin de la liste */
+        if(first_filepath == NULL)
+          first_filepath = current_filepath;
+        else
+          last_filepath->next = current_filepath;
+        last_filepath = current_filepath;
+        nb_filepath++;
+        break;
+
+      case MEMORY_GET_FILE_NB :
+        *((int *)data) = nb_filepath;
+        break;
+
+      case MEMORY_GET_FILE :
+        index = *((int *) data);
+        *((struct file_path **) value) = NULL;
+        if(index <= 0 || index > nb_filepath)
+          return;
+
+        /* Recherche le index-nth entry */
+        for(i=1, current_filepath = first_filepath; i<index; i++)
+          current_filepath = current_filepath->next;
+        *((char **) value) = current_filepath->path;
+        break;
+
+      case MEMORY_FREE_FILE :
+        for(current_filepath = first_filepath; current_filepath; )
+          {
+            next_filepath = current_filepath->next;
+            mem_free_filepath(current_filepath);
+            current_filepath = next_filepath;
+          }
+        nb_filepath = 0;
+        first_filepath = NULL;
+        last_filepath = NULL;
+        break;
+
+      /***************************************/
+      /*  Liste chaine des structure error  */
+      /***************************************/
+      case MEMORY_ADD_ERROR :
+        message = (char *) data;
+
+        /* Allocation mmoire */
+        current_error = (struct error *) calloc(1,sizeof(struct error));
+        if(current_error == NULL)
+          return;
+        current_error->message = strdup(message);
+        if(current_error->message == NULL)
+          {
+            free(current_error);
+            return;
+          }
+
+        /* Ajoute  la fin de la liste */
+        if(first_error == NULL)
+          first_error = current_error;
+        else
+          last_error->next = current_error;
+        last_error = current_error;
+        nb_error++;
+        break;
+
+      case MEMORY_GET_ERROR_NB :
+        *((int *)data) = nb_error;
+        break;
+
+      case MEMORY_GET_ERROR :
+        index = *((int *) data);
+        *((struct error **) value) = NULL;
+        if(index <= 0 || index > nb_error)
+          return;
+
+        /* Recherche le index-nth entry */
+        for(i=1, current_error = first_error; i<index; i++)
+          current_error = current_error->next;
+        *((struct error **) value) = current_error;
+        break;
+
+      case MEMORY_FREE_ERROR :
+        for(current_error = first_error; current_error; )
+          {
+            next_error = current_error->next;
+            if(current_error->message)
+              free(current_error->message);
+            free(current_error);
+            current_error = next_error;
+          }
+        nb_error = 0;
+        first_error = NULL;
+        last_error = NULL;
+        break;
+
+      default :
+        break;
+    }
+}
+
+
+/**********************************************************/
+/*  mem_free_param() :  Libration de la structure Param. */
+/**********************************************************/
+void mem_free_param(struct parameter *param)
+{
+  if(param)
+    {
+      if(param->image_file_path)
+        free(param->image_file_path);
+
+      if(param->prodos_file_path)
+        free(param->prodos_file_path);
+
+      if(param->prodos_folder_path)
+        free(param->prodos_folder_path);
+
+      if(param->output_directory_path)
+        free(param->output_directory_path);
+
+      if(param->file_path)
+        free(param->file_path);
+
+      if(param->folder_path)
+        free(param->folder_path);
+
+      if(param->new_file_name)
+        free(param->new_file_name);
+
+      if(param->new_folder_name)
+        free(param->new_folder_name);
+
+      if(param->new_volume_name)
+        free(param->new_volume_name);
+
+      if(param->new_file_path)
+        free(param->new_file_path);
+
+      if(param->new_folder_path)
+        free(param->new_folder_path);
+
+      free(param);
+    }
+}
+
+/***********************************************************************/

Src/Dc_Memory.h

+/***********************************************************************/
+/*                                                                     */
+/* Dc_Memory.h : Header pour la bibliothque de gestion de la mmoire. */
+/*                                                                     */
+/***********************************************************************/
+/*  Auteur : Olivier ZARDINI  *  Brutal Deluxe Software  *  Dec 2011   */
+/***********************************************************************/
+
+#define MEMORY_INIT                 10
+#define MEMORY_FREE                 11
+
+#define MEMORY_ADD_ENTRY            20
+#define MEMORY_GET_ENTRY_NB         21
+#define MEMORY_GET_ENTRY            22
+#define MEMORY_BUILD_ENTRY_TAB      23
+#define MEMORY_REMOVE_ENTRY         24
+#define MEMORY_FREE_ENTRY           25
+
+#define MEMORY_ADD_DIRECTORY        30
+#define MEMORY_GET_DIRECTORY_NB     31
+#define MEMORY_GET_DIRECTORY        32
+#define MEMORY_BUILD_DIRECTORY_TAB  33
+#define MEMORY_REMOVE_DIRECTORY     34
+#define MEMORY_FREE_DIRECTORY       35
+
+#define MEMORY_ADD_FILE             40
+#define MEMORY_GET_FILE_NB          41
+#define MEMORY_GET_FILE             42
+#define MEMORY_FREE_FILE            43
+
+#define MEMORY_ADD_ERROR            50
+#define MEMORY_GET_ERROR_NB         51
+#define MEMORY_GET_ERROR            52
+#define MEMORY_FREE_ERROR           53
+
+struct parameter
+{
+  int action;
+
+  char *image_file_path;
+  char *prodos_file_path;
+  char *prodos_folder_path;
+  char *output_directory_path;
+
+  char *new_file_name;
+  char *new_folder_name;
+  char *new_volume_name;
+
+  char *new_file_path;
+  char *new_folder_path;
+
+  int new_volume_size_kb;
+
+  char *file_path;
+  char *folder_path;
+
+  int verbose;
+};
+
+struct error
+{
+  char *message;
+
+  struct error *next;
+};
+
+void my_Memory(int,void *,void *);
+void mem_free_param(struct parameter *);
+
+/***********************************************************************/
\ No newline at end of file

Src/Dc_OS.c

+/***********************************************************************/
+/*                                                                     */
+/*   Dc_OS.c : Module pour les fonctions spcifiques  l'OS.           */
+/*                                                                     */
+/***********************************************************************/
+/*  Auteur : Olivier ZARDINI  *  Brutal Deluxe Software  *  Mar 2012   */
+/***********************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <malloc.h>
+#include <string.h>
+#ifdef LINUX
+#include <strings.h>
+#endif
+#if defined(WIN32) || defined(WIN64)
+#include <io.h>
+#include <direct.h>
+#endif
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/timeb.h>
+
+#include <errno.h>
+
+#if defined(WIN32) || defined(WIN64)
+#include <windows.h>
+#endif
+
+#include "Dc_Shared.h"
+#include "Dc_Prodos.h"
+#include "Dc_Memory.h"
+#include "Dc_OS.h"
+
+#if !defined(S_ISDIR) && defined(S_IFDIR)
+#define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
+#endif
+
+static int MakeAllDir(char *);
+
+/******************************************************/
+/*  my_DeleteFile() :  Supprime un fichier du disque. */
+/******************************************************/
+void my_DeleteFile(char *file_path)
+{
+  /* Rend le fichier visible */
+  my_SetFileAttribute(file_path,SET_FILE_VISIBLE);
+
+  /* Supprime le fichier */
+  unlink(file_path);
+}
+
+
+/********************************************************************/
+/*  GetFolderFiles() :  Rcupre tous les fichiers d'un rpertoire. */
+/********************************************************************/
+int GetFolderFiles(char *folder_path, char *hierarchy)
+{
+  int error, rc;
+  long hFile;
+  int first_time = 1;
+  struct _finddata_t c_file;
+  char *buffer_folder_path = NULL;
+  char *buffer_file_path = NULL;
+
+  /* Rien  faire */
+  if(folder_path == NULL)
+    return(0);
+  if(strlen(folder_path) == 0)
+    return(0);
+  error = 0;
+
+  /* Allocation mmoire */
+  buffer_folder_path = (char *) calloc(1,1024);
+  buffer_file_path = (char *) calloc(1,1024);
+  if(buffer_folder_path == NULL || buffer_file_path == NULL)
+    return(1);
+  strcpy(buffer_folder_path,folder_path);
+  if(buffer_folder_path[strlen(buffer_folder_path)-1] != '\\' && buffer_folder_path[strlen(buffer_folder_path)-1] != '/')
+    strcat(buffer_folder_path,FOLDER_CHARACTER);
+  strcat(buffer_folder_path,"*.*");
+
+  /** On boucle sur tous les fichiers prsents **/
+  while(1)
+    {
+      if(first_time == 1)
+        {
+          hFile = _findfirst(buffer_folder_path,&c_file);
+          rc = (int) hFile;
+        }
+      else
+        rc = _findnext(hFile,&c_file);
+
+        /* On analyse le rsultat */
+    	if(rc == -1)
+          break;    /* no more files */
+ 
+      /** On traite cette entre **/
+      first_time++;
+      strcpy(buffer_file_path,folder_path);
+      if(buffer_file_path[strlen(buffer_file_path)-1] != '\\' && buffer_file_path[strlen(buffer_file_path)-1] != '/')
+        strcat(buffer_file_path,FOLDER_CHARACTER);
+      strcat(buffer_file_path,c_file.name);
+
+      /** Traite le dossier de faon rcursive **/
+      if((c_file.attrib & _A_SUBDIR) == _A_SUBDIR)
+        {
+          /* On ne traite ni . ni .. */
+          if(!my_stricmp(c_file.name,".") || !my_stricmp(c_file.name,".."))
+            continue;