Extended the internal interface providing file inputs/outputs.

4 files changed, 178 insertions, 11 deletions

diff --git a/src/common/io.c b/src/common/io.c
index 7bc4cc1..68659fb 100644
--- a/src/common/io.c
+++ b/src/common/io.c
@@ -37,6 +37,106 @@
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : fd    = flux ouvert en lecture.                              *
+*                buf   = données à recevoir.                                  *
+*                count = quantité de ces données.                             *
+*                                                                             *
+*  Description : Lit des données depuis un flux local.                        *
+*                                                                             *
+*  Retour      : true si toutes les données ont été lues, false sinon.        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool safe_read(int fd, const void *buf, size_t count)
+{
+    uint8_t *iter;                          /* Données en attente          */
+    size_t remaining;                       /* Quantité restante           */
+    ssize_t got;                            /* Données envoyées            */
+
+    iter = (uint8_t *)buf;
+    remaining = count;
+
+    while (remaining > 0)
+    {
+        got = read(fd, iter, remaining);
+
+        if (got == -1)
+        {
+            if (errno == EINTR) continue;
+            else
+            {
+                perror("read");
+                break;
+            }
+        }
+
+        if (got == 0)
+            break;
+
+        iter += got;
+        remaining -= got;
+
+    }
+
+    return (remaining == 0);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : fd    = flux ouvert en écriture.                             *
+*                buf   = données à émettre.                                   *
+*                count = quantité de ces données.                             *
+*                                                                             *
+*  Description : Ecrit des données dans un flux local.                        *
+*                                                                             *
+*  Retour      : true si toutes les données ont été écrites, false sinon.     *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool safe_write(int fd, const void *buf, size_t count)
+{
+    uint8_t *iter;                          /* Données en attente          */
+    size_t remaining;                       /* Quantité restante           */
+    ssize_t sent;                           /* Données envoyées            */
+
+    iter = (uint8_t *)buf;
+    remaining = count;
+
+    while (remaining > 0)
+    {
+        sent = write(fd, iter, remaining);
+
+        if (sent == -1)
+        {
+            if (errno == EINTR) continue;
+            else
+            {
+                perror("write");
+                break;
+            }
+        }
+
+        if (sent == 0)
+            break;
+
+        iter += sent;
+        remaining -= sent;
+
+    }
+
+    return (remaining == 0);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : sockfd = flux ouvert en lecture.                             *
 *                buf    = données à recevoir.                                 *
 *                len    = quantité de ces données.                            *
diff --git a/src/common/io.h b/src/common/io.h
index 8213a87..e0316f7 100644
--- a/src/common/io.h
+++ b/src/common/io.h
@@ -31,21 +31,18 @@
 
 
 
+/* Lit des données depuis un flux local. */
+bool safe_read(int, const void *, size_t);
+
+/* Ecrit des données dans un flux local. */
+bool safe_write(int, const void *, size_t);
+
 /* Réceptionne des données depuis un flux réseau. */
 bool safe_recv(int, const void *, size_t, int);
 
 /* Envoie des données au travers un flux réseau. */
 bool safe_send(int, const void *, size_t, int);
 
-
-
-
-#define safe_read read
-
-#define safe_write write
-
-
-
 /* S'assure qu'un chemin donné existe dans le système. */
 int ensure_path_exists(const char *);
 
diff --git a/src/common/packed.c b/src/common/packed.c
index 39df330..03796b1 100644
--- a/src/common/packed.c
+++ b/src/common/packed.c
@@ -239,6 +239,73 @@ bool extract_packed_buffer(packed_buffer *pbuf, void *buf, size_t len, bool ntoh
 *  Paramètres  : pbuf = paquet de données à constituer. [OUT]                 *
 *                fd   = flux ouvert en lecture.                               *
 *                                                                             *
+*  Description : Lit des données depuis un flux local.                        *
+*                                                                             *
+*  Retour      : true si toutes les données ont été reçues, false sinon.      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool read_packed_buffer(packed_buffer *pbuf, int fd)
+{
+    bool result;                            /* Bilan à retourner           */
+    uint32_t used;                          /* Taille de charge utile      */
+
+    result = safe_read(fd, &used, sizeof(uint32_t));
+
+    if (!result)
+        init_packed_buffer(pbuf);
+
+    else
+    {
+        pbuf->allocated = sizeof(uint32_t) + used;
+        pbuf->data = malloc(pbuf->allocated * sizeof(uint8_t));
+
+        pbuf->used = used;
+        pbuf->pos = sizeof(uint32_t);
+
+        result = safe_read(fd, pbuf->data + pbuf->pos, used);
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : pbuf = paquet de données à émettre.                          *
+*                fd   = flux ouvert en écriture.                              *
+*                                                                             *
+*  Description : Ecrit des données dans un flux local.                        *
+*                                                                             *
+*  Retour      : true si toutes les données ont été émises, false sinon.      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool write_packed_buffer(packed_buffer *pbuf, int fd)
+{
+    bool result;                            /* Bilan à retourner           */
+
+    *((uint32_t *)pbuf->data) = pbuf->used;
+
+    result = safe_write(fd, pbuf->data, sizeof(uint32_t) + pbuf->used);
+
+    return result;
+
+}
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : pbuf = paquet de données à constituer. [OUT]                 *
+*                fd   = flux ouvert en lecture.                               *
+*                                                                             *
 *  Description : Réceptionne des données depuis un flux réseau.               *
 *                                                                             *
 *  Retour      : true si toutes les données ont été reçues, false sinon.      *
diff --git a/src/common/packed.h b/src/common/packed.h
index bc038d8..bb12a1f 100644
--- a/src/common/packed.h
+++ b/src/common/packed.h
@@ -58,8 +58,11 @@ bool extend_packed_buffer(packed_buffer *, const void *, size_t, bool);
 /* Récupère des données depuis un paquet après une réception. */
 bool extract_packed_buffer(packed_buffer *, void *, size_t, bool);
 
-/* Réceptionne des données depuis un flux réseau. */
-bool recv_packed_buffer(packed_buffer *, int);
+/* Lit des données depuis un flux local. */
+bool read_packed_buffer(packed_buffer *, int);
+
+/* Ecrit des données dans un flux local. */
+bool write_packed_buffer(packed_buffer *, int);
 
 /* Réceptionne des données depuis un flux réseau. */
 bool recv_packed_buffer(packed_buffer *, int);