From 3e857026bf2ec7c18fe0d5e10fe1218767c394bb Mon Sep 17 00:00:00 2001
From: Philippe PITTOLI <p.pittoli@unistra.fr>
Date: Sun, 5 Jun 2016 03:19:36 +0200
Subject: [PATCH] GROS BORDEL 2, le retour !

---
 lib/communication.c | 362 +++++++++++---------------------------------
 lib/communication.h |  46 ++----
 lib/communication.o | Bin 16952 -> 19624 bytes
 lib/process.c       |  43 ++++++
 lib/process.h       |  35 +++++
 pingpong/pingpong.c |  12 +-
 pubsub/pubsubd.c    |   2 +-
 pubsub/pubsubd.h    |   5 +-
 8 files changed, 191 insertions(+), 314 deletions(-)
 create mode 100644 lib/process.c
 create mode 100644 lib/process.h

diff --git a/lib/communication.c b/lib/communication.c
index 313e697..1976b41 100644
--- a/lib/communication.c
+++ b/lib/communication.c
@@ -2,7 +2,32 @@
 #include <stdio.h>
 #include <time.h>
 
-int service_path (char *buf, const char *sname)
+int file_open (FILE **f, const char *path, const char *mode)
+{
+    printf ("opening %s\n", path);
+    *f = fopen (path, mode);
+    if (*f == NULL) {
+        fprintf (stderr, "\033[31mnot opened\033[00m\n");
+        return -1;
+    }
+    printf ("opened : %ld\n", (long) *f);
+
+    return 0;
+}
+
+int file_close (FILE *f)
+{
+    if (f != 0) {
+        printf ("before fclosing\n");
+        fclose (f);
+        printf ("after fclosing\n");
+    }
+    return 0;
+}
+
+// SERVICE
+
+int srv_path (char *buf, const char *sname)
 {
     if (buf == NULL) {
         return 1;
@@ -20,15 +45,7 @@ int service_path (char *buf, const char *sname)
     return 0;
 }
 
-void process_paths (char *in, char *out, pid_t pid, int index)
-{
-    bzero (in, PATH_MAX);
-    bzero (out, PATH_MAX);
-    snprintf(in , PATH_MAX, "%s/%d-%d-in" , TMPDIR, pid, index);
-    snprintf(out, PATH_MAX, "%s/%d-%d-out", TMPDIR, pid, index);
-}
-
-int service_create (const char *fifopath)
+int srv_create (const char *fifopath)
 {
     int ret;
     if ((ret = mkfifo (fifopath, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH))) {
@@ -63,7 +80,7 @@ int service_create (const char *fifopath)
     return 0;
 }
 
-int service_close (const char *fifopath)
+int srv_close (const char *fifopath)
 {
     if (unlink (fifopath)) {
         return 1;
@@ -72,24 +89,7 @@ int service_close (const char *fifopath)
     return 0;
 }
 
-struct process * srv_process_copy (const struct process *p)
-{
-    if (p == NULL)
-        return NULL;
-
-    struct process * copy = malloc (sizeof(struct process));
-    memcpy (copy, p, sizeof (struct process));
-
-    return copy;
-}
-
-int srv_process_eq (const struct process *p1, const struct process *p2)
-{
-    return (p1->pid == p2->pid && p1>version == p2->version
-            && p1->index == p2->index);
-}
-
-int service_get_new_process (struct process *proc, const char * spath)
+int srv_get_new_process (struct process *p, const char * spath)
 {
     if (spath == NULL) {
         return -1;
@@ -117,349 +117,167 @@ int service_get_new_process (struct process *proc, const char * spath)
     char *str;
     int i;
 
+    pid_t pid;
+    int index;
+    int version;
+
     for (str = buf, i = 1; ; str = NULL, i++) {
         token = strtok_r(str, " ", &saveptr);
         if (token == NULL)
             break;
 
         if (i == 1) {
-            proc->pid = strtoul(token, NULL, 10);
+            pid = strtoul(token, NULL, 10);
         }
         else if (i == 2) {
-            proc->index = strtoul(token, NULL, 10);
+            index = strtoul(token, NULL, 10);
         }
         else if (i == 3) {
-            proc->version = strtoul(token, NULL, 10);
+            version = strtoul(token, NULL, 10);
         }
     }
 
+    srv_process_gen (p, pid, index, version);
+
     return 1;
 }
 
-// FIXME only works for a single process
-void service_get_new_processes (struct process ***proc, int *nproc, char * spath)
+int srv_read (struct process *p, void * buf, size_t * msize)
 {
-    if (proc == NULL || spath == NULL) {
-        return;
-    }
+    if (file_open (&p->out, p->path_out, "rb"))
+        return 1;
 
-    char buf[BUFSIZ];
-    bzero (buf, BUFSIZ);
+    *msize = fread (buf, 1, *msize, p->out); // FIXME check errors
+    // printf ("DEBUG read, size %ld : %s\n", *msize, buf);
 
-    // read the pipe, get a process to work on
-    FILE * f = fopen (spath, "rb");
-    fgets (buf, BUFSIZ, f);
-    fclose (f);
+    if (file_close (p->out))
+        return 1;
 
-    char *token, *line, *saveptr, *saveptr2;
-    char *str, *str2;
-    int i, j;
-
-    *nproc = 0;
-    proc[0] = malloc(sizeof(struct process**));
-
-    for (str2 = buf, j = 1; ; str2 = NULL, j++) {
-        line = strtok_r(str2, "\n", &saveptr2);
-        if (line == NULL)
-            break;
-
-        printf ("line : %s\n", line);
-
-        *nproc = *nproc +1;
-
-        proc[0] = realloc(proc[0], sizeof(struct process*) * (*nproc));
-        proc[0][*nproc -1] = malloc(sizeof(struct process));
-
-        for (str = line, i = 1; ; str = NULL, i++) {
-            token = strtok_r(str, " ", &saveptr);
-            if (token == NULL)
-                break;
-
-            if (i == 1) {
-                proc[0][*nproc -1]->pid = strtoul(token, NULL, 10);
-            }
-            else if (i == 2) {
-                proc[0][*nproc -1]->index = strtoul(token, NULL, 10);
-            }
-            else if (i == 3) {
-                proc[0][*nproc -1]->version = strtoul(token, NULL, 10);
-            }
-
-        }
-    }
+    return 0;
 }
 
-void struct_process_free (struct process * p)
+int srv_write (struct process *p, void * buf, size_t msize)
 {
-    free (p);
+    if (file_open (&p->in, p->path_in, "wb"))
+        return 1;
+
+    fwrite (buf, 1, msize, p->in); // FIXME check errors
+
+    if (file_close (p->in))
+        return 1;
+
+    return 0;
 }
 
-void service_free_processes (struct process **procs, int nproc)
-{
-    printf ("free processes\n");
-    while (nproc--) {
-        printf ("free process %d\n", nproc);
+// APPLICATION
 
-        struct_process_free (procs[nproc]);
-    }
-}
-
-void gen_process_structure (struct process *p
-        , pid_t pid, unsigned int index, unsigned int version)
-{
-    p->pid = pid;
-    p->version = version;
-    p->index = index;
-}
-
-
-void process_print (struct process *p)
-{
-    printf ("process %d : index %d\n", p->pid, p->index);
-}
-
-int process_create (struct process *p, int index)
+int app_create (struct process *p, int index)
 {
     pid_t pid = getpid();
-    char fifopathin[PATH_MAX];
-    char fifopathout[PATH_MAX];
-    process_paths (fifopathin, fifopathout, pid, index);
+
+    // then creates the structure
+    srv_process_gen (p, pid, index, COMMUNICATION_VERSION);
 
     // creates the pipes
     int ret;
-    if ((ret = mkfifo (fifopathin, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)))
+    if ((ret = mkfifo (p->path_in, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)))
     {
         switch (errno) {
             case EACCES :
-                printf ("file %s : EACCES\n", fifopathin);
+                printf ("file %s : EACCES\n", p->path_in);
                 return 1;
             case EEXIST :
-                printf ("file %s : EEXIST\n", fifopathin);
+                printf ("file %s : EEXIST\n", p->path_in);
                 break;
             case ENAMETOOLONG :
-                printf ("file %s : ENAMETOOLONG\n", fifopathin);
+                printf ("file %s : ENAMETOOLONG\n", p->path_in);
                 return 2;
             case ENOENT :
-                printf ("file %s : ENOENT\n", fifopathin);
+                printf ("file %s : ENOENT\n", p->path_in);
                 return 3;
             case ENOSPC :
-                printf ("file %s : ENOSPC\n", fifopathin);
+                printf ("file %s : ENOSPC\n", p->path_in);
                 return 4;
             case ENOTDIR :
-                printf ("file %s : ENOTDIR\n", fifopathin);
+                printf ("file %s : ENOTDIR\n", p->path_in);
                 return 5;
             case EROFS :
-                printf ("file %s : EROFS\n", fifopathin);
+                printf ("file %s : EROFS\n", p->path_in);
                 return 6;
             default :
-                printf ("err file %s unknown\n", fifopathin);
+                printf ("err file %s unknown\n", p->path_in);
                 return 7;
         }
     }
 
-    if ((ret = mkfifo (fifopathout, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH))) {
+    if ((ret = mkfifo (p->path_out, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH))) {
         switch (errno) {
             case EACCES :
-                printf ("file %s : EACCES\n", fifopathout);
+                printf ("file %s : EACCES\n", p->path_out);
                 return 1;
             case EEXIST :
-                printf ("file %s : EEXIST\n", fifopathout);
+                printf ("file %s : EEXIST\n", p->path_out);
                 break;
             case ENAMETOOLONG :
-                printf ("file %s : ENAMETOOLONG\n", fifopathout);
+                printf ("file %s : ENAMETOOLONG\n", p->path_out);
                 return 2;
             case ENOENT :
-                printf ("file %s : ENOENT\n", fifopathout);
+                printf ("file %s : ENOENT\n", p->path_out);
                 return 3;
             case ENOSPC :
-                printf ("file %s : ENOSPC\n", fifopathout);
+                printf ("file %s : ENOSPC\n", p->path_out);
                 return 4;
             case ENOTDIR :
-                printf ("file %s : ENOTDIR\n", fifopathout);
+                printf ("file %s : ENOTDIR\n", p->path_out);
                 return 5;
             case EROFS :
-                printf ("file %s : EROFS\n", fifopathout);
+                printf ("file %s : EROFS\n", p->path_out);
                 return 6;
             default :
-                printf ("err file %s unknown\n", fifopathout);
+                printf ("err file %s unknown\n", p->path_out);
                 return 7;
         }
     }
 
-    // then creates the structure
-    gen_process_structure (p, pid, index, COMMUNICATION_VERSION);
-
     return 0;
 }
 
-int process_destroy (struct process *p)
+int app_destroy (struct process *p)
 {
-    char fifopathin[PATH_MAX];
-    char fifopathout[PATH_MAX];
-    process_paths (fifopathin, fifopathout, p->pid, p->index);
-
-    if (unlink (fifopathin)) {
+    if (unlink (p->path_in)) {
         return 1;
     }
 
-    if (unlink (fifopathout)) {
+    if (unlink (p->path_out)) {
         return 1;
     }
 
     return 0;
 }
 
-int process_open_in (struct process *proc)
+int app_read (struct process *p, void * buf, size_t * msize)
 {
-    char fifopathin[PATH_MAX];
-    char fifopathout[PATH_MAX];
-    process_paths (fifopathin, fifopathout, proc->pid, proc->index);
-
-    printf ("opening in %s\n", fifopathin);
-    proc->in = fopen (fifopathin, "rb");
-    if (proc->in == NULL) {
-        fprintf (stderr, "\033[31mnot opened\033[00m\n");
-        return -1;
-    }
-    printf ("opened : %d\n", proc->in);
-
-    return 0;
-}
-
-int service_proc_open_in (struct process *proc)
-{
-    char fifopathin[PATH_MAX];
-    char fifopathout[PATH_MAX];
-    process_paths (fifopathin, fifopathout, proc->pid, proc->index);
-
-    printf ("opening in %s\n", fifopathin);
-    proc->in = fopen (fifopathin, "wb");
-    if (proc->in == NULL) {
-        fprintf (stderr, "\033[31mnot opened\033[00m\n");
-        return -1;
-    }
-    printf ("opened : %d\n", proc->in);
-
-    return 0;
-}
-
-int service_proc_open_out (struct process *proc)
-{
-    char fifopathin[PATH_MAX];
-    char fifopathout[PATH_MAX];
-    process_paths (fifopathin, fifopathout, proc->pid, proc->index);
-
-    printf ("opening out %s\n", fifopathout);
-    proc->out = fopen (fifopathout, "rb");
-    if (proc->out == NULL) {
-        fprintf (stderr, "\033[31mnot opened\033[00m\n");
-        return -1;
-    }
-    printf ("opened\n");
-
-    return 0;
-}
-
-int process_open_out (struct process *proc)
-{
-    char fifopathin[PATH_MAX];
-    char fifopathout[PATH_MAX];
-    process_paths (fifopathin, fifopathout, proc->pid, proc->index);
-
-    printf ("opening out %s\n", fifopathout);
-    proc->out = fopen (fifopathout, "wb");
-    if (proc->out == NULL) {
-        fprintf (stderr, "\033[31mnot opened\033[00m\n");
-        return -1;
-    }
-    printf ("opened\n");
-
-    return 0;
-}
-
-int process_close_in (struct process *proc)
-{
-    printf ("closing in\n");
-    if (proc->in != 0) {
-        printf ("before fclose in\n");
-        fclose (proc->in);
-        printf ("after fclose in\n");
-        proc->in = 0;
-    }
-    return 0;
-}
-
-int process_close_out (struct process *proc)
-{
-    printf ("closing out\n");
-    if (proc->out != 0) {
-        fclose (proc->out);
-        proc->out = 0;
-    }
-    return 0;
-}
-
-
-int process_read (struct process *proc, void * buf, size_t * msize)
-{
-    int ret;
-    if ((ret = process_open_in (proc))) {
+    if (file_open (&p->in, p->path_in, "rb"))
         return 1;
-    }
 
-    *msize = fread (buf, 1, *msize, proc->in); // FIXME check errors
+    *msize = fread (buf, 1, *msize, p->in); // FIXME check errors
     // printf ("DEBUG read, size %ld : %s\n", *msize, buf);
 
-    if ((ret = process_close_in (proc))) {
+    if (file_close (p->in))
         return 1;
-    }
 
     return 0;
 }
 
-int process_write (struct process *proc, void * buf, size_t msize)
+int app_write (struct process *p, void * buf, size_t msize)
 {
-    int ret;
-    if ((ret = process_open_out (proc))) {
+    if (file_open (&p->out, p->path_out, "wb"))
         return 1;
-    }
 
-    fwrite (buf, 1, msize, proc->out); // FIXME check errors
+    fwrite (buf, 1, msize, p->out); // FIXME check errors
 
-    if ((ret = process_close_out (proc))) {
+    if (file_close (p->out))
         return 1;
-    }
-    return 0;
-}
-
-int service_read (struct process *proc, void * buf, size_t * msize)
-{
-    int ret;
-    if ((ret = service_proc_open_out (proc))) {
-        return 1;
-    }
-
-    *msize = fread (buf, 1, *msize, proc->out); // FIXME check errors
-    // printf ("DEBUG read, size %ld : %s\n", *msize, buf);
-
-    if ((ret = process_close_out (proc))) {
-        return 1;
-    }
 
     return 0;
 }
-
-int service_write (struct process *proc, void * buf, size_t msize)
-{
-    int ret;
-    if ((ret = service_proc_open_in (proc))) {
-        return 1;
-    }
-
-    fwrite (buf, 1, msize, proc->in); // FIXME check errors
-
-    if ((ret = process_close_in (proc))) {
-        return 1;
-    }
-    return 0;
-}
diff --git a/lib/communication.h b/lib/communication.h
index e9a27b0..ebe062e 100644
--- a/lib/communication.h
+++ b/lib/communication.h
@@ -5,6 +5,7 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include "process.h"
 #include <unistd.h> // unlink
 
 #include <sys/types.h> // mkfifo
@@ -13,35 +14,16 @@
 
 #include <errno.h> // error numbers
 
-#define TMPDIR "/tmp/ipc/"
-
 #define COMMUNICATION_VERSION 1
 
-// TODO to check the right length for a path
-#define PATH_MAX BUFSIZ
-
-struct process {
-    pid_t pid;
-    unsigned int version;
-    unsigned int index;
-    FILE *in, *out;
-};
-
 struct service {
     unsigned int version;
     unsigned int index;
 };
 
-// TODO create the service process structure
+int srv_path (char *buf, const char *sname);
 
-int service_path (char *buf, const char *sname);
-
-struct process * srv_process_copy (struct process *p);
-
-int srv_process_eq (const struct process *p1, const struct process *p2);
-
-void gen_process_structure (struct process *p
-        , pid_t pid, unsigned int index, unsigned int version);
+int srv_get_new_process (struct process *proc, const char * spath);
 
 /*
  * returns
@@ -50,22 +32,18 @@ void gen_process_structure (struct process *p
  *  2 : service name too long
  *  3 : unable to create fifo
  */
-int service_create (const char *sname);
-int service_close (const char *sname);
+int srv_create (const char *sname);
+int srv_close (const char *sname);
 
-int service_get_new_process (struct process *proc, const char * spath);
-void service_get_new_processes (struct process ***, int *nproc, char *spath);
-void service_free_processes (struct process **, int nproc);
+int srv_read (struct process *, void * buf, size_t *);
+int srv_write (struct process *, void * buf, size_t);
 
+// APPLICATION
 
-void process_print (struct process *);
-int process_create (struct process *, int index); // called by the application
-int process_destroy (struct process *); // called by the application
+int app_create (struct process *, int index); // called by the application
+int app_destroy (struct process *); // called by the application
 
-int process_read (struct process *, void * buf, size_t *);
-int process_write (struct process *, void * buf, size_t);
-
-int service_read (struct process *, void * buf, size_t *);
-int service_write (struct process *, void * buf, size_t);
+int app_read (struct process *, void * buf, size_t *);
+int app_write (struct process *, void * buf, size_t);
 
 #endif
diff --git a/lib/communication.o b/lib/communication.o
index a0cea9da474b6b4da1b905dd5750f3a466c7a97e..967d37ee0dce8288a6edad1d4b8612f8987fea18 100644
GIT binary patch
literal 19624
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
Y4CCR?Y#-0R+1f9krRrB04H~BSe@p_*q5uE@

literal 16952
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

diff --git a/lib/process.c b/lib/process.c
new file mode 100644
index 0000000..7f3cba7
--- /dev/null
+++ b/lib/process.c
@@ -0,0 +1,43 @@
+#include "process.h"
+
+struct process * srv_process_copy (const struct process *p)
+{
+    if (p == NULL)
+        return NULL;
+
+    struct process * copy = malloc (sizeof(struct process));
+    memcpy (copy, p, sizeof (struct process));
+
+    return copy;
+}
+
+int srv_process_eq (const struct process *p1, const struct process *p2)
+{
+    return (p1->pid == p2->pid && p1->version == p2->version
+            && p1->index == p2->index);
+}
+
+void srv_process_gen (struct process *p
+        , pid_t pid, unsigned int index, unsigned int version)
+{
+    p->pid = pid;
+    p->version = version;
+    p->index = index;
+
+    bzero (p->path_in, PATH_MAX);
+    bzero (p->path_out, PATH_MAX);
+    snprintf(p->path_in , PATH_MAX, "%s/%d-%d-in" , TMPDIR, pid, index);
+    snprintf(p->path_out, PATH_MAX, "%s/%d-%d-out", TMPDIR, pid, index);
+}
+
+void srv_process_free (struct process * p)
+{
+    if (! p)
+        return;
+    free (p);
+}
+
+void process_print (struct process *p)
+{
+    printf ("process %d : index %d\n", p->pid, p->index);
+}
diff --git a/lib/process.h b/lib/process.h
new file mode 100644
index 0000000..13461fd
--- /dev/null
+++ b/lib/process.h
@@ -0,0 +1,35 @@
+#ifndef __PROCESS_H__
+#define __PROCESS_H__
+
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define TMPDIR "/tmp/ipc/"
+
+// TODO to check the right length for a path
+#define PATH_MAX BUFSIZ
+
+#include <string.h>
+
+struct process {
+    pid_t pid;
+    unsigned int version;
+    unsigned int index;
+    char path_in [PATH_MAX];
+    char path_out [PATH_MAX];
+    FILE *in, *out;
+};
+
+struct process * srv_process_copy (const struct process *p);
+
+int srv_process_eq (const struct process *p1, const struct process *p2);
+
+// create the service process structure
+void srv_process_gen (struct process *p
+        , pid_t pid, unsigned int index, unsigned int version);
+
+void process_print (struct process *);
+
+#endif
diff --git a/pingpong/pingpong.c b/pingpong/pingpong.c
index 6b78ddc..4b932ba 100644
--- a/pingpong/pingpong.c
+++ b/pingpong/pingpong.c
@@ -17,7 +17,7 @@ void main_loop (const char *spath)
 
     while (cnt--) {
         // -1 : error, 0 = no new process, 1 = new process
-        ret = service_get_new_process (&proc, spath);
+        ret = srv_get_new_process (&proc, spath);
         if (ret == -1) {
             fprintf (stderr, "error service_get_new_process\n");
             continue;
@@ -35,7 +35,7 @@ void main_loop (const char *spath)
         bzero(buf, BUFSIZ);
 
         // printf ("before read\n");
-        if ((ret = service_read (&proc, &buf, &msize))) {
+        if ((ret = srv_read (&proc, &buf, &msize))) {
             fprintf(stdout, "error service_read %d\n", ret);
             continue;
         }
@@ -43,7 +43,7 @@ void main_loop (const char *spath)
         printf ("read, size %ld : %s\n", msize, buf);
 
         // printf ("before proc write\n");
-        if ((ret = service_write (&proc, &buf, msize))) {
+        if ((ret = srv_write (&proc, &buf, msize))) {
             fprintf(stdout, "error service_write %d\n", ret);
             continue;
         }
@@ -66,11 +66,11 @@ int main(int argc, char * argv[])
 {
     // gets the service path, such as /tmp/<service>
     char spath[PATH_MAX];
-    service_path (spath, "pingpong");
+    srv_path (spath, "pingpong");
 
     // creates the service named pipe, that listens to client applications
     int ret;
-    if ((ret = service_create (spath))) {
+    if ((ret = srv_create (spath))) {
         fprintf(stdout, "error service_create %d\n", ret);
         exit (1);
     }
@@ -79,7 +79,7 @@ int main(int argc, char * argv[])
     main_loop (spath);
 
     // the application will shut down, and remove the service named pipe
-    if ((ret = service_close (spath))) {
+    if ((ret = srv_close (spath))) {
         fprintf(stdout, "error service_close %d\n", ret);
         exit (1);
     }
diff --git a/pubsub/pubsubd.c b/pubsub/pubsubd.c
index c1263b0..0295c87 100644
--- a/pubsub/pubsubd.c
+++ b/pubsub/pubsubd.c
@@ -1,4 +1,4 @@
-#include "../lib/communication.h"
+#include "pubsubd.h"
 #include <stdlib.h>
 
 const char* service_name = "pubsub";
diff --git a/pubsub/pubsubd.h b/pubsub/pubsubd.h
index 4c70462..9e507d0 100644
--- a/pubsub/pubsubd.h
+++ b/pubsub/pubsubd.h
@@ -1,7 +1,10 @@
 #ifndef __PUBSUBD_H__
 #define __PUBSUBD_H__
 
-#include "queue.h"
+#include "../lib/communication.h"
+#include "../lib/process.h"
+
+#include "../lib/queue.h"
 
 struct message {
     unsigned char *chan;