separate receive routine

main.c

@@ -38,21 +38,23 @@ int main(int argc, char ** argv){
         
         p[1] = pipes_b[1]; // pipe d'entree du fils suivant
         user_t user = user_init(i, NB_CHEVALS, p);
-        user_data_t user_data;
-        while(1) user_loop(user, user_data);
+        while(1) user_loop(user);
       break;
     }
   }
   pipes[0] = pipes_b[0];
 
-  id_request id_req;
-  request req = { .t = R_ID};
-  memcpy(req.content, &id_req, sizeof(id_req));
-  send_message(pipes[1], 0, &req, sizeof(req), M_REQUEST);
+  request req = { .t = REQ_ID};
+  id_request id_req = { .parent = req };
+  send_message(pipes[1], 0, &id_req, sizeof(id_req), M_REQUEST);
+
+  send_message(pipes[1], 3, &id_req, sizeof(id_req), M_REQUEST);
   
-  memcpy(req.content, &id_req, sizeof(id_req));
-  send_message(pipes[1], 1, &req, sizeof(req), M_REQUEST);
+  send_message(pipes[1], 1, &id_req, sizeof(id_req), M_REQUEST);
   
-  memcpy(req.content, &id_req, sizeof(id_req));
-  send_message(pipes[1], 3, &req, sizeof(req), M_REQUEST);
+  send_message(pipes[1], 2, &id_req, sizeof(id_req), M_REQUEST);
+
+  while(1){
+    
+  }
 }

user.c

@@ -8,7 +8,18 @@
 
 user_t user_init(unsigned int id, unsigned int nb_cheval, int pipes[]){
   cheval_t chevals[nb_cheval];
-  
+
+
+  receive_data_t r_data = {
+    .pipes = pipes,
+    .id = id,
+    .r_buf = malloc(R_CHUNK_SIZE),
+    .cont_id = -1,
+    .cont_type = -1,
+    .content_off = 0,
+    .onRequest = user_onRequest,
+  };
+
   user_t out = {
     .id = id,
     .c = chevals,
@@ -16,52 +27,60 @@ user_t user_init(unsigned int id, unsigned int nb_cheval, int pipes[]){
     .pipes = pipes,
   };
 
+  out.r_data = malloc(sizeof(r_data));
+  memcpy(out.r_data, &r_data, sizeof(r_data));
+
   return out;
 }
 
-void user_loop(user_t user, user_data_t data){
+void user_loop(user_t user){
+  receive_loop(user.r_data);
+}
+
+void receive_loop(receive_data_t* data){
   message in;
-  read(user.pipes[0], &in, sizeof(message));
+  read(data->pipes[0], &in, sizeof(message));
   
-  if(in.dest_id != user.id){ // si le message ne nous est pas destine on le passe au suivant de facon transparente
-    write(user.pipes[1], &in, sizeof(message));
+  if(in.dest_id != data->id){ // si le message ne nous est pas destine on le passe au suivant de facon transparente
+    write(data->pipes[1], &in, sizeof(message));
     return;
   }
   
   switch(in.t){
     case M_REQUEST:
-      memcpy(&data.req, &in.content + data.content_off, in.content_size);
-      data.content_off = in.content_size;
-      
-      if(in.cont_id != -1) break; // si c'est le dernier message
+      data->content_off = 0;
+      data->r_buf = realloc(data->r_buf, R_CHUNK_SIZE);
 
-      user_onRequest(user, data.req);
+      memcpy(data->r_buf, &in.content + data->content_off, in.content_size);
+      data->content_off = in.content_size;     
     break;
+
     case M_CONT:
-      if(in.id != data.cont_id) fprintf(stderr, "Continuation message of an unknown source, dropping it");
-      if(in.t != data.cont_type) fprintf(stderr, "Continuation message of the wrong type, dropping it");
-
-      void* target;
-      switch(data.cont_type){
-        case M_REQUEST:
-          target = &data.req;
-        break;
-        default:
-          fprintf(stderr, "message type not implemented, dropping it");
-        break;
+      if(in.id != data->cont_id){
+        fprintf(stderr, "Continuation message of an unknown source, dropping it");
+        return;
+      }
+      if(in.t != data->cont_type){
+        fprintf(stderr, "Continuation message of the wrong type, dropping it");
+        return;
       }
 
-      memcpy(target, &in.content + data.content_off, in.content_size);
-      data.content_off += in.content_size;
-
-      if(in.cont_id != -1) break;
-
-      user_onRequest(user, data.req);
+      data->r_buf = realloc(data->r_buf, data->content_off + in.content_size);
+      memcpy(data->r_buf, &in.content + data->content_off, in.content_size);
+      data->content_off += in.content_size;
     break;
+
     case M_RESPONSE:
 
     break;
   }
+  if(in.cont_id != -1){ // si ce n'est pas le dernier message
+    data->cont_id = in.cont_id;
+    data->cont_type = in.t;
+    return;
+  }
+
+  data->onRequest(data);
 }
 
 void send_message(int pipe, int dest_id, void* content, int content_size, M_TYPE type){
@@ -85,10 +104,20 @@ void send_message(int pipe, int dest_id, void* content, int content_size, M_TYPE
   }
 }
 
-void user_onRequest(user_t user, request r){
-  switch(r.t){
-    case R_ID:
-      printf("%d received id request\n", user.id);
+void user_onRequest(receive_data_t* data){
+  request req;
+  memcpy(&req, data->r_buf, sizeof(req));
+
+  switch(req.t){
+    case REQ_ID:
+      ;
+      response resp = { .t = RESP_ID};
+      id_response id_resp = {
+        .parent = resp,
+        .id = data->id,
+      };
+      send_message(data->pipes[1], -1, &id_resp, sizeof(id_resp), M_RESPONSE);
+      printf("%d received id request\n", data->id);
     break;
   }
 }
\ No newline at end of file

user.h

@@ -4,11 +4,14 @@ typedef struct {
   int escalier; // si le cheval est dans l'escalier
 } cheval_t;
 
+typedef struct receive_data receive_data_t;
+
 typedef struct {
   unsigned int id;
   cheval_t* c;
   unsigned char nb_chevals;
   int* pipes;
+  receive_data_t* r_data;
 } user_t;
 
 #define M_SIZE 64
@@ -24,27 +27,46 @@ typedef struct {
   int cont_id; // id du message continuant celui-ci -1 si c'est le dernier
 } message;
 
-#define R_SIZE 64
+#define REQ_SIZE 64
 
-typedef enum R_TYPE {R_ID} R_TYPE;
+typedef enum REQ_TYPE {REQ_ID} REQ_TYPE;
 
 typedef struct {
-  R_TYPE t;
-  char content[R_SIZE];
+  REQ_TYPE t;
 } request;
 
 typedef struct {
-  
+  request parent;
 } id_request;
 
+typedef enum RESP_TYPE {RESP_ID} RESP_TYPE;
+
+typedef struct {
+  RESP_TYPE t;
+} response;
+
 typedef struct {
-  request req; // request actuelle
+  response parent;
+  int id;
+} id_response;
+
+#define R_CHUNK_SIZE 64
+
+
+typedef void (*m_onRequest)(receive_data_t* buf);
+
+struct receive_data {
+  int* pipes;
+  int id;
+  char * r_buf;
   int cont_id; // id du prochain message attendu
   M_TYPE cont_type; // type de message en cours de reception
   int content_off; //offset de reception actuel
-} user_data_t;
+  m_onRequest onRequest;
+};
 
 user_t user_init(unsigned int id, unsigned int nb_cheval, int pipes[]);
-void user_loop(user_t user, user_data_t);
+void user_loop(user_t user);
+void receive_loop(receive_data_t* data);
 void send_message(int pipe, int dest_id, void* content, int content_size, M_TYPE type);
-void user_onRequest(user_t user, request r);
\ No newline at end of file
+void user_onRequest(receive_data_t* data);
\ No newline at end of file