Apply indent with -linux style

src/allocate.c

@@ -9,11 +9,8 @@
 
 /* TODO: prevoir le cas des négatifs dans la taille ... */
 
-void * msgAllocate(msgSpace *space,
+void *msgAllocate(msgSpace * space, int pool, int taille, int option)
-	int pool,
+{
-	int taille,
-	int option
-	){
 	void *resultAddr = NULL;
 	int bufferFreeSize;
 	int i;
@@ -32,10 +29,8 @@ void * msgAllocate(msgSpace *space,
 	int bufferFreeIndex;
 	msgPoolData *mSPoolDataTabAddr;
 
-
 	selectedPoolIndex = -1;
 
-
 	mSPoolDataTabAddr = msgPoolDataTabOpen(space);
 	if (mSPoolDataTabAddr == NULL) {
 		NZG_ERROR("msgPoolDataTabOpen", space->poolDataTabId);
@@ -76,29 +71,40 @@ if (mSPoolDataTabAddr==NULL){
 		fprintf(stderr, "[ ALLOCATION ANYPOOL : %d ]\n", (int)getpid());
 		// choisir le pool au hasard (ou presque)
 		for (i = 0; i < (space->poolNb); i++) {
-	  printf("- boucle %d\n",i); fflush(stdout);
+			printf("- boucle %d\n", i);
+			fflush(stdout);
 			if (mSPoolDataTabAddr[i].bufferSize >= taille) {
-		printf("( buffSize > taille )\n"); fflush(stdout);
+				printf("( buffSize > taille )\n");
+				fflush(stdout);
 				/* choisir le numero du semaphore
 				   en fonction du nombre de lock poses / nombre de buffer */
-		msgPoolSemIdIntern(ressourceSemId,space->id,i);
+				msgPoolSemIdIntern(ressourceSemId, space->id,
-		ressourceSemFd = sem_open(ressourceSemId,O_CREAT,SEM_DEFAULT_MODE,0);
+						   i);
+				ressourceSemFd =
+				    sem_open(ressourceSemId, O_CREAT,
+					     SEM_DEFAULT_MODE, 0);
 				if (ressourceSemFd == SEM_FAILED) {
 					NZG_ERROR("sem_open", ressourceSemId);
 					return NULL;
 				}
 				/* on remplit le tableau avec les valeurs des semaphores */
 
-		if (sem_getvalue(ressourceSemFd, &ressourceSemVal) < 0){ 
+				if (sem_getvalue
-		  NZG_ERROR("sem_getvalue",ressourceSemId);
+				    (ressourceSemFd, &ressourceSemVal) < 0) {
+					NZG_ERROR("sem_getvalue",
+						  ressourceSemId);
 					return NULL;
 				}
 				printf("RESSOURCESEMVAL %d\n", ressourceSemVal);
 				if (ressourceSemVal <= 0) {
-		  printf("resVal < 0 : %d\n",ressourceSemVal);
+					printf("resVal < 0 : %d\n",
+					       ressourceSemVal);
 					/* il y a ressourceSemVal processus qui attendent déja... */
 					semPoolCoef[nbLockedSem] =
-			(float) ((1-ressourceSemVal) / mSPoolDataTabAddr[i].bufferNb);
+					    (float)((1 -
+						     ressourceSemVal) /
+						    mSPoolDataTabAddr[i].
+						    bufferNb);
 					nbLockedSem++;
 				}
 				if (sem_trywait(ressourceSemFd) == 0) {
@@ -110,13 +116,15 @@ if (mSPoolDataTabAddr==NULL){
 					break;
 				}
 				if (sem_close(ressourceSemFd) < 0) {
-		  NZG_ERROR("sem_getvalue",ressourceSemId);
+					NZG_ERROR("sem_getvalue",
+						  ressourceSemId);
 					return NULL;
 				}
 			}	// if buffSize > taille
 		}		// for
 
-	printf("ERRORDETECT outFor\n"); fflush(stdout);
+		printf("ERRORDETECT outFor\n");
+		fflush(stdout);
 
 		if (!gotRessourceSem) {
 			printf("Calcul du meilleur en cas de liberation\n");
@@ -125,7 +133,8 @@ if (mSPoolDataTabAddr==NULL){
 			/* on cherche le pool avec le moins de lock poses / nbre de buffer
 			 * le numéro du pool est stocké dans idxPoolOptimum */
 			for (i = 0; i < nbLockedSem; i++) {
-		printf("Coef %d : %d\n",i,(int)semPoolCoef[i]);
+				printf("Coef %d : %d\n", i,
+				       (int)semPoolCoef[i]);
 				if ((semPoolCoef[i] != -1)
 				    && (semPoolCoef[i] < minPoolCoef)) {
 					minPoolCoef = semPoolCoef[i];
@@ -147,13 +156,14 @@ if (mSPoolDataTabAddr==NULL){
 	}
 
 	if (!gotRessourceSem) {
-	msgPoolSemIdIntern(ressourceSemId,space->externId,selectedPoolIndex);
+		msgPoolSemIdIntern(ressourceSemId, space->externId,
-	ressourceSemFd=sem_open(ressourceSemId,O_CREAT,SEM_DEFAULT_MODE,0);
+				   selectedPoolIndex);
+		ressourceSemFd =
+		    sem_open(ressourceSemId, O_CREAT, SEM_DEFAULT_MODE, 0);
 		if (ressourceSemFd == SEM_FAILED) {
 			NZG_ERROR("sem_open", ressourceSemId);
 			return NULL;
 		}
-
 		//TODO:virer la ligne suivante:
 		sem_getvalue(ressourceSemFd, &ressourceSemVal);
 
@@ -166,7 +176,6 @@ if (mSPoolDataTabAddr==NULL){
 		printf("Passed %s\n", ressourceSemId);
 	}
 
-  
 	/* on a acqui un semaphore pour la ressouce */
 	/* on acquiert le droit de modifier les infos sur la ressource */
 	/* on protege le tableau des associations */
@@ -174,7 +183,8 @@ if (mSPoolDataTabAddr==NULL){
 
 	/* on modifie maintenant les données */
 	/* - on récupere l'index du premier buffer libre */
-  bufferFreeIndex = msgBufferGetFreeIndex(mSPoolDataTabAddr,selectedPoolIndex);
+	bufferFreeIndex =
+	    msgBufferGetFreeIndex(mSPoolDataTabAddr, selectedPoolIndex);
 	if (bufferFreeIndex < 0) {
 		// aucun buffer libre ?
 		NZG_ERROR("msgBufferGetFreeIndex", "");
@@ -187,17 +197,17 @@ if (mSPoolDataTabAddr==NULL){
 	bufferFreeSize = mSPoolDataTabAddr[selectedPoolIndex].bufferSize;
 	printf("BufferSize : %d\n", bufferFreeSize);
 
- resultAddr=msgBufferMap(mSPoolDataTabAddr,selectedPoolIndex,bufferFreeIndex);
+	resultAddr =
+	    msgBufferMap(mSPoolDataTabAddr, selectedPoolIndex, bufferFreeIndex);
 	if (resultAddr == NULL) {
-   NZG_ERROR("msgBufferMap",mSPoolDataTabAddr[selectedPoolIndex].poolId);
+		NZG_ERROR("msgBufferMap",
+			  mSPoolDataTabAddr[selectedPoolIndex].poolId);
 		goto ERROR;
 	}
 
 	/* - on s'enregistre aupres de ce buffer */
 	msgBufferAttachProc(mSPoolDataTabAddr,
-	 selectedPoolIndex,
+			    selectedPoolIndex, bufferFreeIndex, resultAddr);
-	 bufferFreeIndex,
-	 resultAddr);  
 
 	// munmap(mSPoolDataTabAddr,(space->poolNb) * sizeof( msgPoolData ));
 	/* unmapper le msgPoolDataTab */

src/buffer.c

@@ -1,15 +1,11 @@
 #include "libnazgul.h"
 
-int msgBufferGetAttachedProcIndex(
+int msgBufferGetAttachedProcIndex(msgPoolData * poolDataTabAddr,
-	msgPoolData * poolDataTabAddr,
+				  int poolIndex, void *addr)
-	int poolIndex,
+{
-	void * addr
-	){
 
 	//TODO: parcourrir tous les index, et regarder s'il y
 	//a une addresse qui correspond avec le meme processus...
 	//et renvoyer l'index du buffer correspondant a l'addresse...
 	return 0;
 }
-
-

src/bufferAttachProc.c

@@ -1,10 +1,7 @@
 #include "libnazgul.h"
 
-int msgBufferAttachProc(
+int msgBufferAttachProc(msgPoolData * poolDataTabAddr,
-	msgPoolData * poolDataTabAddr,
+			int poolIndex, int bufferIndex, void *addr)
-	int poolIndex,
-	int bufferIndex,
-	void * addr)
 {
 	msgBufferInfoTabId bufferInfoTabId;
 	int bufferInfoTabFd;
@@ -14,7 +11,6 @@ int msgBufferAttachProc(
 	//récuperer l'ID du BufferInfoTab;
 	strcpy(bufferInfoTabId, poolDataTabAddr[poolIndex].bufferInfoTabId);
 
-
 	bufferInfoTabFd = shm_open(bufferInfoTabId, O_RDWR, SHM_DEFAULT_MODE);
 	if (bufferInfoTabFd < 0) {
 		NZG_ERROR("sem_open", bufferInfoTabId);
@@ -24,18 +20,17 @@ int msgBufferAttachProc(
   /** on regarde dans le tableau d'infos de buffer **/
 	bufferInfoNb = poolDataTabAddr[poolIndex].bufferNb;
 	bufferInfoTabAddr = mmap(NULL, bufferInfoNb * sizeof(msgBufferInfo),
-	  PROT_READ|PROT_WRITE,MAP_SHARED,bufferInfoTabFd,(off_t)0);
+				 PROT_READ | PROT_WRITE, MAP_SHARED,
+				 bufferInfoTabFd, (off_t) 0);
 	printf("atta gooo %s\n", bufferInfoTabId);
 
 	bufferInfoTabAddr[bufferIndex].ownerPid = getpid();
 	bufferInfoTabAddr[bufferIndex].addr = addr;
 
-  if (munmap(bufferInfoTabAddr,bufferInfoNb*sizeof(msgBufferInfo))< 0)
+	if (munmap(bufferInfoTabAddr, bufferInfoNb * sizeof(msgBufferInfo)) < 0) {
-  {	
 		NZG_ERROR("munmap", bufferInfoTabId);
-	return -1; }
+		return -1;
+	}
 
 	return 0;
 }
-
-

src/bufferDetachProc.c

@@ -1,11 +1,8 @@
 #include "libnazgul.h"
 
-int msgBufferDetachProc(
+int msgBufferDetachProc(msgPoolData * poolDataTabAddr,
-	msgPoolData * poolDataTabAddr,
+			int poolIndex, int bufferIndex, void *addr)
-	int poolIndex,
+{
-	int bufferIndex,
-	void * addr
-	){
 	msgBufferInfoTabId bufferInfoTabId;
 	int bufferInfoTabFd;
 	msgBufferInfo *bufferInfoTabAddr;
@@ -14,7 +11,6 @@ int msgBufferDetachProc(
 	printf("Detaching %d,%d\n", poolIndex, bufferIndex);
 	//récuperer l'ID du BufferInfoTab;
 
-
 	strcpy(bufferInfoTabId, poolDataTabAddr[poolIndex].bufferInfoTabId);
 
 	bufferInfoTabFd = shm_open(bufferInfoTabId, O_RDWR, SHM_DEFAULT_MODE);
@@ -26,17 +22,16 @@ int msgBufferDetachProc(
   /** on regarde dans le tableau d'infos de buffer **/
 	bufferInfoNb = poolDataTabAddr[poolIndex].bufferNb;
 	bufferInfoTabAddr = mmap(NULL, bufferInfoNb * sizeof(msgBufferInfo),
-	  PROT_READ|PROT_WRITE,MAP_SHARED,bufferInfoTabFd,(off_t)0);
+				 PROT_READ | PROT_WRITE, MAP_SHARED,
+				 bufferInfoTabFd, (off_t) 0);
 
 	bufferInfoTabAddr[bufferIndex].ownerPid = (pid_t) - 1;
 	bufferInfoTabAddr[bufferIndex].addr = NULL;
 
-  if (munmap(bufferInfoTabAddr,bufferInfoNb*sizeof(msgBufferInfo))< 0)
+	if (munmap(bufferInfoTabAddr, bufferInfoNb * sizeof(msgBufferInfo)) < 0) {
-  {	
 		NZG_ERROR("munmap", bufferInfoTabId);
 		return -1;
 	}
 
 	return 0;
 }
-  

src/bufferGetFreeIndex.c

@@ -1,6 +1,7 @@
 #include "libnazgul.h"
 
-int msgBufferGetFreeIndex(msgPoolData * poolDataTabAddr,int poolIndex){
+int msgBufferGetFreeIndex(msgPoolData * poolDataTabAddr, int poolIndex)
+{
 	msgBufferInfoTabId bufferInfoTabId;
 	int bufferInfoTabFd;
 	msgBufferInfo *bufferInfoTabAddr;
@@ -20,20 +21,23 @@ int i;
   /** on regarde dans le tableau d'infos de buffer **/
 	bufferInfoNb = poolDataTabAddr[poolIndex].bufferNb;
 	bufferInfoTabAddr = mmap(NULL, bufferInfoNb * sizeof(msgBufferInfo),
-	  PROT_READ,MAP_SHARED,bufferInfoTabFd,(off_t)0);
+				 PROT_READ, MAP_SHARED, bufferInfoTabFd,
+				 (off_t) 0);
 
 	i = 0;
 	while ((i < bufferInfoNb)
-	  && (bufferInfoTabAddr[i].ownerPid != (pid_t)-1)){ i++; }
+	       && (bufferInfoTabAddr[i].ownerPid != (pid_t) - 1)) {
-  if (i == bufferInfoNb){ return -1; }
+		i++;
+	}
+	if (i == bufferInfoNb) {
+		return -1;
+	}
 	bufferFreeIndex = i;
 
-  if (munmap(bufferInfoTabAddr,bufferInfoNb*sizeof(msgBufferInfo))< 0)
+	if (munmap(bufferInfoTabAddr, bufferInfoNb * sizeof(msgBufferInfo)) < 0) {
-  {	
 		NZG_ERROR("munmap", bufferInfoTabId);
 		return -1;
 	}
 
 	return bufferFreeIndex;
 }
-

src/bufferGetProcAttach.c

@@ -1,12 +1,9 @@
 #include "libnazgul.h"
 
-int msgBufferGetProcAttach(
+int msgBufferGetProcAttach(msgPoolData * poolDataTabAddr,
-	msgPoolData * poolDataTabAddr,
 			   int poolNb,
-	int * poolIndex,
+			   int *poolIndex, int *bufferIndex, void *addr)
-	int * bufferIndex,
+{
-	void * addr
-	){
 	msgBufferInfoTabId bufferInfoTabId;
 	int bufferInfoTabFd;
 	msgBufferInfo *bufferInfoTabAddr;
@@ -21,13 +18,17 @@ int msgBufferGetProcAttach(
 		strcpy(bufferInfoTabId, poolDataTabAddr[pIdx].bufferInfoTabId);
 		bufferInfoNb = poolDataTabAddr[pIdx].bufferNb;
 
-	bufferInfoTabFd=shm_open(bufferInfoTabId,O_RDWR,SHM_DEFAULT_MODE);
+		bufferInfoTabFd =
-	if (bufferInfoTabFd<0)
+		    shm_open(bufferInfoTabId, O_RDWR, SHM_DEFAULT_MODE);
-	{ NZG_ERROR("shm_open",bufferInfoTabId); return -1; 	}
+		if (bufferInfoTabFd < 0) {
+			NZG_ERROR("shm_open", bufferInfoTabId);
+			return -1;
+		}
 
 	/** on regarde dans le tableau d'infos de buffer **/
-	bufferInfoTabAddr=mmap(NULL,bufferInfoNb*sizeof(msgBufferInfo),
+		bufferInfoTabAddr =
-		PROT_READ,MAP_SHARED,bufferInfoTabFd,(off_t)0);
+		    mmap(NULL, bufferInfoNb * sizeof(msgBufferInfo), PROT_READ,
+			 MAP_SHARED, bufferInfoTabFd, (off_t) 0);
 
 		/* on cherche dans chacun des buffers */
 		bIdx = 0;
@@ -38,14 +39,23 @@ int msgBufferGetProcAttach(
 			};
 			bIdx++;
 		}
-	if (found){ (*poolIndex)=pIdx; }
+		if (found) {
+			(*poolIndex) = pIdx;
+		}
 		/* on détache le morceau de mémoire */
-	if (munmap(bufferInfoTabAddr,bufferInfoNb*sizeof(msgBufferInfo))< 0)
+		if (munmap
-	{ NZG_ERROR("munmap",bufferInfoTabId); return -1; }
+		    (bufferInfoTabAddr,
+		     bufferInfoNb * sizeof(msgBufferInfo)) < 0) {
+			NZG_ERROR("munmap", bufferInfoTabId);
+			return -1;
+		}
 		close(bufferInfoTabFd);
 		pIdx++;
 	}
 
-  if (found){ return 0; } else {return -1;}
+	if (found) {
+		return 0;
+	} else {
+		return -1;
+	}
 }
-

src/bufferInfoTabCreate.c

@@ -1,11 +1,10 @@
 #include "libnazgul.h"
 #include "ids.h"
 
-int msgBufferInfoTabCreate(
+int msgBufferInfoTabCreate(msgSpaceId externId,
-	msgSpaceId externId,
 			   msgPoolData * poolDataTabAddr,
-	int poolIdx,
+			   int poolIdx, int bufferNb)
-	int bufferNb) {
+{
 
 	int bufferInfoTabFd;
 	msgBufferInfoTabId bufferInfoTabId;
@@ -16,10 +15,12 @@ int msgBufferInfoTabCreate(
 		return -1;
 	}
 
-  bufferInfoTabFd=shm_open(bufferInfoTabId,O_RDWR|O_CREAT|O_EXCL|O_TRUNC,MSGSPACE_DEFAULT_MODE);
+	bufferInfoTabFd =
+	    shm_open(bufferInfoTabId, O_RDWR | O_CREAT | O_EXCL | O_TRUNC,
+		     MSGSPACE_DEFAULT_MODE);
 	if (bufferInfoTabFd == -1) {
-	fprintf( stderr, "msgInfoTab : %s creation failed: %s\n",bufferInfoTabId,
+		fprintf(stderr, "msgInfoTab : %s creation failed: %s\n",
-		strerror( errno ) );
+			bufferInfoTabId, strerror(errno));
 		return -1;
 	}
 	if (ftruncate(bufferInfoTabFd, bufferNb * sizeof(msgBufferInfo)) == -1) {
@@ -32,6 +33,7 @@ int msgBufferInfoTabCreate(
 
 	msgBufferInfoTabInit(poolDataTabAddr, poolIdx);
 
-  return -1;NZG_ERROR("munmap",bufferInfoTabId);
+	return -1;
+	NZG_ERROR("munmap", bufferInfoTabId);
 	return -1;
 }

src/bufferInfoTabInit.c

@@ -1,6 +1,7 @@
 #include "libnazgul.h"
 
-int msgBufferInfoTabInit(msgPoolData * poolDataTabAddr,int poolIndex){
+int msgBufferInfoTabInit(msgPoolData * poolDataTabAddr, int poolIndex)
+{
 	msgBufferInfoTabId bufferInfoTabId;
 	int bufferInfoTabFd;
 	msgBufferInfo *bufferInfoTabAddr;
@@ -10,7 +11,8 @@ int i;
 	//récuperer l'ID du BufferInfoTab;
 	strcpy(bufferInfoTabId, poolDataTabAddr[poolIndex].bufferInfoTabId);
 
-  printf("msgBufferInfoTabId %d open >>%s<<\n",poolIndex,bufferInfoTabId);
+	printf("msgBufferInfoTabId %d open >>%s<<\n", poolIndex,
+	       bufferInfoTabId);
 	bufferInfoTabFd = shm_open(bufferInfoTabId, O_RDWR, SHM_DEFAULT_MODE);
 	if (bufferInfoTabFd < 0) {
 		NZG_ERROR("msgBufferInfoTabId open", bufferInfoTabId);
@@ -20,15 +22,17 @@ int i;
   /** on regarde dans le tableau d'infos de buffer **/
 	bufferInfoNb = poolDataTabAddr[poolIndex].bufferNb;
 	bufferInfoTabAddr = mmap(NULL, bufferInfoNb * sizeof(msgBufferInfo),
-	  PROT_WRITE|PROT_READ,MAP_SHARED,bufferInfoTabFd,(off_t)0);
+				 PROT_WRITE | PROT_READ, MAP_SHARED,
+				 bufferInfoTabFd, (off_t) 0);
 
 	for (i = 0; i < bufferInfoNb; i++) {
 		bufferInfoTabAddr[i].ownerPid = (pid_t) - 1;
 	}
 
-  if (munmap(bufferInfoTabAddr,bufferInfoNb*sizeof(msgBufferInfo))< 0)
+	if (munmap(bufferInfoTabAddr, bufferInfoNb * sizeof(msgBufferInfo)) < 0) {
-  {	perror("munmap"); return -1; }
+		perror("munmap");
+		return -1;
+	}
 
 	return 0;
 }
-

src/bufferMap.c

@@ -1,7 +1,7 @@
 #include "libnazgul.h"
 
-
+void *msgBufferMap(msgPoolData * poolDataTab, int poolIndex, int bufferIndex)
-void * msgBufferMap(msgPoolData * poolDataTab, int poolIndex, int bufferIndex) {
+{
 	void *resultAddr;
 	int bufferSize, bufferNb;
 	int poolBufferTabFd;
@@ -20,15 +20,10 @@ void * msgBufferMap(msgPoolData * poolDataTab, int poolIndex, int bufferIndex) {
 		NZG_ERROR("shm_open", poolBufferTabId);
 		goto ERROR;
 	}
-
 	// mapper le buffer dans l'espace mémoire du processus
 	/* on s'arrete juste derriere l'index qui nous intéresse */
-  resultAddr=mmap(NULL, 
+	resultAddr = mmap(NULL, bufferSize * (bufferIndex + 1), PROT_READ | PROT_WRITE,	//PROT_NONE
-	  bufferSize*(bufferIndex+1),  
+			  MAP_SHARED, poolBufferTabFd, (off_t) 0);
-	  PROT_READ|PROT_WRITE,  //PROT_NONE
-	  MAP_SHARED, 
-	  poolBufferTabFd, 
-	  (off_t)0);
 	if (resultAddr == MAP_FAILED) {
 		NZG_ERROR("mmap", poolBufferTabId);
 		goto ERROR;

src/free.c

@@ -1,6 +1,7 @@
 #include "libnazgul.h"
 
-int msgFree(msgSpace * space, void * addr){
+int msgFree(msgSpace * space, void *addr)
+{
 
 	int poolIndex;
 	int bufferIndex;
@@ -25,14 +26,11 @@ int msgFree(msgSpace * space, void * addr){
 
 	// TODO: verouiller semaphore DataInfo ??
 
-  poolIndex=-1; bufferIndex=-1;
+	poolIndex = -1;
-  err=msgBufferGetProcAttach(
+	bufferIndex = -1;
-	  poolDataTabAddr,
+	err = msgBufferGetProcAttach(poolDataTabAddr,
 				     space->poolNb,
-	  &poolIndex,
+				     &poolIndex, &bufferIndex, addr);
-	  &bufferIndex,
-	  addr
-	  );
 
 	printf("Found : %d\n", err);
 	printf("Freing pool: %d, buffer: %d\n", poolIndex, bufferIndex);
@@ -63,4 +61,3 @@ int msgFree(msgSpace * space, void * addr){
  ERROR:
 	return -1;
 }
-

src/get.c

@@ -2,7 +2,8 @@
 
 #define NONBLOCK -1
 
-void * msgGet(msgSpace * space,int queueIndex,int option){
+void *msgGet(msgSpace * space, int queueIndex, int option)
+{
 	void *resultAddr;
 	msgQueueId queueId;
 	msgQueue *queue;
@@ -42,12 +43,12 @@ void * msgGet(msgSpace * space,int queueIndex,int option){
 	/* on récupere la taille des buffer dans la pool du buffer */
 	poolDataTab = msgPoolDataTabOpen(space);
 	// mapper le buffer dans l'espace mémoire du processus
-  resultAddr=msgBufferMap(poolDataTab,oldElem->poolIndex,oldElem->bufferIndex);
+	resultAddr =
+	    msgBufferMap(poolDataTab, oldElem->poolIndex, oldElem->bufferIndex);
 	// attacher au buffer...
 	if (msgBufferAttachProc(poolDataTab,
 				oldElem->poolIndex,
-		oldElem->bufferIndex,
+				oldElem->bufferIndex, resultAddr) < 0) {
-		resultAddr) <0){
 		NZG_ERROR("msgBufferAttachProc", oldElemId);
 		goto ERROR;
 	}

src/global.h

@@ -25,12 +25,10 @@
 #define SEM_FAILED ((sem_t *)0)
 #endif
 
-
 #ifndef MAP_FAILED
 #define MAP_FAILED ((void *)-1)
 #endif
 
-
 #ifdef _NZG_REALFILEID
 #define DEFAULT_MSGSPACELISTID "/tmp/nzgSpaceList"
 #else

src/global.h~

@@ -0,0 +1,48 @@
+#ifndef _NZG_GLOBAL
+#define _NZG_GLOBAL 1
+
+#include <unistd.h>  /* POSIX et al */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h> /* pour O_RDWR */
+#include <sys/types.h>
+#include <sys/mman.h> /* shm_open */
+#include <errno.h>
+#include <semaphore.h>
+
+#define PAGESIZE sysconf(_SC_PAGESIZE)
+#define MSGSPACE_DEFAULT_MODE 0600
+#define SEM_DEFAULT_MODE 0600
+#define SHM_DEFAULT_MODE 0600
+#define MSGSPACE_ID_LEN 32
+#define ERR_UNHANDLED "Gérer mieu les erreurs"
+
+#define ANYPOOL -1
+#define SPECIFICPOOL 0
+
+#ifndef SEM_FAILED
+#define SEM_FAILED ((sem_t *)0)
+#endif
+
+
+#ifndef MAP_FAILED
+#define MAP_FAILED ((void *)-1)
+#endif
+
+
+#ifdef _NZG_REALFILEID
+#define DEFAULT_MSGSPACELISTID "/tmp/nzgSpaceList"
+#else
+#define DEFAULT_MSGSPACELISTID "/nzgSpaceList"
+#endif
+
+#ifdef _NZG_REALFILEID
+#define DEFAULT_MSGSPACELISTSEMID "/tmp/nzgSpaceListSem"
+#else
+#define DEFAULT_MSGSPACELISTSEMID "/nzgSpaceListSem"
+#endif
+
+#define NZG_ERROR(func,str) fprintf(stderr,"*** %s: %s***\n%s in %s:%d\n",func,strerror(errno),str,__FILE__,__LINE__);
+
+#endif

src/ids.c

@@ -1,7 +1,8 @@
 #include "libnazgul.h"
 #include "ids.h"
 
-int msgSpaceIdIntern(msgSpaceId dest,const msgSpaceId src ){
+int msgSpaceIdIntern(msgSpaceId dest, const msgSpaceId src)
+{
 	if (strlen(src) > MSGSPACE_ID_LEN) {
 		return -1;
 	}
@@ -13,9 +14,9 @@ int msgSpaceIdIntern(msgSpaceId dest,const msgSpaceId src ){
 #endif
 	return 0;
 }
-int msgPoolDataTabSemIdIntern(
+
-	msgPoolSemId destSemId,
+int msgPoolDataTabSemIdIntern(msgPoolSemId destSemId, const msgSpaceId externId)
-	const msgSpaceId externId){
+{
 	if (strlen(externId) > MSGSPACE_ID_LEN * 4) {
 		return -1;
 	}
@@ -27,10 +28,10 @@ int msgPoolDataTabSemIdIntern(
 #endif
 	return 0;
 }
-int msgPoolSemIdIntern(
+
-	msgPoolSemId destSemId,
+int msgPoolSemIdIntern(msgPoolSemId destSemId,
-	const msgSpaceId srcPoolId,
+		       const msgSpaceId srcPoolId, int poolIdx)
-	int poolIdx){
+{
 	if (strlen(srcPoolId) > MSGSPACE_ID_LEN * 4) {
 		return -1;
 	}
@@ -43,7 +44,8 @@ int msgPoolSemIdIntern(
 	return 0;
 }
 
-int msgPoolDataIdIntern(msgPoolDataTabId dest,const msgSpaceId src ){
+int msgPoolDataIdIntern(msgPoolDataTabId dest, const msgSpaceId src)
+{
 	if (strlen(src) > MSGSPACE_ID_LEN) {
 		return -1;
 	}
@@ -56,8 +58,8 @@ int msgPoolDataIdIntern(msgPoolDataTabId dest,const msgSpaceId src ){
 	return 0;
 }
 
-
+int msgPoolIdIntern(msgPoolId dest, msgPoolId src, int num)
-int msgPoolIdIntern(msgPoolId dest,msgPoolId src, int num){
+{
 	if (strlen(src) > MSGSPACE_ID_LEN) {
 		return -1;
 	}
@@ -69,10 +71,8 @@ int msgPoolIdIntern(msgPoolId dest,msgPoolId src, int num){
 	return 0;
 }
 
-int msgBufferInfoTabIdIntern(
+int msgBufferInfoTabIdIntern(msgBufferInfoTabId dest, msgSpaceId src, int num)
-	msgBufferInfoTabId dest,
+{
-	msgSpaceId src, 
-	int num){
 	if (strlen(src) > MSGSPACE_ID_LEN) {
 		return -1;
 	}
@@ -84,10 +84,9 @@ int msgBufferInfoTabIdIntern(
 	return 0;
 }
 
-int msgQueueProtSemIdIntern(
+int msgQueueProtSemIdIntern(msgQueueSemId dest,
-	msgQueueSemId dest,
+			    msgSpaceId externId, int queueIdx)
-	msgSpaceId externId, 
+{
-	int queueIdx){
 	if (strlen(externId) > MSGSPACE_ID_LEN) {
 		return -1;
 	}
@@ -99,10 +98,9 @@ int msgQueueProtSemIdIntern(
 	return 0;
 }
 
-int msgQueueReadSemIdIntern(
+int msgQueueReadSemIdIntern(msgQueueSemId dest,
-	msgQueueSemId dest,
+			    msgSpaceId externId, int queueIdx)
-	msgSpaceId externId, 
+{
-	int queueIdx){
 	if (strlen(externId) > MSGSPACE_ID_LEN) {
 		return -1;
 	}
@@ -114,10 +112,8 @@ int msgQueueReadSemIdIntern(
 	return 0;
 }
 
-int msgQueueIdIntern(
+int msgQueueIdIntern(msgQueueId dest, msgSpaceId externId, int queueIdx)
-	msgQueueId dest,
+{
-	msgSpaceId externId, 
-	int queueIdx){
 	if (strlen(externId) > MSGSPACE_ID_LEN) {
 		return -1;
 	}
@@ -129,10 +125,8 @@ int msgQueueIdIntern(
 	return 0;
 }
 
-int msgQueueElemIdIntern(
+int msgQueueElemIdIntern(msgQueueElemId dest, msgQueueId src, int counter)
-	msgQueueElemId dest,
+{
-	msgQueueId src,
-	int counter){
 	if (strlen(src) > MSGSPACE_ID_LEN) {
 		return -1;
 	}
@@ -140,7 +134,8 @@ int msgQueueElemIdIntern(
 	return 0;
 }
 
-int msgSpaceListElemIdIntern(msgSpaceListElemId elemListId,msgSpaceId externId){
+int msgSpaceListElemIdIntern(msgSpaceListElemId elemListId, msgSpaceId externId)
+{
 	if (strlen(externId) > MSGSPACE_ID_LEN) {
 		return -1;
 	}
@@ -153,6 +148,3 @@ int msgSpaceListElemIdIntern(msgSpaceListElemId elemListId,msgSpaceId externId){
 	return 0;
 
 }
-
-
-

src/ids.h

@@ -2,21 +2,13 @@
 #define _NZG_IDS 1
 #include "libnazgul.h"
 
-
-
-
 /* nzg_ids.c */
 int msgSpaceIdIntern(msgSpaceId dest, const msgSpaceId src);
-int msgPoolSemIdIntern(msgPoolSemId destSemId, const msgSpaceId srcPoolId, int poolIdx);
+int msgPoolSemIdIntern(msgPoolSemId destSemId, const msgSpaceId srcPoolId,
+		       int poolIdx);
 int msgPoolDataIdIntern(msgPoolDataTabId dest, const msgSpaceId src);
 int msgPoolIdIntern(msgPoolId dest, msgPoolId src, int num);
-int msgQueueSemIdIntern(
+int msgQueueSemIdIntern(msgQueueSemId dest, msgSpaceId externId, int queueIdx);
-	msgQueueSemId dest,
+int msgQueueIdIntern(msgQueueId dest, msgSpaceId externId, int queueIdx);
-	msgSpaceId externId, 
-	int queueIdx);
-int msgQueueIdIntern(
-	msgQueueId dest,
-	msgSpaceId externId, 
-	int queueIdx);
 
 #endif

src/ids.h~

@@ -0,0 +1,22 @@
+#ifndef _NZG_IDS
+#define _NZG_IDS 1
+#include "libnazgul.h"
+
+
+
+
+/* nzg_ids.c */
+int msgSpaceIdIntern(msgSpaceId dest, const msgSpaceId src);
+int msgPoolSemIdIntern(msgPoolSemId destSemId, const msgSpaceId srcPoolId, int poolIdx);
+int msgPoolDataIdIntern(msgPoolDataTabId dest, const msgSpaceId src);
+int msgPoolIdIntern(msgPoolId dest,msgPoolId src, int num);
+int msgQueueSemIdIntern(
+	msgQueueSemId dest,
+	msgSpaceId externId, 
+	int queueIdx);
+int msgQueueIdIntern(
+	msgQueueId dest,
+	msgSpaceId externId, 
+	int queueIdx);
+
+#endif

src/iface.h

@@ -46,7 +46,6 @@ typedef struct MsgPoolData {
 
 /* TODO: queueId */
 
-
 typedef struct MsgSpace {
 	msgSpaceId id;
 	msgSpaceId externId;
@@ -57,7 +56,6 @@ typedef struct MsgSpace {
 	msgPoolDataTabSemId poolDataTabSemId;
 } msgSpace;
 
-
 typedef struct MsgSpaceListElem {
 	msgSpaceListElemId id;
 

src/iface.h~

@@ -0,0 +1,91 @@
+#ifndef _NZG_IFACE
+#define _NZG_IFACE 1
+
+#include "global.h"
+
+typedef enum { true=1, false=0} bool;
+
+typedef char msgSpaceId[MSGSPACE_ID_LEN];
+
+typedef char msgSpaceListId[4*MSGSPACE_ID_LEN]; 
+typedef char msgSpaceListSemId[4*MSGSPACE_ID_LEN]; 
+typedef char msgSpaceListElemId[4*MSGSPACE_ID_LEN];
+
+typedef char msgPoolDataTabId[4*MSGSPACE_ID_LEN];
+typedef char msgPoolDataTabSemId[4*MSGSPACE_ID_LEN];
+
+typedef char msgBufferInfoTabId[4*MSGSPACE_ID_LEN];
+
+typedef char msgPoolId[4*MSGSPACE_ID_LEN];
+typedef char msgPoolSemId[4*MSGSPACE_ID_LEN];
+
+typedef char msgQueueDataId[4*MSGSPACE_ID_LEN];
+typedef char msgQueueId[4*MSGSPACE_ID_LEN];
+typedef char msgQueueElemId[4*MSGSPACE_ID_LEN];
+typedef char msgQueueSemId[4*MSGSPACE_ID_LEN];
+
+  /* pid[] */
+  /* liste des processus demandeurs */ 
+typedef struct MsgPool {
+  int bufferSize;
+  int bufferNb;
+} msgPool;
+
+typedef struct MsgBufferInfo {
+  pid_t ownerPid;
+  void * addr;
+} msgBufferInfo;
+
+typedef struct MsgPoolData {
+  msgPoolId poolId;
+  msgBufferInfoTabId bufferInfoTabId;
+  int bufferNb;
+  int bufferSize;
+  int allocDispBuffer;
+} msgPoolData;
+
+/* TODO: queueId */
+
+
+typedef struct MsgSpace {
+  msgSpaceId id;
+  msgSpaceId externId;
+  int poolNb;
+  int queueNb;
+  int pid; 
+  msgPoolDataTabId poolDataTabId;
+  msgPoolDataTabSemId poolDataTabSemId;
+} msgSpace;
+
+
+typedef struct MsgSpaceListElem {
+  msgSpaceListElemId id;
+
+  msgSpaceId spaceId;
+  msgSpaceListElemId next;
+} msgSpaceListElem;
+
+typedef struct MsgSpaceList {
+  msgSpaceListId id;
+  
+  int elemCounter;
+  msgSpaceListElemId headId;
+  msgSpaceListElemId tailId;
+} msgSpaceList;
+
+typedef struct MsgQueueElem {
+  msgQueueElemId id;  
+  int poolIndex;
+  int bufferIndex;
+  msgQueueElemId next;  
+} msgQueueElem;
+
+typedef struct MsgQueue {
+  msgQueueId id;
+  int elemCounter;
+  msgQueueElemId headId; 
+  msgQueueElemId tailId;
+} msgQueue;
+
+#endif
+/* */

src/libnazgul.h~

@@ -0,0 +1,8 @@
+#ifndef _LIBNAZGUL
+#define _LIBNAZGUL 1
+
+#include "global.h"
+#include "iface.h"
+#include "proto.h"
+
+#endif

src/poolCreate.c

@@ -1,12 +1,8 @@
 #include "libnazgul.h"
 #include "ids.h"
 
-int msgPoolCreate(
+int msgPoolCreate(msgSpaceId externId, int poolIdx, int buffNb, int buffSize)
-		msgSpaceId externId,
+{
-		int poolIdx,
-		int buffNb,
-		int buffSize
-	) {
 
 	int poolFd;
 	sem_t *ressourceSemFd;
@@ -15,10 +11,13 @@ int msgPoolCreate(
 
 	/* creation des buffers DEBUT */
 	if (msgPoolIdIntern(poolId, externId, poolIdx) == -1) {
-	  fprintf( stderr, "msgPoolId creation failed for id %s\n", (char*)poolId );
+		fprintf(stderr, "msgPoolId creation failed for id %s\n",
+			(char *)poolId);
 		return -1;
 	}
-	poolFd=shm_open(poolId,O_RDWR|O_CREAT|O_EXCL|O_TRUNC,MSGSPACE_DEFAULT_MODE);
+	poolFd =
+	    shm_open(poolId, O_RDWR | O_CREAT | O_EXCL | O_TRUNC,
+		     MSGSPACE_DEFAULT_MODE);
 	if (poolFd == -1) {
 		fprintf(stderr, "msgPool : %s creation failed: %s\n", poolId,
 			strerror(errno));
@@ -36,14 +35,17 @@ int msgPoolCreate(
 			(char *)poolRessourceSemId);
 		return -1;
 	}
-
 	// on met un semaphore sur le pool
-	ressourceSemFd = sem_open(poolRessourceSemId, O_CREAT|O_EXCL,SEM_DEFAULT_MODE, buffNb);
+	ressourceSemFd =
+	    sem_open(poolRessourceSemId, O_CREAT | O_EXCL, SEM_DEFAULT_MODE,
+		     buffNb);
 	if (ressourceSemFd == SEM_FAILED) {
-		  NZG_ERROR("sem_open : creation de la ressource",poolRessourceSemId);
+		NZG_ERROR("sem_open : creation de la ressource",
+			  poolRessourceSemId);
 		goto ERROR;
 	} else {
-		  printf("[ Created %s with %d ressources ]\n",poolRessourceSemId,buffNb);
+		printf("[ Created %s with %d ressources ]\n",
+		       poolRessourceSemId, buffNb);
 	}
 
 	//TODO: verrifier les erreurs sur l'ouverture de la sem
@@ -58,4 +60,3 @@ int msgPoolCreate(
  ERROR:
 	return -1;
 }
-

src/poolDataTabClose.c

@@ -1,6 +1,7 @@
 #include "libnazgul.h"
 
-int msgPoolDataTabClose(msgSpace * space,void * addr){
+int msgPoolDataTabClose(msgSpace * space, void *addr)
+{
 	/* unmapper le msgPoolDataTab */
 
 	if (munmap(addr, (space->poolNb) * sizeof(msgPoolData)) < 0) {

src/poolDataTabCreate.c

@@ -1,14 +1,13 @@
 #include "libnazgul.h"
 #include "ids.h"
 
-void * msgPoolDataTabCreate(msgSpace * space){
+void *msgPoolDataTabCreate(msgSpace * space)
+{
 	int poolDataFd;		// shm file descriptor
 	msgPoolData *poolDataTabAddr;
-  poolDataFd=shm_open(
+	poolDataFd = shm_open(space->poolDataTabId,
-	  space->poolDataTabId,
 			      O_RDWR | O_CREAT | O_EXCL | O_TRUNC,
-	  MSGSPACE_DEFAULT_MODE
+			      MSGSPACE_DEFAULT_MODE);
-	  );
 	if (poolDataFd == -1) {
 		NZG_ERROR("shm_open :create", space->poolDataTabId);
 		goto ERROR;
@@ -38,5 +37,3 @@ void * msgPoolDataTabCreate(msgSpace * space){
  ERROR:
 	return NULL;
 }
-
-

src/poolDataTabLock.c

@@ -3,17 +3,17 @@
 
 #define DEBUG 0
 
-int msgPoolDataTabLock(msgSpace * space){
+int msgPoolDataTabLock(msgSpace * space)
+{
 	int semval;
 	sem_t *poolDataTabSemFd;
 	semval = 0;
-  if (DEBUG) {printf("Locking %s\n",space->poolDataTabSemId);}
+	if (DEBUG) {
+		printf("Locking %s\n", space->poolDataTabSemId);
+	}
 
-  poolDataTabSemFd=sem_open(
+	poolDataTabSemFd = sem_open(space->poolDataTabSemId, O_CREAT,
-	  space->poolDataTabSemId
+				    SEM_DEFAULT_MODE, 1);
-	  ,O_CREAT,
-	  SEM_DEFAULT_MODE,
-	  1);
 	if (poolDataTabSemFd == SEM_FAILED) {
 		NZG_ERROR("sem_open", space->poolDataTabSemId);
 		goto ERROR;
@@ -25,7 +25,9 @@ int msgPoolDataTabLock(msgSpace * space){
 	}
 
 	sem_getvalue(poolDataTabSemFd, &semval);
-  if (DEBUG) { printf("(AfternValue:%d)\n",semval);}
+	if (DEBUG) {
+		printf("(AfternValue:%d)\n", semval);
+	}
 
 	sem_close(poolDataTabSemFd);
 
@@ -33,4 +35,3 @@ int msgPoolDataTabLock(msgSpace * space){
  ERROR:
 	return -1;
 }
-

src/poolDataTabOpen.c

@@ -1,19 +1,18 @@
 #include "libnazgul.h"
 #include "ids.h"
 
-void * msgPoolDataTabOpen(msgSpace * space){
+void *msgPoolDataTabOpen(msgSpace * space)
+{
 	int poolDataTabFd;
 	void *poolDataTabAddr;
 
 	poolDataTabFd = shm_open(space->poolDataTabId,
-	  O_RDWR,
+				 O_RDWR, MSGSPACE_DEFAULT_MODE);
-	  MSGSPACE_DEFAULT_MODE);
 	if (poolDataTabFd == -1) {
 		NZG_ERROR("shm_open", space->poolDataTabId);
 		goto ERROR;
 	}
 
-
 	poolDataTabAddr = mmap(NULL, (space->poolNb) * sizeof(msgPoolData),
 			       PROT_READ | PROT_WRITE,
 			       MAP_SHARED, poolDataTabFd, 0);

src/poolDataTabUnlock.c

@@ -3,15 +3,15 @@
 
 #define DEBUG 0
 
-int msgPoolDataTabUnlock(msgSpace * space){
+int msgPoolDataTabUnlock(msgSpace * space)
+{
 	int semval;
 	sem_t *poolDataTabSemFd;
-  if (DEBUG) { printf("Unlocking %s\n",space->poolDataTabSemId); }
+	if (DEBUG) {
-  poolDataTabSemFd=sem_open(
+		printf("Unlocking %s\n", space->poolDataTabSemId);
-	  space->poolDataTabSemId
+	}
-	  ,O_CREAT,
+	poolDataTabSemFd = sem_open(space->poolDataTabSemId, O_CREAT,
-	  SEM_DEFAULT_MODE,
+				    SEM_DEFAULT_MODE, 1);
-	  1);
 	if (poolDataTabSemFd == SEM_FAILED) {
 		NZG_ERROR("sem_open", space->poolDataTabSemId);
 		goto ERROR;
@@ -24,7 +24,9 @@ int msgPoolDataTabUnlock(msgSpace * space){
 
 	semval = 0;
 	sem_getvalue(poolDataTabSemFd, &semval);
-  if (DEBUG) { printf("(AfternValue:%d)\n",semval); }
+	if (DEBUG) {
+		printf("(AfternValue:%d)\n", semval);
+	}
 
 	sem_close(poolDataTabSemFd);
 
@@ -32,4 +34,3 @@ int msgPoolDataTabUnlock(msgSpace * space){
  ERROR:
 	return -1;
 }
-

src/poolDelete.c

@@ -1,32 +1,31 @@
 #include "libnazgul.h"
 #include "ids.h"
 
-int msgPoolDelete(
+int msgPoolDelete(msgSpaceId spaceId, int poolIdx)
-		msgSpaceId spaceId,
+{
-		int poolIdx
-	) {
 
 	msgPoolId poolId;
 	msgBufferInfoTabId bufferInfoTabId;
 	msgPoolSemId poolRessourceSemId;
 
-	
 	/* suppression des infos sur buffers DEBUT */
 	if (msgBufferInfoTabIdIntern(bufferInfoTabId, spaceId, poolIdx) == -1) {
-	  fprintf( stderr, "msgPoolId creation failed for id %s\n", (char*)poolId );
+		fprintf(stderr, "msgPoolId creation failed for id %s\n",
+			(char *)poolId);
 		return -1;
 	}
 
 	if (shm_unlink(bufferInfoTabId) < 0) {
-	fprintf( stderr, "msgInfoTab : %s deletion failed: %s\n",bufferInfoTabId,
+		fprintf(stderr, "msgInfoTab : %s deletion failed: %s\n",
-		strerror( errno ) );
+			bufferInfoTabId, strerror(errno));
 		return -1;
 	}
 	/* suppression des infos sur buffers FIN */
 
 	/* suppression des buffers DEBUT */
 	if (msgPoolIdIntern(poolId, spaceId, poolIdx) == -1) {
-	  fprintf( stderr, "msgPoolId creation failed for id %s\n", (char*)poolId );
+		fprintf(stderr, "msgPoolId creation failed for id %s\n",
+			(char *)poolId);
 		return -1;
 	}
 	if (shm_unlink(poolId) < 0) {

src/proto.h

@@ -4,17 +4,22 @@
 /* allocate.c */
 void *msgAllocate(msgSpace * space, int pool, int taille, int option);
 /* bufferAttachProc.c */
-int msgBufferAttachProc(msgPoolData *poolDataTabAddr, int poolIndex, int bufferIndex, void *addr);
+int msgBufferAttachProc(msgPoolData * poolDataTabAddr, int poolIndex,
+			int bufferIndex, void *addr);
 /* buffer.c */
-int msgBufferGetAttachedProcIndex(msgPoolData *poolDataTabAddr, int poolIndex, void *addr);
+int msgBufferGetAttachedProcIndex(msgPoolData * poolDataTabAddr, int poolIndex,
+				  void *addr);
 /* bufferDetachProc.c */
-int msgBufferDetachProc(msgPoolData *poolDataTabAddr, int poolIndex, int bufferIndex, void *addr);
+int msgBufferDetachProc(msgPoolData * poolDataTabAddr, int poolIndex,
+			int bufferIndex, void *addr);
 /* bufferGetFreeIndex.c */
 int msgBufferGetFreeIndex(msgPoolData * poolDataTabAddr, int poolIndex);
 /* bufferGetProcAttach.c */
-int msgBufferGetProcAttach(msgPoolData *poolDataTabAddr, int poolNb, int *poolIndex, int *bufferIndex, void *addr);
+int msgBufferGetProcAttach(msgPoolData * poolDataTabAddr, int poolNb,
+			   int *poolIndex, int *bufferIndex, void *addr);
 /* bufferInfoTabCreate.c */
-int msgBufferInfoTabCreate(msgSpaceId externId, msgPoolData *poolDataTabAddr, int poolIdx, int bufferNb);
+int msgBufferInfoTabCreate(msgSpaceId externId, msgPoolData * poolDataTabAddr,
+			   int poolIdx, int bufferNb);
 /* bufferInfoTabInit.c */
 int msgBufferInfoTabInit(msgPoolData * poolDataTabAddr, int poolIndex);
 /* bufferMap.c */
@@ -25,16 +30,21 @@ int msgFree(msgSpace *space, void *addr);
 void *msgGet(msgSpace * space, int queueIndex, int option);
 /* ids.c */
 int msgSpaceIdIntern(msgSpaceId dest, const msgSpaceId src);
-int msgPoolDataTabSemIdIntern(msgPoolSemId destSemId, const msgSpaceId externId);
+int msgPoolDataTabSemIdIntern(msgPoolSemId destSemId,
-int msgPoolSemIdIntern(msgPoolSemId destSemId, const msgSpaceId srcPoolId, int poolIdx);
+			      const msgSpaceId externId);
+int msgPoolSemIdIntern(msgPoolSemId destSemId, const msgSpaceId srcPoolId,
+		       int poolIdx);
 int msgPoolDataIdIntern(msgPoolDataTabId dest, const msgSpaceId src);
 int msgPoolIdIntern(msgPoolId dest, msgPoolId src, int num);
 int msgBufferInfoTabIdIntern(msgBufferInfoTabId dest, msgSpaceId src, int num);
-int msgQueueProtSemIdIntern(msgQueueSemId dest, msgSpaceId externId, int queueIdx);
+int msgQueueProtSemIdIntern(msgQueueSemId dest, msgSpaceId externId,
-int msgQueueReadSemIdIntern(msgQueueSemId dest, msgSpaceId externId, int queueIdx);
+			    int queueIdx);
+int msgQueueReadSemIdIntern(msgQueueSemId dest, msgSpaceId externId,
+			    int queueIdx);
 int msgQueueIdIntern(msgQueueId dest, msgSpaceId externId, int queueIdx);
 int msgQueueElemIdIntern(msgQueueElemId dest, msgQueueId src, int counter);
-int msgSpaceListElemIdIntern(msgSpaceListElemId elemListId, msgSpaceId externId);
+int msgSpaceListElemIdIntern(msgSpaceListElemId elemListId,
+			     msgSpaceId externId);
 /* list.c */
 /* poolCreate.c */
 int msgPoolCreate(msgSpaceId externId, int poolIdx, int buffNb, int buffSize);
@@ -61,7 +71,8 @@ int msgQueueDelete(msgQueueId externId, int queueIdx);
 /* queueElemClose.c */
 int msgQueueElemClose(msgQueueElem * queueElem);
 /* queueElemCreate.c */
-int msgQueueElemCreate(msgQueueElemId finalQueueElemId, msgQueueId queueId, int counter);
+int msgQueueElemCreate(msgQueueElemId finalQueueElemId, msgQueueId queueId,
+		       int counter);
 /* queueElemDelete.c */
 int msgQueueElemDelete(msgQueueElemId queueElemId);
 /* queueElemOpen.c */
@@ -85,7 +96,8 @@ int msgQueueRem(msgQueue *queue, msgQueueElemId oldElemId);
 /* spaceClose.c */
 int msgSpaceClose(msgSpace * space);
 /* spaceCreate.c */
-msgSpace *msgSpaceCreate(msgSpaceId externId, int queueNb, int poolNb, msgPool *poolInfos);
+msgSpace *msgSpaceCreate(msgSpaceId externId, int queueNb, int poolNb,
+			 msgPool * poolInfos);
 /* spaceDelete.c */
 int msgSpaceDelete(msgSpaceId externId);
 /* spaceListAdd.c */

src/proto.h~

@@ -0,0 +1,118 @@
+#ifndef _NZG_PROTO
+#define _NZG_PROTO 1
+
+/* allocate.c */
+void *msgAllocate(msgSpace *space, int pool, int taille, int option);
+/* bufferAttachProc.c */
+int msgBufferAttachProc(msgPoolData *poolDataTabAddr, int poolIndex, int bufferIndex, void *addr);
+/* buffer.c */
+int msgBufferGetAttachedProcIndex(msgPoolData *poolDataTabAddr, int poolIndex, void *addr);
+/* bufferDetachProc.c */
+int msgBufferDetachProc(msgPoolData *poolDataTabAddr, int poolIndex, int bufferIndex, void *addr);
+/* bufferGetFreeIndex.c */
+int msgBufferGetFreeIndex(msgPoolData *poolDataTabAddr, int poolIndex);
+/* bufferGetProcAttach.c */
+int msgBufferGetProcAttach(msgPoolData *poolDataTabAddr, int poolNb, int *poolIndex, int *bufferIndex, void *addr);
+/* bufferInfoTabCreate.c */
+int msgBufferInfoTabCreate(msgSpaceId externId, msgPoolData *poolDataTabAddr, int poolIdx, int bufferNb);
+/* bufferInfoTabInit.c */
+int msgBufferInfoTabInit(msgPoolData *poolDataTabAddr, int poolIndex);
+/* bufferMap.c */
+void *msgBufferMap(msgPoolData *poolDataTab, int poolIndex, int bufferIndex);
+/* free.c */
+int msgFree(msgSpace *space, void *addr);
+/* get.c */
+void *msgGet(msgSpace *space, int queueIndex, int option);
+/* ids.c */
+int msgSpaceIdIntern(msgSpaceId dest, const msgSpaceId src);
+int msgPoolDataTabSemIdIntern(msgPoolSemId destSemId, const msgSpaceId externId);
+int msgPoolSemIdIntern(msgPoolSemId destSemId, const msgSpaceId srcPoolId, int poolIdx);
+int msgPoolDataIdIntern(msgPoolDataTabId dest, const msgSpaceId src);
+int msgPoolIdIntern(msgPoolId dest, msgPoolId src, int num);
+int msgBufferInfoTabIdIntern(msgBufferInfoTabId dest, msgSpaceId src, int num);
+int msgQueueProtSemIdIntern(msgQueueSemId dest, msgSpaceId externId, int queueIdx);
+int msgQueueReadSemIdIntern(msgQueueSemId dest, msgSpaceId externId, int queueIdx);
+int msgQueueIdIntern(msgQueueId dest, msgSpaceId externId, int queueIdx);
+int msgQueueElemIdIntern(msgQueueElemId dest, msgQueueId src, int counter);
+int msgSpaceListElemIdIntern(msgSpaceListElemId elemListId, msgSpaceId externId);
+/* list.c */
+/* poolCreate.c */
+int msgPoolCreate(msgSpaceId externId, int poolIdx, int buffNb, int buffSize);
+/* poolDataTabClose.c */
+int msgPoolDataTabClose(msgSpace *space, void *addr);
+/* poolDataTabCreate.c */
+void *msgPoolDataTabCreate(msgSpace *space);
+/* poolDataTabLock.c */
+int msgPoolDataTabLock(msgSpace *space);
+/* poolDataTabOpen.c */
+void *msgPoolDataTabOpen(msgSpace *space);
+/* poolDataTabUnlock.c */
+int msgPoolDataTabUnlock(msgSpace *space);
+/* poolDelete.c */
+int msgPoolDelete(msgSpaceId spaceId, int poolIdx);
+/* put.c */
+int msgPut(msgSpace *space, int queueIndex, void *addr);
+/* queueAdd.c */
+int msgQueueAdd(msgQueue *queue, msgQueueElemId newElemId);
+/* queueClose.c */
+int msgQueueClose(msgQueue *queue);
+/* queueDelete.c */
+int msgQueueDelete(msgQueueId externId, int queueIdx);
+/* queueElemClose.c */
+int msgQueueElemClose(msgQueueElem *queueElem);
+/* queueElemCreate.c */
+int msgQueueElemCreate(msgQueueElemId finalQueueElemId, msgQueueId queueId, int counter);
+/* queueElemDelete.c */
+int msgQueueElemDelete(msgQueueElemId queueElemId);
+/* queueElemOpen.c */
+void *msgQueueElemOpen(msgQueueElemId queueElemId);
+/* queueInit.c */
+msgQueue *msgQueueInit(msgSpaceId externId, int queueIdx);
+/* queueOpen.c */
+void *msgQueueOpen(msgQueueId queueId);
+/* queueProtLock.c */
+int msgQueueProtLock(msgSpaceId externId, int queueIdx);
+/* queueProtUnlock.c */
+int msgQueueProtUnlock(msgSpaceId externId, int queueIdx);
+/* queueReadLock.c */
+int msgQueueReadLock(msgSpaceId externId, int queueIdx);
+/* queueReadTryLock.c */
+int msgQueueReadTryLock(msgSpaceId externId, int queueIdx);
+/* queueReadUnlock.c */
+int msgQueueReadUnlock(msgSpaceId externId, int queueIdx);
+/* queueRem.c */
+int msgQueueRem(msgQueue *queue, msgQueueElemId oldElemId);
+/* spaceClose.c */
+int msgSpaceClose(msgSpace *space);
+/* spaceCreate.c */
+msgSpace *msgSpaceCreate(msgSpaceId externId, int queueNb, int poolNb, msgPool *poolInfos);
+/* spaceDelete.c */
+int msgSpaceDelete(msgSpaceId externId);
+/* spaceListAdd.c */
+int msgSpaceListAdd(msgSpaceListElemId newElemId);
+/* spaceListClose.c */
+int msgSpaceListClose(msgSpaceList *list);
+/* spaceListElemClose.c */
+int msgSpaceListElemClose(msgSpaceListElem *listElem);
+/* spaceListElemCreate.c */
+int msgSpaceListElemCreate(msgSpaceListElemId listElemId, msgSpace *space);
+/* spaceListElemLink.c */
+/* spaceListElemOpen.c */
+void *msgSpaceListElemOpen(msgSpaceListElemId listElemId);
+/* spaceListFindId.c */
+int msgSpaceListFindId(msgSpaceId externId);
+int msgSpaceListElemFindId(msgSpaceListElemId elemId, msgSpaceId spaceId);
+/* spaceListInit.c */
+int msgSpaceListInit(void);
+/* spaceListLocking.c */
+int msgSpaceListLock(void);
+int msgSpaceListUnlock(void);
+/* spaceListOpen.c */
+void *msgSpaceListOpen(void);
+/* spaceListRem.c */
+int msgSpaceListRem(msgSpaceId spaceId);
+/* spaceOpen.c */
+msgSpace *msgSpaceOpen(msgSpaceId externId);
+/* spaceState.c */
+
+#endif

src/put.c

@@ -1,6 +1,7 @@
 #include "libnazgul.h"
 
-int msgPut(msgSpace * space,int queueIndex, void * addr){
+int msgPut(msgSpace * space, int queueIndex, void *addr)
+{
 	// retrouver le pool, buffer qui correspondent à l'addresse...
 	msgPoolData *poolDataTabAddr;
 	int poolIndex;
@@ -17,17 +18,12 @@ int msgPut(msgSpace * space,int queueIndex, void * addr){
 		NZG_ERROR("msgPoolDataTabOpen", space->poolDataTabId);
 		goto ERROR;
 	}
-  err = msgBufferGetProcAttach(
+	err = msgBufferGetProcAttach(poolDataTabAddr,
-	  	  poolDataTabAddr,
 				     space->poolNb,
-	  	  &poolIndex,
+				     &poolIndex, &bufferIndex, addr);
-	  	  &bufferIndex,
-	  	  addr
-	  	  );
 	if (err) {
 		//FIXME
 	}
-
 	// ouvrir la queue avec le bon index
 	msgQueueIdIntern(queueId, space->externId, queueIndex);
 
@@ -49,13 +45,11 @@ int msgPut(msgSpace * space,int queueIndex, void * addr){
 		NZG_ERROR("msgQueueElemClose", "");
 		goto ERROR;
 	}
-
 	//ajouter le message a la bonne file...
 	if (msgQueueAdd(queue, newElemId) < 0) {
 		NZG_ERROR("msgQueueAdd", newElemId);
 		goto ERROR;
 	}
-
 	// fermer la file
 	msgQueueClose(queue);
 	msgQueueProtUnlock(space->externId, queueIndex);
@@ -70,5 +64,3 @@ int msgPut(msgSpace * space,int queueIndex, void * addr){
  ERROR:
 	return -1;
 }
-
-

src/queueAdd.c

@@ -2,7 +2,8 @@
 
 // on ajoute en fin de queue...
 
-int msgQueueAdd(msgQueue * queue, msgQueueElemId newElemId){
+int msgQueueAdd(msgQueue * queue, msgQueueElemId newElemId)
+{
 	msgQueueElem *queueOldTailElem;
 	msgQueueElem *queueNewTailElem;
 

src/queueClose.c

@@ -1,7 +1,8 @@
 #include "libnazgul.h"
 #include "ids.h"
 
-int msgQueueClose(msgQueue * queue){
+int msgQueueClose(msgQueue * queue)
+{
 	msgQueueId qId;
 	strcpy(qId, queue->id);
 

src/queueDelete.c

@@ -1,6 +1,7 @@
 #include "libnazgul.h"
 
-int msgQueueDelete(msgQueueId externId,int queueIdx){
+int msgQueueDelete(msgQueueId externId, int queueIdx)
+{
 	msgQueue *queue;
 	msgQueueId queueId;
 	msgQueueSemId queueProtLockSemId;
@@ -31,5 +32,3 @@ int msgQueueDelete(msgQueueId externId,int queueIdx){
  ERROR:
 	return -1;
 }
-
-

src/queueElemClose.c

@@ -1,6 +1,7 @@
 #include "libnazgul.h"
 
-int msgQueueElemClose(msgQueueElem * queueElem){
+int msgQueueElemClose(msgQueueElem * queueElem)
+{
 	msgQueueElemId qId;
 	strcpy(qId, queueElem->id);
 

src/queueElemCreate.c

@@ -1,10 +1,9 @@
 #include "libnazgul.h"
 #include "ids.h"
 
-int msgQueueElemCreate(
+int msgQueueElemCreate(msgQueueElemId finalQueueElemId,
-	msgQueueElemId finalQueueElemId ,
+		       msgQueueId queueId, int counter)
-	msgQueueId queueId,
+{
-	int counter){
 	msgQueueElemId queueElemId;
 	int queueElemFd;
 

src/queueElemDelete.c

@@ -1,6 +1,7 @@
 #include "libnazgul.h"
 
-int msgQueueElemDelete(msgQueueElemId queueElemId){
+int msgQueueElemDelete(msgQueueElemId queueElemId)
+{
 	msgQueueElem *queueElem;
 	msgQueueElemId nextIdToDie;
 
@@ -16,7 +17,6 @@ int msgQueueElemDelete(msgQueueElemId queueElemId){
 		NZG_ERROR("msgQueueElemClose", queueElemId);
 		goto ERROR;
 	}
-
 	// on détruit l'élément
 	shm_unlink(queueElemId);
 

src/queueElemOpen.c

@@ -1,7 +1,8 @@
 #include "libnazgul.h"
 #include "ids.h"
 
-void * msgQueueElemOpen(msgQueueElemId queueElemId){
+void *msgQueueElemOpen(msgQueueElemId queueElemId)
+{
 	int queueElemFd;
 	void *queueElemAddr;
 
@@ -14,9 +15,7 @@ void * msgQueueElemOpen(msgQueueElemId queueElemId){
 	queueElemAddr = mmap(NULL,
 			     sizeof(msgQueueElem),
 			     PROT_READ | PROT_WRITE,
-	  MAP_SHARED,
+			     MAP_SHARED, queueElemFd, 0);
-	  queueElemFd,
-	  0);
 	if (queueElemAddr == MAP_FAILED) {
 		NZG_ERROR("mmap", queueElemId);
 		goto ERROR;

src/queueInit.c

@@ -1,7 +1,8 @@
 #include "libnazgul.h"
 #include "ids.h"
 
-msgQueue * msgQueueInit(msgSpaceId externId, int queueIdx) {
+msgQueue *msgQueueInit(msgSpaceId externId, int queueIdx)
+{
 	int queueFd;
 	msgQueue *queue;
 	sem_t *semProtectFd;
@@ -12,7 +13,6 @@ msgQueue * msgQueueInit(msgSpaceId externId, int queueIdx) {
 
 	queue = NULL;
 
-
 	msgQueueProtSemIdIntern(queueSemProtectId, externId, queueIdx);
 	msgQueueReadSemIdIntern(queueSemReadableId, externId, queueIdx);
 
@@ -23,7 +23,6 @@ msgQueue * msgQueueInit(msgSpaceId externId, int queueIdx) {
 		NZG_ERROR("sem_open", queueSemReadableId);
 		goto ERROR;
 	}
-	
 	// creation du semaphore de protection
 	semProtectFd = sem_open(queueSemProtectId,
 				O_CREAT | O_EXCL, SEM_DEFAULT_MODE, 0);
@@ -41,15 +40,16 @@ msgQueue * msgQueueInit(msgSpaceId externId, int queueIdx) {
 		return NULL;
 	}
 
-	queueFd = shm_open(queueId, O_RDWR|O_CREAT|O_EXCL|O_TRUNC, MSGSPACE_DEFAULT_MODE);
+	queueFd =
+	    shm_open(queueId, O_RDWR | O_CREAT | O_EXCL | O_TRUNC,
+		     MSGSPACE_DEFAULT_MODE);
 	if (queueFd == -1) {
 		NZG_ERROR("shm_open : queueInit", queueId);
 		return NULL;
 	}
 
 	if (ftruncate(queueFd, sizeof(msgQueue)) == -1) {
-	  fprintf( stderr, "Queue resizing failed: %s\n",
+		fprintf(stderr, "Queue resizing failed: %s\n", strerror(errno));
-		  strerror( errno ) );
 		return NULL;
 	}
 

src/queueOpen.c

@@ -1,7 +1,8 @@
 #include "libnazgul.h"
 #include "ids.h"
 
-void * msgQueueOpen(msgQueueId queueId){
+void *msgQueueOpen(msgQueueId queueId)
+{
 	int queueFd;
 	void *queueAddr;
 
@@ -13,10 +14,7 @@ void * msgQueueOpen(msgQueueId queueId){
 
 	queueAddr = mmap(NULL,
 			 sizeof(msgQueue),
-	  PROT_READ|PROT_WRITE,
+			 PROT_READ | PROT_WRITE, MAP_SHARED, queueFd, 0);
-	  MAP_SHARED,
-	  queueFd,
-	  0);
 	if (queueAddr == MAP_FAILED) {
 		NZG_ERROR("mmap", queueId);
 		goto ERROR;

src/queueProtLock.c

@@ -2,13 +2,16 @@
 #include "ids.h"
 
 #define DEBUG 0
-int msgQueueProtLock(msgSpaceId externId,int queueIdx){
+int msgQueueProtLock(msgSpaceId externId, int queueIdx)
+{
 	int semval;
 	sem_t *queueSemFd;
 	msgQueueSemId queueSemId;
 
 	msgQueueProtSemIdIntern(queueSemId, externId, queueIdx);
-  if (DEBUG) { printf("Locking %s\n",queueSemId);}
+	if (DEBUG) {
+		printf("Locking %s\n", queueSemId);
+	}
 	queueSemFd = sem_open(queueSemId, O_CREAT, SEM_DEFAULT_MODE, 1);
 	if (queueSemFd == SEM_FAILED) {
 		NZG_ERROR("sem_open", queueSemId);
@@ -21,7 +24,9 @@ int msgQueueProtLock(msgSpaceId externId,int queueIdx){
 	}
 	semval = 0;
 	sem_getvalue(queueSemFd, &semval);
- if (DEBUG) { printf("(AfterValue:%d)\n",semval); }
+	if (DEBUG) {
+		printf("(AfterValue:%d)\n", semval);
+	}
 
 	sem_close(queueSemFd);
 	sem_close(queueSemFd);
@@ -30,4 +35,3 @@ int msgQueueProtLock(msgSpaceId externId,int queueIdx){
  ERROR:
 	return -1;
 }
-

src/queueProtUnlock.c

@@ -3,13 +3,16 @@
 
 #define DEBUG 0
 
-int msgQueueProtUnlock(msgSpaceId externId,int queueIdx){
+int msgQueueProtUnlock(msgSpaceId externId, int queueIdx)
+{
 	int semval;
 	sem_t *queueSemFd;
 	msgQueueSemId queueSemId;
 
 	msgQueueProtSemIdIntern(queueSemId, externId, queueIdx);
-  if (DEBUG) { printf("Unlocking %s\n",queueSemId); }
+	if (DEBUG) {
+		printf("Unlocking %s\n", queueSemId);
+	}
 
 	queueSemFd = sem_open(queueSemId, O_CREAT, SEM_DEFAULT_MODE, 1);
 	if (queueSemFd == SEM_FAILED) {
@@ -23,7 +26,9 @@ int msgQueueProtUnlock(msgSpaceId externId,int queueIdx){
 	}
 	semval = 0;
 	sem_getvalue(queueSemFd, &semval);
-  if (DEBUG) { printf("(AfterValue:%d)\n",semval); }
+	if (DEBUG) {
+		printf("(AfterValue:%d)\n", semval);
+	}
 
 	sem_close(queueSemFd);
 
@@ -31,4 +36,3 @@ int msgQueueProtUnlock(msgSpaceId externId,int queueIdx){
  ERROR:
 	return -1;
 }
-

src/queueReadLock.c

@@ -3,13 +3,16 @@
 
 #define DEBUG 0
 
-int msgQueueReadLock(msgSpaceId externId,int queueIdx){
+int msgQueueReadLock(msgSpaceId externId, int queueIdx)
+{
 	int semval;
 	sem_t *queueSemFd;
 	msgQueueSemId queueSemId;
 
 	msgQueueReadSemIdIntern(queueSemId, externId, queueIdx);
-  if (DEBUG) { printf("Locking %s\n",queueSemId); }
+	if (DEBUG) {
+		printf("Locking %s\n", queueSemId);
+	}
 	queueSemFd = sem_open(queueSemId, O_CREAT, SEM_DEFAULT_MODE, 1);
 	if (queueSemFd == SEM_FAILED) {
 		NZG_ERROR("sem_open", queueSemId);
@@ -22,7 +25,9 @@ int msgQueueReadLock(msgSpaceId externId,int queueIdx){
 	}
 	semval = 0;
 	sem_getvalue(queueSemFd, &semval);
-  if (DEBUG) { printf("(AfterValue:%d)\n",semval); }
+	if (DEBUG) {
+		printf("(AfterValue:%d)\n", semval);
+	}
 
 	sem_close(queueSemFd);
 
@@ -30,4 +35,3 @@ int msgQueueReadLock(msgSpaceId externId,int queueIdx){
  ERROR:
 	return -1;
 }
-

src/queueReadTryLock.c

@@ -3,7 +3,8 @@
 
 #define DEBUG 0
 
-int msgQueueReadTryLock(msgSpaceId externId,int queueIdx){
+int msgQueueReadTryLock(msgSpaceId externId, int queueIdx)
+{
 	int semval;
 	sem_t *queueSemFd;
 	msgQueueSemId queueSemId;
@@ -19,10 +20,14 @@ int msgQueueReadTryLock(msgSpaceId externId,int queueIdx){
 		NZG_ERROR("sem_wait", queueSemId);
 		goto ERROR;
 	}
-  if (DEBUG) { printf("Locking %s\n",queueSemId); }
+	if (DEBUG) {
+		printf("Locking %s\n", queueSemId);
+	}
 	semval = 0;
 	sem_getvalue(queueSemFd, &semval);
-  if (DEBUG) { printf("(AfterValue:%d)\n",semval); }
+	if (DEBUG) {
+		printf("(AfterValue:%d)\n", semval);
+	}
 
 	sem_close(queueSemFd);
 
@@ -30,4 +35,3 @@ int msgQueueReadTryLock(msgSpaceId externId,int queueIdx){
  ERROR:
 	return -1;
 }
-

src/queueReadUnlock.c

@@ -3,13 +3,16 @@
 
 #define DEBUG 0
 
-int msgQueueReadUnlock(msgSpaceId externId,int queueIdx){
+int msgQueueReadUnlock(msgSpaceId externId, int queueIdx)
+{
 	int semval;
 	sem_t *queueSemFd;
 	msgQueueSemId queueSemId;
 
 	msgQueueReadSemIdIntern(queueSemId, externId, queueIdx);
-  if (DEBUG) { printf("Unlocking %s\n",queueSemId); }
+	if (DEBUG) {
+		printf("Unlocking %s\n", queueSemId);
+	}
 	queueSemFd = sem_open(queueSemId, O_CREAT, SEM_DEFAULT_MODE, 1);
 	if (queueSemFd == SEM_FAILED) {
 		NZG_ERROR("sem_open", queueSemId);
@@ -22,8 +25,9 @@ int msgQueueReadUnlock(msgSpaceId externId,int queueIdx){
 	}
 	semval = 0;
 	sem_getvalue(queueSemFd, &semval);
-  if (DEBUG) { printf("(AfterValue:%d)\n",semval); }
+	if (DEBUG) {
-
+		printf("(AfterValue:%d)\n", semval);
+	}
 
 	sem_close(queueSemFd);
 
@@ -31,4 +35,3 @@ int msgQueueReadUnlock(msgSpaceId externId,int queueIdx){
  ERROR:
 	return -1;
 }
-

src/queueRem.c

@@ -2,10 +2,10 @@
 
 // l'id de l'element enlevé vas dans oldElemId
 
-int msgQueueRem(msgQueue * queue, msgQueueElemId oldElemId){
+int msgQueueRem(msgQueue * queue, msgQueueElemId oldElemId)
+{
 	msgQueueElem *queueOldHeadElem;
 
-	
 	if (strcmp(queue->headId, queue->id) == 0) {
 		NZG_ERROR("msgQueueElemRem : Empty queue", queue->id);
 		goto ERROR;
@@ -17,7 +17,6 @@ int msgQueueRem(msgQueue * queue, msgQueueElemId oldElemId){
 		NZG_ERROR("msgQueueElemOpen", oldElemId);
 		goto ERROR;
 	}
-
 	// on indique à la queue le nouveau premier element
 	strcpy(queue->headId, queueOldHeadElem->next);
 	if (strcmp(queueOldHeadElem->next, oldElemId) == 0) {

src/spaceClose.c

@@ -1,6 +1,7 @@
 #include "libnazgul.h"
 
-int msgSpaceClose(msgSpace * space){
+int msgSpaceClose(msgSpace * space)
+{
 	msgSpaceId spaceId;
 	strcpy(spaceId, space->id);
 

src/spaceCreate.c

@@ -4,8 +4,8 @@
 /* prototypes des fonctions annexes à ne pas exporter */
 int msgSpaceIdIntern(msgSpaceId dest, const msgSpaceId src);
 int msgPoolDataIdIntern(msgSpaceId dest, const msgSpaceId src);
-int msgPoolDataTabSemIdIntern(
+int msgPoolDataTabSemIdIntern(msgPoolSemId destSemId,
-	msgPoolSemId destSemId,const msgSpaceId externId);
+			      const msgSpaceId externId);
 /*
  * spaceId : identifiant externe de l'espace de msg
  * queueNb : nombre de files de messages
@@ -13,11 +13,9 @@ int msgPoolDataTabSemIdIntern(
  * queueNbCar : tableau de caracteristiques des different pool
  */
 
-msgSpace * msgSpaceCreate(
+msgSpace *msgSpaceCreate(msgSpaceId externId,
-	msgSpaceId externId, 
+			 int queueNb, int poolNb, msgPool * poolInfos)
-	int queueNb, 
+{
-	int poolNb, 
-	msgPool * poolInfos ){
 	msgSpaceId nzgId;
 	/* msgSpaceList mSList;  */
 	int mSFd;		// shm file descriptor
@@ -72,11 +70,9 @@ msgSpace * msgSpaceCreate(
 	printf("spaceListUnlock ok\n");
 
 	fprintf(stderr, "Creating msgSpace with id : %s\n", nzgId);
-  mSFd=shm_open(
+	mSFd = shm_open(nzgId,
-	  nzgId,
 			O_RDWR | O_CREAT | O_EXCL | O_TRUNC,
-	  MSGSPACE_DEFAULT_MODE
+			MSGSPACE_DEFAULT_MODE);
-	  );
 	if (mSFd == -1) {
 		NZG_ERROR("shm_open : msgSpace creation", nzgId);
 		goto ERROR;
@@ -90,14 +86,14 @@ msgSpace * msgSpaceCreate(
 
 	/* Map the memory object */
 	space = mmap(0, sizeof(*space),
-	  PROT_READ | PROT_WRITE,
+		     PROT_READ | PROT_WRITE, MAP_SHARED, mSFd, 0);
-	  MAP_SHARED, mSFd, 0 );
 	if (space == MAP_FAILED) {
 		NZG_ERROR("mmap", nzgId);
 		goto ERROR;
 	}
 
-  printf( "CREAT: msgSpace mapped to 0x%08lx in %d\n", (long)space,(int)getpid());
+	printf("CREAT: msgSpace mapped to 0x%08lx in %d\n", (long)space,
+	       (int)getpid());
 
 	/* on ferme le descripteur du fichier */
 	close(mSFd);
@@ -142,14 +138,18 @@ msgSpace * msgSpaceCreate(
 		poolDataTabAddr[i].bufferSize = poolInfos[i].bufferSize;
 		poolDataTabAddr[i].allocDispBuffer = 0;
 
-	if (msgBufferInfoTabIdIntern(bufferInfoTabId,externId,i) == -1){
+		if (msgBufferInfoTabIdIntern(bufferInfoTabId, externId, i) ==
-	  fprintf( stderr, "msgBufferInfoTabId creation failed for id %s\n",
+		    -1) {
+			fprintf(stderr,
+				"msgBufferInfoTabId creation failed for id %s\n",
 				(char *)poolId);
 			return NULL;
 		}
 		strcpy(poolDataTabAddr[i].bufferInfoTabId, bufferInfoTabId);
-	printf("buffIfoTab %d name : %s\n",i,poolDataTabAddr[i].bufferInfoTabId);
+		printf("buffIfoTab %d name : %s\n", i,
-	msgBufferInfoTabCreate(externId,poolDataTabAddr,i,poolInfos[i].bufferNb);
+		       poolDataTabAddr[i].bufferInfoTabId);
+		msgBufferInfoTabCreate(externId, poolDataTabAddr, i,
+				       poolInfos[i].bufferNb);
 
 		if (msgPoolIdIntern(poolId, externId, i) == -1) {
 			fprintf(stderr, "msgPoolId creation failed for id %s\n",
@@ -157,17 +157,20 @@ msgSpace * msgSpaceCreate(
 			return NULL;
 		}
 		strcpy(poolDataTabAddr[i].poolId, poolId);
-	msgPoolCreate(externId,i,poolInfos[i].bufferNb,poolInfos[i].bufferSize);
+		msgPoolCreate(externId, i, poolInfos[i].bufferNb,
+			      poolInfos[i].bufferSize);
 
 	}
 
 	/* on crée queueNb files de messages */
 	printf("Creating queues:\n");
 	for (i = 0; i < queueNb; i++) {
-	printf("- queue %i...",i); fflush(stdout);
+		printf("- queue %i...", i);
+		fflush(stdout);
 		if (msgQueueInit(space->externId, i) < 0) {
 			printf("fail.\n");
-	  NZG_ERROR("msgQueueInit : queue ?? for",space->externId);
+			NZG_ERROR("msgQueueInit : queue ?? for",
+				  space->externId);
 			goto ERROR;
 		}
 		printf("ok.\n");
@@ -192,6 +195,3 @@ msgSpace * msgSpaceCreate(
  ERROR:
 	return NULL;
 }
-
-
-

src/spaceDelete.c

@@ -4,10 +4,11 @@
 /* prototypes des fonctions annexes à ne pas exporter */
 int msgSpaceIdIntern(msgSpaceId dest, const msgSpaceId src);
 int msgPoolDataIdIntern(msgSpaceId dest, const msgSpaceId src);
-int msgPoolDataTabSemIdIntern(
+int msgPoolDataTabSemIdIntern(msgPoolSemId destSemId,
-	msgPoolSemId destSemId,const msgSpaceId externId);
+			      const msgSpaceId externId);
 
-int msgSpaceDelete(msgSpaceId externId){
+int msgSpaceDelete(msgSpaceId externId)
+{
 	//int shmId;
 	msgSpaceId nzgId;
 	msgSpace *space;
@@ -64,4 +65,3 @@ int msgSpaceDelete(msgSpaceId externId){
  ERROR:
 	return -1;
 }
-

src/spaceListAdd.c

@@ -3,7 +3,8 @@
 // ajoute un element en début de liste.
 // fait pointer l'ancien dernier vers lui
 // il s'enregistre en tant que dernier chez la liste
-int msgSpaceListAdd(msgSpaceListElemId newElemId){
+int msgSpaceListAdd(msgSpaceListElemId newElemId)
+{
 	msgSpaceListElem *listOldTailElem;
 	msgSpaceListElem *listNewTailElem;
 	msgSpaceList *list;

src/spaceListClose.c

@@ -1,7 +1,8 @@
 #include "libnazgul.h"
 #include "ids.h"
 
-int msgSpaceListClose(msgSpaceList * list){
+int msgSpaceListClose(msgSpaceList * list)
+{
 
 	msgSpaceListId spaceListId;
 	strcpy(spaceListId, DEFAULT_MSGSPACELISTID);

src/spaceListElemCreate.c

@@ -2,9 +2,7 @@
 #include "ids.h"
 
 // cree un nouvel elemen
-int msgSpaceListElemCreate(
+int msgSpaceListElemCreate(msgSpaceListElemId listElemId, msgSpace * space)
-	msgSpaceListElemId listElemId,
-	msgSpace * space)
 {
 
 	int listElemFd;
@@ -35,9 +33,7 @@ int msgSpaceListElemCreate(
 	strcpy(listElem->next, listElemId);
 	strcpy(listElem->spaceId, space->id);
 	printf("[ ListElem : id %s,next: %s, Sid: %s ]\n",
-	  listElem->id,
+	       listElem->id, listElem->next, listElem->spaceId);
-	  listElem->next,
-	  listElem->spaceId);
 	if (msgSpaceListElemClose(listElem) < 0) {
 		NZG_ERROR("msgSpaceListElemClose", listElemId);
 	}

src/spaceListElemLink.c

@@ -2,6 +2,5 @@
 
 // modifie l'element suivant de l'element choisi
 // et le fait pointer sur un nouvel ID
-int msgSpaceListElemLinkNext(msgSpaceListElemId current,msgSpaceListElemId next);
+int msgSpaceListElemLinkNext(msgSpaceListElemId current,
-
+			     msgSpaceListElemId next);
-

src/spaceListElemOpen.c

@@ -2,7 +2,8 @@
 #include "ids.h"
 
 // cree un nouvel elemen
-void * msgSpaceListElemOpen(msgSpaceListElemId listElemId){
+void *msgSpaceListElemOpen(msgSpaceListElemId listElemId)
+{
 	int listElemFd;
 	void *listElemAddr;
 
@@ -14,10 +15,7 @@ void * msgSpaceListElemOpen(msgSpaceListElemId listElemId){
 
 	listElemAddr = mmap(NULL,
 			    sizeof(msgQueueElem),
-	  PROT_READ|PROT_WRITE,
+			    PROT_READ | PROT_WRITE, MAP_SHARED, listElemFd, 0);
-	  MAP_SHARED,
-	  listElemFd,
-	  0);
 
 	if (listElemAddr == MAP_FAILED) {
 		NZG_ERROR("mmap", listElemId);
@@ -29,5 +27,4 @@ void * msgSpaceListElemOpen(msgSpaceListElemId listElemId){
  ERROR:
 	return NULL;
 
-
 };

src/spaceListFindId.c

@@ -2,7 +2,8 @@
 
 #define DEBUG 1
 
-int msgSpaceListFindId(msgSpaceId externId){
+int msgSpaceListFindId(msgSpaceId externId)
+{
 	msgSpaceList *list;
 	msgSpaceId spaceId;
 	msgSpaceListElemId listHeadElemId;
@@ -15,15 +16,21 @@ int msgSpaceListFindId(msgSpaceId externId){
 		NZG_ERROR("msgSpaceListOpen", "");
 		goto ERROR;
 	}
-  if (DEBUG) { printf("Before ListStrCpy\n"); }
+	if (DEBUG) {
+		printf("Before ListStrCpy\n");
+	}
 	strcpy(listHeadElemId, list->headId);
 	strcpy(listTailElemId, list->tailId);
 	strcpy(listId, list->id);
-  if (DEBUG) { printf("After ListStrCpy\n"); }
+	if (DEBUG) {
+		printf("After ListStrCpy\n");
+	}
 	if ((strcmp(listHeadElemId, listId) == 0)
 	    && strcmp(listTailElemId, listId) == 0) {
 		// si la liste est vide
-	if (DEBUG) { printf("SpaceList : vide\n"); }
+		if (DEBUG) {
+			printf("SpaceList : vide\n");
+		}
 		return 1;
 	} else {
 		return msgSpaceListElemFindId(listHeadElemId, spaceId);
@@ -37,7 +44,8 @@ ERROR:
 	return -1;
 }
 
-int msgSpaceListElemFindId(msgSpaceListElemId elemId,msgSpaceId spaceId){
+int msgSpaceListElemFindId(msgSpaceListElemId elemId, msgSpaceId spaceId)
+{
 	msgSpaceListElem *listElem;
 	msgSpaceListElemId listElemIdNext;
 	msgSpaceId currentElemSpaceId;
@@ -75,5 +83,3 @@ int msgSpaceListElemFindId(msgSpaceListElemId elemId,msgSpaceId spaceId){
  ERROR:
 	return -1;
 }
-
-

src/spaceListInit.c

@@ -1,7 +1,8 @@
 #include "libnazgul.h"
 #include "ids.h"
 
-int msgSpaceListInit(){
+int msgSpaceListInit()
+{
 	int spaceListFd;
 	sem_t *spaceListSemFd;
 	msgSpaceList *list;
@@ -22,12 +23,9 @@ int msgSpaceListInit(){
 		}
 	}
 
-
-
 	/*Fait un segment de memoir partager sur espace de listelement */
 	spaceListFd = shm_open(spaceListId,
-	  O_RDWR|O_CREAT|O_EXCL|O_TRUNC,
+			       O_RDWR | O_CREAT | O_EXCL | O_TRUNC, 0666);
-	  0666);
 	if (spaceListFd == -1) {
 		spaceListFd = shm_open(spaceListId, O_RDWR, 0666);
 		if (spaceListFd == -1) {
@@ -73,4 +71,3 @@ EXISTING:
 
 	return 0;
 };
-

src/spaceListLocking.c

@@ -1,9 +1,9 @@
 #include "libnazgul.h"
 
-
 // verouille le semaphore de la liste
 
-int msgSpaceListLock(){
+int msgSpaceListLock()
+{
 	sem_t *msgSpaceListSemFd;
 	msgSpaceListSemId spaceListSemId;
 	strcpy(spaceListSemId, DEFAULT_MSGSPACELISTSEMID);
@@ -33,14 +33,13 @@ ERROR:
 	return -1;
 }
 
-
 // deverouille le semaphore de la liste
-int msgSpaceListUnlock(){
+int msgSpaceListUnlock()
+{
 	sem_t *msgSpaceListSemFd;
 	msgSpaceListSemId spaceListSemId;
 	strcpy(spaceListSemId, DEFAULT_MSGSPACELISTSEMID);
 
-
 	/*Ouverture dun semaphore */
 	msgSpaceListSemFd = sem_open(spaceListSemId, O_CREAT, 0666, 0);
 	if (msgSpaceListSemFd == SEM_FAILED) {
@@ -48,14 +47,12 @@ int msgSpaceListUnlock(){
 		goto ERROR;
 	}
 
-
 	/*Relachement du semaphore */
 	if (sem_post(msgSpaceListSemFd) == -1) {
 		NZG_ERROR("sem_relache", spaceListSemId);
 		goto ERROR;
 	}
 
-
 	/*    Ferme le semaphore */
 	if (sem_close(msgSpaceListSemFd) == -1) {
 		NZG_ERROR("sem_close", spaceListSemId);
@@ -66,4 +63,3 @@ int msgSpaceListUnlock(){
  ERROR:
 	return -1;
 };
-

src/spaceListOpen.c

@@ -1,7 +1,8 @@
 #include "libnazgul.h"
 #include "ids.h"
 
-void * msgSpaceListOpen(){
+void *msgSpaceListOpen()
+{
 	int listFd;
 	void *listAddr;
 
@@ -16,10 +17,7 @@ void * msgSpaceListOpen(){
 
 	listAddr = mmap(NULL,
 			sizeof(msgSpaceList),
-	  PROT_READ|PROT_WRITE,
+			PROT_READ | PROT_WRITE, MAP_SHARED, listFd, 0);
-	  MAP_SHARED,
-	  listFd,
-	  0);
 	if (listAddr == MAP_FAILED) {
 		NZG_ERROR("mmap", spaceListId);
 		goto ERROR;

src/spaceListRem.c

@@ -2,7 +2,8 @@
 
 #define DEBUG 1
 
-int msgSpaceListRem(msgSpaceId spaceId){
+int msgSpaceListRem(msgSpaceId spaceId)
+{
 	msgSpaceList *list;
 	msgSpaceListElemId listHeadElemId;
 	msgSpaceListElemId listTailElemId;
@@ -21,14 +22,20 @@ int msgSpaceListRem(msgSpaceId spaceId){
 		NZG_ERROR("msgSpaceListOpen", "");
 		goto ERROR;
 	}
-  if (DEBUG) { printf("Before ListStrCpy\n"); }
+	if (DEBUG) {
+		printf("Before ListStrCpy\n");
+	}
 	strcpy(listHeadElemId, list->headId);
 	strcpy(listTailElemId, list->tailId);
 	strcpy(listId, list->id);
-  if (DEBUG) { printf("After ListStrCpy\n"); }
+	if (DEBUG) {
+		printf("After ListStrCpy\n");
+	}
 	if ((strcmp(listHeadElemId, listId) == 0)
 	    && strcmp(listTailElemId, listId) == 0) {
-	if (DEBUG) { printf("SpaceList : vide\n"); }
+		if (DEBUG) {
+			printf("SpaceList : vide\n");
+		}
 		return 1;
 	} else {
 		bool found = false;
@@ -67,22 +74,34 @@ int msgSpaceListRem(msgSpaceId spaceId){
 					if (strcmp(prevElemId, currElemId) == 0) {
 						// si on est en début de liste (prev=current)
 						// - la tete de liste pointe sur le suivant
-			strcpy(list->headId,nextElemId);
+						strcpy(list->headId,
+						       nextElemId);
 					} else {
-			if (strcmp(currElemId,nextElemId)==0){
+						if (strcmp
+						    (currElemId,
+						     nextElemId) == 0) {
 							// si on est en find de liste (current=next)
 							// - on fait pointer la queue de liste sur le précédent
-			  strcpy(list->tailId,prevElemId);
+							strcpy(list->tailId,
+							       prevElemId);
 							// - on fait pointer le précédent sur lui-meme
-			  prevElem=msgSpaceListElemOpen(prevElemId);
+							prevElem =
-			  strcpy(prevElem->next,prevElemId);
+							    msgSpaceListElemOpen
-			  msgSpaceListElemClose(prevElem);
+							    (prevElemId);
+							strcpy(prevElem->next,
+							       prevElemId);
+							msgSpaceListElemClose
+							    (prevElem);
 						} else {
 							// on est en milieu de liste
 							// - on fait pointer le précédent sur le suivant
-			  prevElem=msgSpaceListElemOpen(prevElemId);
+							prevElem =
-			  strcpy(prevElem->next,nextElemId);
+							    msgSpaceListElemOpen
-			  msgSpaceListElemClose(prevElem);
+							    (prevElemId);
+							strcpy(prevElem->next,
+							       nextElemId);
+							msgSpaceListElemClose
+							    (prevElem);
 						}
 					}
 					// - on détruit l'actuel
@@ -107,4 +126,3 @@ int msgSpaceListRem(msgSpaceId spaceId){
  ERROR:
 	return -1;
 }
-

src/spaceOpen.c

@@ -5,8 +5,8 @@
 int msgSpaceIdIntern(msgSpaceId dest, const msgSpaceId src);
 int msgPoolDataIdIntern(msgSpaceId dest, const msgSpaceId src);
 
-
+msgSpace *msgSpaceOpen(msgSpaceId externId)
-msgSpace * msgSpaceOpen(msgSpaceId externId){
+{
 	int shmFd;
 	msgSpaceId nzgId;
 	msgSpace *mSAddr;
@@ -17,10 +17,11 @@ msgSpace * msgSpaceOpen(msgSpaceId externId){
 		perror("shm_open");
 		return NULL;
 	}
-  mSAddr=mmap(NULL,sizeof(msgSpace),PROT_READ|PROT_WRITE,MAP_SHARED,shmFd,(off_t)0);
+	mSAddr =
+	    mmap(NULL, sizeof(msgSpace), PROT_READ | PROT_WRITE, MAP_SHARED,
+		 shmFd, (off_t) 0);
 
-  printf( "OPEN: msgSpace mapped to %p in %d\n", (void *)mSAddr,(int)getpid());
+	printf("OPEN: msgSpace mapped to %p in %d\n", (void *)mSAddr,
+	       (int)getpid());
 	return mSAddr;
 }
-
-

src/spaceState.c

@@ -1,2 +1 @@
 #include "libnazgul.h"
-

test/test_create_delete.c

@@ -6,7 +6,8 @@
 
 #include "libnazgul.h"
 
-int main(void) {
+int main(void)
+{
 	//    msgSpace mS=0;
 
 	pid_t pid;
@@ -35,8 +36,6 @@ int main(void) {
 
 	pid = fork();
 
-  
-  
 	if (pid == 0) {
 		mSPAC = msgSpaceOpen(testId);
 		sleep(5);

test/test_msgSpaceState.c

@@ -6,11 +6,13 @@
 
 #include "libnazgul.h"
 
-void usage(char * myname){
+void usage(char *myname)
+{
 	printf("Usage: %s [--all | msgSpaceId1 msgSpaceId2 ... ]\n", myname);
 }
 
-int about(char * spaceId){
+int about(char *spaceId)
+{
 	msgPoolDataTabSemId ressourceSemId;
 	sem_t *ressourceSemFd;
 	int i;
@@ -33,27 +35,35 @@ int about(char * spaceId){
 				// on lit les informations sur le msgSpace
 				// les pool
 				for (i = 0; i < space->poolNb; i++) {
-		  msgPoolSemIdIntern(ressourceSemId,space->externId,i);
+					msgPoolSemIdIntern(ressourceSemId,
-		  ressourceSemFd = sem_open(ressourceSemId,O_CREAT,SEM_DEFAULT_MODE,0);
+							   space->externId, i);
+					ressourceSemFd =
+					    sem_open(ressourceSemId, O_CREAT,
+						     SEM_DEFAULT_MODE, 0);
 					if (ressourceSemFd == SEM_FAILED) {
-			NZG_ERROR("sem_open",ressourceSemId);
+						NZG_ERROR("sem_open",
+							  ressourceSemId);
 						goto ERROR;
 					}
-		  if (sem_getvalue(ressourceSemFd, &ressourceSemVal) < 0){ 
+					if (sem_getvalue
-			NZG_ERROR("sem_getvalue",ressourceSemId);
+					    (ressourceSemFd,
+					     &ressourceSemVal) < 0) {
+						NZG_ERROR("sem_getvalue",
+							  ressourceSemId);
 						goto ERROR;
 					}
 					msgPoolDataTabLock(space);
 					poolDataTab = msgPoolDataTabOpen(space);
 					// donner le nombre de buffer disponibles
-		  printf("- %d/%d free buffers in pool #%d\n",
+					printf
+					    ("- %d/%d free buffers in pool #%d\n",
 					     ressourceSemVal,
-			  poolDataTab[i].bufferNb,
+					     poolDataTab[i].bufferNb, i);
-			  i);
 					msgPoolDataTabClose(space, poolDataTab);
 					msgPoolDataTabUnlock(space);
 					if (sem_close(ressourceSemFd) < 0) {
-			NZG_ERROR("sem_getvalue",ressourceSemId);
+						NZG_ERROR("sem_getvalue",
+							  ressourceSemId);
 						goto ERROR;
 					}
 					// pour chaque buffer, dire s'il est libre ou pas
@@ -74,7 +84,8 @@ ERROR:
 	return -1;
 }
 
-int main(int argc,char **argv){
+int main(int argc, char **argv)
+{
 	printf("Args %d\n", argc);
 	if (argc < 2) {
 		usage(argv[0]);

test/test_put_get_mono.c

@@ -6,7 +6,8 @@
 
 #include "libnazgul.h"
 
-int main(void) {
+int main(void)
+{
 	//    msgSpace mS=0;
 
 	msgSpaceId testId;
@@ -38,12 +39,13 @@ int main(void) {
 	montext = msgAllocate(mSPAC, 1, 280, 0);
 	*montext = 42;
 	printf("### test Valeur0 %d ###\n", (int)*montext);
-  printf("Put..."); fflush(stdout);
+	printf("Put...");
+	fflush(stdout);
 	msgPut(mSPAC, 0, montext);
 	printf("put-ok\n");
 
-
+	printf("Get...");
-  printf("Get..."); fflush(stdout);
+	fflush(stdout);
 	montext = msgGet(mSPAC, 0, 0);
 	printf("get-ok\n");
 	printf("### test Reception %d ###\n", (int)*montext);

test/test_put_get_multi.c

@@ -6,7 +6,8 @@
 
 #include "libnazgul.h"
 
-int main(void) {
+int main(void)
+{
 	//    msgSpace mS=0;
 
 	msgSpaceId testId;
@@ -38,12 +39,14 @@ if (pid==0){
 		montext = msgAllocate(mSPAC, 1, 280, 0);
 		*montext = 42;
 		printf("### test Valeur0 %d ###\n", (int)*montext);
-  printf("Put1..."); fflush(stdout);
+		printf("Put1...");
+		fflush(stdout);
 		msgPut(mSPAC, 0, montext);
 		printf("put1-ok\n");
 	} else {
 		mSPAC = msgSpaceOpen(testId);
-  printf("Get..."); fflush(stdout);
+		printf("Get...");
+		fflush(stdout);
 		montext = msgGet(mSPAC, 0, 0);
 		printf("get-ok\n");
 		printf("### test Reception %d ###\n", (int)*montext);