Apply indent with -linux style

src/allocate.c

@@ -9,12 +9,9 @@
 
 /* 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,
+	void *resultAddr = NULL;
-	int option
-	){
-  void * resultAddr=NULL;
 	int bufferFreeSize;
 	int i;
 	msgPoolId resultPoolId;
@@ -24,23 +21,21 @@ void * msgAllocate(msgSpace *space,
 	int idxPoolOptimum;
 	bool gotRessourceSem;
 	msgPoolDataTabSemId ressourceSemId;
-  sem_t * ressourceSemFd;
+	sem_t *ressourceSemFd;
 	int ressourceSemVal;
 	int nbLockedSem;
 	float minPoolCoef;
 	int selectedPoolIndex;
 	int bufferFreeIndex;
-  msgPoolData * mSPoolDataTabAddr;
+	msgPoolData *mSPoolDataTabAddr;
 
+	selectedPoolIndex = -1;
 
-  selectedPoolIndex=-1;
+	mSPoolDataTabAddr = msgPoolDataTabOpen(space);
-
+	if (mSPoolDataTabAddr == NULL) {
-
+		NZG_ERROR("msgPoolDataTabOpen", space->poolDataTabId);
-mSPoolDataTabAddr=msgPoolDataTabOpen(space);
-if (mSPoolDataTabAddr==NULL){
-  NZG_ERROR("msgPoolDataTabOpen",space->poolDataTabId);
 		goto ERROR;
-}
+	}
 /*
   // verifier le premier arg du shm_open 
   mSPoolDataTabFd=shm_open(space->poolDataTabId,
@@ -64,68 +59,82 @@ if (mSPoolDataTabAddr==NULL){
 	return NULL;
   }
 */
-  gotRessourceSem=false;
+	gotRessourceSem = false;
 
 	/* initialisation des coefs */
-  for (i=0;i<(space->poolNb);i++){
+	for (i = 0; i < (space->poolNb); i++) {
-	semPoolCoef[i]=-1;
+		semPoolCoef[i] = -1;
 	}
 
-  nbLockedSem=0;
+	nbLockedSem = 0;
-  if ( pool == ANYPOOL){
+	if (pool == ANYPOOL) {
-	fprintf(stderr,"[ ALLOCATION ANYPOOL : %d ]\n",(int)getpid());
+		fprintf(stderr, "[ ALLOCATION ANYPOOL : %d ]\n", (int)getpid());
 		// choisir le pool au hasard (ou presque)
-	for(i=0; i<(space->poolNb); i++) {
+		for (i = 0; i < (space->poolNb); i++) {
-	  printf("- boucle %d\n",i); fflush(stdout);
+			printf("- boucle %d\n", i);
-	  if(mSPoolDataTabAddr[i].bufferSize >= taille) {
+			fflush(stdout);
-		printf("( buffSize > taille )\n"); fflush(stdout);
+			if (mSPoolDataTabAddr[i].bufferSize >= taille) {
+				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);
-		if (ressourceSemFd == SEM_FAILED){ 
+				ressourceSemFd =
-		  NZG_ERROR("sem_open",ressourceSemId);
+				    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);
+				printf("RESSOURCESEMVAL %d\n", ressourceSemVal);
-		if (ressourceSemVal <= 0){
+				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) {
+				if (sem_trywait(ressourceSemFd) == 0) {
 					printf("got try_wait\n");
 					/* choisir la 1ere pool de taille plus grande 
 					 * libre si possible */
-		  gotRessourceSem=true;
+					gotRessourceSem = true;
-		  selectedPoolIndex=i;
+					selectedPoolIndex = i;
 					break;
 				}
-		if(	sem_close(ressourceSemFd) <0){
+				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");
-	  minPoolCoef= semPoolCoef[0];
+			minPoolCoef = semPoolCoef[0];
 			idxPoolOptimum = 0;
 			/* 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++) {
+			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];
@@ -133,40 +142,40 @@ if (mSPoolDataTabAddr==NULL){
 				}
 			}
 
-	  if (minPoolCoef == -1){
+			if (minPoolCoef == -1) {
 				/* il n'y a aucune pool dont la taille satisfait la demande */
 				return NULL;
 			} else {
-		selectedPoolIndex=idxPoolOptimum;
+				selectedPoolIndex = idxPoolOptimum;
 			}
-	  printf("Optimum : %d\n",selectedPoolIndex);
+			printf("Optimum : %d\n", selectedPoolIndex);
 		}
-  }else {
+	} else {
-	fprintf(stderr,"[ ALLOCATION : %d ]\n",(int)getpid());
+		fprintf(stderr, "[ ALLOCATION : %d ]\n", (int)getpid());
-	selectedPoolIndex=pool;
+		selectedPoolIndex = pool;
 	}
 
-  if (!gotRessourceSem){
+	if (!gotRessourceSem) {
-	msgPoolSemIdIntern(ressourceSemId,space->externId,selectedPoolIndex);
+		msgPoolSemIdIntern(ressourceSemId, space->externId,
-	ressourceSemFd=sem_open(ressourceSemId,O_CREAT,SEM_DEFAULT_MODE,0);
+				   selectedPoolIndex);
-	if(ressourceSemFd==SEM_FAILED){
+		ressourceSemFd =
-	  NZG_ERROR("sem_open",ressourceSemId);
+		    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);
 
-	printf("SemWait... %s : %d\n",ressourceSemId,ressourceSemVal);
+		printf("SemWait... %s : %d\n", ressourceSemId, ressourceSemVal);
-	if (sem_wait(ressourceSemFd) < 0){
+		if (sem_wait(ressourceSemFd) < 0) {
-	  NZG_ERROR("sem_wait",ressourceSemId);
+			NZG_ERROR("sem_wait", ressourceSemId);
 			sem_close(ressourceSemFd);
 			return NULL;
 		}
-	printf("Passed %s\n",ressourceSemId);
+		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,42 +183,43 @@ if (mSPoolDataTabAddr==NULL){
 
 	/* on modifie maintenant les données */
 	/* - on récupere l'index du premier buffer libre */
-  bufferFreeIndex = msgBufferGetFreeIndex(mSPoolDataTabAddr,selectedPoolIndex);
+	bufferFreeIndex =
-  if (bufferFreeIndex < 0){
+	    msgBufferGetFreeIndex(mSPoolDataTabAddr, selectedPoolIndex);
+	if (bufferFreeIndex < 0) {
 		// aucun buffer libre ?
-	NZG_ERROR("msgBufferGetFreeIndex","");
+		NZG_ERROR("msgBufferGetFreeIndex", "");
 		goto ERROR;
 	}
-  printf("Buffer selected : %d,%d\n",selectedPoolIndex,bufferFreeIndex);
+	printf("Buffer selected : %d,%d\n", selectedPoolIndex, bufferFreeIndex);
 	/* mapper le buffer libre dans l'esp addr du proc */
-  strcpy(resultPoolId,mSPoolDataTabAddr[selectedPoolIndex].poolId);
+	strcpy(resultPoolId, mSPoolDataTabAddr[selectedPoolIndex].poolId);
 
-  bufferFreeSize=mSPoolDataTabAddr[selectedPoolIndex].bufferSize;
+	bufferFreeSize = mSPoolDataTabAddr[selectedPoolIndex].bufferSize;
 	printf("BufferSize : %d\n", bufferFreeSize);
 
- resultAddr=msgBufferMap(mSPoolDataTabAddr,selectedPoolIndex,bufferFreeIndex);
+	resultAddr =
- if (resultAddr==NULL){
+	    msgBufferMap(mSPoolDataTabAddr, selectedPoolIndex, bufferFreeIndex);
-   NZG_ERROR("msgBufferMap",mSPoolDataTabAddr[selectedPoolIndex].poolId);
+	if (resultAddr == NULL) {
+		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 */
- msgPoolDataTabClose(space,mSPoolDataTabAddr);
+	msgPoolDataTabClose(space, mSPoolDataTabAddr);
 	msgPoolDataTabUnlock(space);
 
- printf( "alloc de %p\n", (void *)resultAddr);
+	printf("alloc de %p\n", (void *)resultAddr);
 	return resultAddr;
 
-ERROR:
+ ERROR:
- NZG_ERROR("msgAllocate","error processing");
+	NZG_ERROR("msgAllocate", "error processing");
 	msgPoolDataTabUnlock(space);
- munmap(mSPoolDataTabAddr,(space->poolNb) * sizeof( msgPoolData ));
+	munmap(mSPoolDataTabAddr, (space->poolNb) * sizeof(msgPoolData));
 	return NULL;
 }

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;
+	return 0;
 }
-
-

src/bufferAttachProc.c

@@ -1,41 +1,36 @@
 #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;
-  msgBufferInfo * bufferInfoTabAddr;
+	msgBufferInfo *bufferInfoTabAddr;
 	int bufferInfoNb;
 
 	//récuperer l'ID du BufferInfoTab;
 	strcpy(bufferInfoTabId, poolDataTabAddr[poolIndex].bufferInfoTabId);
 
-
+	bufferInfoTabFd = shm_open(bufferInfoTabId, O_RDWR, SHM_DEFAULT_MODE);
-  bufferInfoTabFd=shm_open(bufferInfoTabId,O_RDWR,SHM_DEFAULT_MODE);
+	if (bufferInfoTabFd < 0) {
-  if (bufferInfoTabFd<0){
+		NZG_ERROR("sem_open", bufferInfoTabId);
-	NZG_ERROR("sem_open",bufferInfoTabId);
 		return -1;
 	}
 
   /** on regarde dans le tableau d'infos de buffer **/
-  bufferInfoNb=poolDataTabAddr[poolIndex].bufferNb;
+	bufferInfoNb = poolDataTabAddr[poolIndex].bufferNb;
-  bufferInfoTabAddr=mmap(NULL,bufferInfoNb*sizeof(msgBufferInfo),
+	bufferInfoTabAddr = mmap(NULL, bufferInfoNb * sizeof(msgBufferInfo),
-	  PROT_READ|PROT_WRITE,MAP_SHARED,bufferInfoTabFd,(off_t)0);
+				 PROT_READ | PROT_WRITE, MAP_SHARED,
-  printf("atta gooo %s\n",bufferInfoTabId);
+				 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);
-	NZG_ERROR("munmap",bufferInfoTabId);
+		return -1;
-	return -1; }
+	}
 
 	return 0;
 }
-
-

src/bufferDetachProc.c

@@ -1,42 +1,37 @@
 #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;
+	msgBufferInfo *bufferInfoTabAddr;
 	int bufferInfoNb;
 
-  printf("Detaching %d,%d\n",poolIndex,bufferIndex);
+	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);
+	bufferInfoTabFd = shm_open(bufferInfoTabId, O_RDWR, SHM_DEFAULT_MODE);
-  if (bufferInfoTabFd<0){
+	if (bufferInfoTabFd < 0) {
-	NZG_ERROR("shm_open",bufferInfoTabId);
+		NZG_ERROR("shm_open", bufferInfoTabId);
 		return -1;
 	}
 
   /** on regarde dans le tableau d'infos de buffer **/
-  bufferInfoNb=poolDataTabAddr[poolIndex].bufferNb;
+	bufferInfoNb = poolDataTabAddr[poolIndex].bufferNb;
-  bufferInfoTabAddr=mmap(NULL,bufferInfoNb*sizeof(msgBufferInfo),
+	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].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);
-	NZG_ERROR("munmap",bufferInfoTabId);
 		return -1;
 	}
 
 	return 0;
 }
-  

src/bufferGetFreeIndex.c

@@ -1,39 +1,43 @@
 #include "libnazgul.h"
 
-int msgBufferGetFreeIndex(msgPoolData * poolDataTabAddr,int poolIndex){
+int msgBufferGetFreeIndex(msgPoolData * poolDataTabAddr, int poolIndex)
+{
 	msgBufferInfoTabId bufferInfoTabId;
-int bufferInfoTabFd;
+	int bufferInfoTabFd;
-msgBufferInfo * bufferInfoTabAddr;
+	msgBufferInfo *bufferInfoTabAddr;
-int bufferInfoNb;  
+	int bufferInfoNb;
-int bufferFreeIndex;
+	int bufferFreeIndex;
-int i;
+	int i;
 
 	//récuperer l'ID du BufferInfoTab;
 	strcpy(bufferInfoTabId, poolDataTabAddr[poolIndex].bufferInfoTabId);
 
-  bufferInfoTabFd=shm_open(bufferInfoTabId,O_RDWR,SHM_DEFAULT_MODE);
+	bufferInfoTabFd = shm_open(bufferInfoTabId, O_RDWR, SHM_DEFAULT_MODE);
-  if (bufferInfoTabFd<0){
+	if (bufferInfoTabFd < 0) {
-	NZG_ERROR("shm_open",bufferInfoTabId);
+		NZG_ERROR("shm_open", bufferInfoTabId);
 		return -1;
 	}
 
   /** on regarde dans le tableau d'infos de buffer **/
-  bufferInfoNb=poolDataTabAddr[poolIndex].bufferNb;
+	bufferInfoNb = poolDataTabAddr[poolIndex].bufferNb;
-  bufferInfoTabAddr=mmap(NULL,bufferInfoNb*sizeof(msgBufferInfo),
+	bufferInfoTabAddr = mmap(NULL, bufferInfoNb * sizeof(msgBufferInfo),
-	  PROT_READ,MAP_SHARED,bufferInfoTabFd,(off_t)0);
+				 PROT_READ, MAP_SHARED, bufferInfoTabFd,
+				 (off_t) 0);
 
-  i=0;
+	i = 0;
-  while ((i<bufferInfoNb) 
+	while ((i < bufferInfoNb)
-	  && (bufferInfoTabAddr[i].ownerPid != (pid_t)-1)){ i++; }
+	       && (bufferInfoTabAddr[i].ownerPid != (pid_t) - 1)) {
-  if (i == bufferInfoNb){ return -1; }
+		i++;
-  bufferFreeIndex=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);
-	NZG_ERROR("munmap",bufferInfoTabId);
 		return -1;
 	}
 
 	return bufferFreeIndex;
 }
-

src/bufferGetProcAttach.c

@@ -1,51 +1,61 @@
 #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;
+	msgBufferInfo *bufferInfoTabAddr;
 	int bufferInfoNb;
 
-  bool found=false;
+	bool found = false;
-  int pIdx=0;
+	int pIdx = 0;
 	int bIdx;
-  while ((!found) && (pIdx < poolNb)){
+	while ((!found) && (pIdx < poolNb)) {
 		/* Pour chaque pool */
 		//récuperer l'ID du BufferInfoTab;
 		strcpy(bufferInfoTabId, poolDataTabAddr[pIdx].bufferInfoTabId);
-	bufferInfoNb=poolDataTabAddr[pIdx].bufferNb;
+		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;
+		bIdx = 0;
-	while((!found) && bIdx<bufferInfoNb){
+		while ((!found) && bIdx < bufferInfoNb) {
-	  if (bufferInfoTabAddr[bIdx].addr == addr){ 
+			if (bufferInfoTabAddr[bIdx].addr == addr) {
-		found=true; 
+				found = true;
-		(*bufferIndex)=bIdx;
+				(*bufferIndex) = bIdx;
 			};
 			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,37 +1,39 @@
 #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;
 
 	/* creation des infos sur buffers DEBUT */
-  if (msgBufferInfoTabIdIntern(bufferInfoTabId,externId,poolIdx) == -1){
+	if (msgBufferInfoTabIdIntern(bufferInfoTabId, externId, poolIdx) == -1) {
-	NZG_ERROR("msgPoolId creation",bufferInfoTabId);
+		NZG_ERROR("msgPoolId creation", bufferInfoTabId);
 		return -1;
 	}
 
-  bufferInfoTabFd=shm_open(bufferInfoTabId,O_RDWR|O_CREAT|O_EXCL|O_TRUNC,MSGSPACE_DEFAULT_MODE);
+	bufferInfoTabFd =
-  if (bufferInfoTabFd == -1 ) {
+	    shm_open(bufferInfoTabId, O_RDWR | O_CREAT | O_EXCL | O_TRUNC,
-	fprintf( stderr, "msgInfoTab : %s creation failed: %s\n",bufferInfoTabId,
+		     MSGSPACE_DEFAULT_MODE);
-		strerror( errno ) );
+	if (bufferInfoTabFd == -1) {
+		fprintf(stderr, "msgInfoTab : %s creation failed: %s\n",
+			bufferInfoTabId, strerror(errno));
 		return -1;
 	}
-  if (ftruncate(bufferInfoTabFd, bufferNb*sizeof(msgBufferInfo)) == -1){
+	if (ftruncate(bufferInfoTabFd, bufferNb * sizeof(msgBufferInfo)) == -1) {
-	fprintf( stderr, "msgBufferInfoTab resizing failed: %s\n",
+		fprintf(stderr, "msgBufferInfoTab resizing failed: %s\n",
-		strerror( errno ) );
+			strerror(errno));
 		return -1;
 	}
 	close(bufferInfoTabFd);
 	/* creation des infos sur buffers FIN */
 
-  msgBufferInfoTabInit(poolDataTabAddr,poolIdx);
+	msgBufferInfoTabInit(poolDataTabAddr, poolIdx);
 
-  return -1;NZG_ERROR("munmap",bufferInfoTabId);
+	return -1;
+	NZG_ERROR("munmap", bufferInfoTabId);
 	return -1;
 }

src/bufferInfoTabInit.c

@@ -1,34 +1,38 @@
 #include "libnazgul.h"
 
-int msgBufferInfoTabInit(msgPoolData * poolDataTabAddr,int poolIndex){
+int msgBufferInfoTabInit(msgPoolData * poolDataTabAddr, int poolIndex)
+{
 	msgBufferInfoTabId bufferInfoTabId;
-int bufferInfoTabFd;
+	int bufferInfoTabFd;
-msgBufferInfo * bufferInfoTabAddr;
+	msgBufferInfo *bufferInfoTabAddr;
-int bufferInfoNb;
+	int bufferInfoNb;
-int i;  
+	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,
-  bufferInfoTabFd=shm_open(bufferInfoTabId,O_RDWR,SHM_DEFAULT_MODE);
+	       bufferInfoTabId);
-  if (bufferInfoTabFd<0){
+	bufferInfoTabFd = shm_open(bufferInfoTabId, O_RDWR, SHM_DEFAULT_MODE);
-	NZG_ERROR("msgBufferInfoTabId open",bufferInfoTabId);
+	if (bufferInfoTabFd < 0) {
+		NZG_ERROR("msgBufferInfoTabId open", bufferInfoTabId);
 		return -1;
 	}
 
   /** on regarde dans le tableau d'infos de buffer **/
-  bufferInfoNb=poolDataTabAddr[poolIndex].bufferNb;
+	bufferInfoNb = poolDataTabAddr[poolIndex].bufferNb;
-  bufferInfoTabAddr=mmap(NULL,bufferInfoNb*sizeof(msgBufferInfo),
+	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++){
+	for (i = 0; i < bufferInfoNb; i++) {
-	bufferInfoTabAddr[i].ownerPid = (pid_t)-1;
+		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,12 +1,12 @@
 #include "libnazgul.h"
 
-
+void *msgBufferMap(msgPoolData * poolDataTab, int poolIndex, int bufferIndex)
-void * msgBufferMap(msgPoolData * poolDataTab, int poolIndex, int bufferIndex) {
+{
-  void * resultAddr;
+	void *resultAddr;
 	int bufferSize, bufferNb;
 	int poolBufferTabFd;
 	msgPoolId poolBufferTabId;
-  printf("Mapping buffer (%d,%d)\n",poolIndex,bufferIndex);
+	printf("Mapping buffer (%d,%d)\n", poolIndex, bufferIndex);
 	// TODO: récuperer l'ID du BufferInfoTab;
 	strcpy(poolBufferTabId, poolDataTab[poolIndex].poolId);
 	bufferSize = poolDataTab[poolIndex].bufferSize;
@@ -15,41 +15,36 @@ void * msgBufferMap(msgPoolData * poolDataTab, int poolIndex, int bufferIndex) {
 		// do something with bufferNb
 	}
 
-  poolBufferTabFd=shm_open(poolBufferTabId,O_RDWR,SHM_DEFAULT_MODE);
+	poolBufferTabFd = shm_open(poolBufferTabId, O_RDWR, SHM_DEFAULT_MODE);
-  if (poolBufferTabFd<0){
+	if (poolBufferTabFd < 0) {
-	NZG_ERROR("shm_open",poolBufferTabId);
+		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
+	if (resultAddr == MAP_FAILED) {
-	  MAP_SHARED, 
-	  poolBufferTabFd, 
-	  (off_t)0);
-  if(resultAddr == MAP_FAILED) {
 		NZG_ERROR("mmap", poolBufferTabId);
 		goto ERROR;
 	}
-  printf( "Mapped from %p to %p\n",
+	printf("Mapped from %p to %p\n",
 	       (void *)resultAddr,
-	  (void *)(resultAddr+ bufferSize*(bufferIndex+1))
+	       (void *)(resultAddr + bufferSize * (bufferIndex + 1))
 	    );
 
-  resultAddr=resultAddr +( bufferSize*bufferIndex);
+	resultAddr = resultAddr + (bufferSize * bufferIndex);
-  printf( "Moved to %p\n",(void *)resultAddr	);
+	printf("Moved to %p\n", (void *)resultAddr);
 
 	/* mprotect(
 	   resultAddr,
 	   bufferSize,
 	   PROT_READ|PROT_WRITE
-	  );*/
+	   ); */
 
 	close(poolBufferTabFd);
 
 	return resultAddr;
-ERROR:
+ ERROR:
 	return NULL;
 }

src/free.c

@@ -1,21 +1,22 @@
 #include "libnazgul.h"
 
-int msgFree(msgSpace * space, void * addr){
+int msgFree(msgSpace * space, void *addr)
+{
 
 	int poolIndex;
 	int bufferIndex;
-  msgPoolData * poolDataTabAddr;
+	msgPoolData *poolDataTabAddr;
-  sem_t * ressourceSemFd;
+	sem_t *ressourceSemFd;
 	msgPoolDataTabSemId ressourceSemId;
 	int err;
 	int bufferNb;
 	int bufferSize;
-  void * realAddr;
+	void *realAddr;
-  printf("[ FREE %p ]\n",(void *)addr);
+	printf("[ FREE %p ]\n", (void *)addr);
 	/* on acquiert le droit de modifier les infos sur la ressource */
 	/* on protege le tableau des associations */
-  if (msgPoolDataTabLock(space) <0){
+	if (msgPoolDataTabLock(space) < 0) {
-	NZG_ERROR("msgPoolDataTabLock",space->poolDataTabSemId);
+		NZG_ERROR("msgPoolDataTabLock", space->poolDataTabSemId);
 		goto ERROR;
 	};
 
@@ -25,42 +26,38 @@ 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("Found : %d\n", err);
-  printf("Freing pool: %d, buffer: %d\n",poolIndex,bufferIndex);
+	printf("Freing pool: %d, buffer: %d\n", poolIndex, bufferIndex);
-  msgBufferDetachProc(poolDataTabAddr,poolIndex,bufferIndex,addr);
+	msgBufferDetachProc(poolDataTabAddr, poolIndex, bufferIndex, addr);
 
 	/* unmapper le buffer */
-  realAddr=addr;
+	realAddr = addr;
-  bufferSize=poolDataTabAddr[poolIndex].bufferSize;
+	bufferSize = poolDataTabAddr[poolIndex].bufferSize;
-  bufferNb=poolDataTabAddr[poolIndex].bufferNb;
+	bufferNb = poolDataTabAddr[poolIndex].bufferNb;
-  realAddr=realAddr-poolIndex*bufferSize;
+	realAddr = realAddr - poolIndex * bufferSize;
-  munmap(realAddr,bufferSize*bufferNb);
+	munmap(realAddr, bufferSize * bufferNb);
 
-  msgPoolDataTabClose(space,poolDataTabAddr);
+	msgPoolDataTabClose(space, poolDataTabAddr);
 
 	// deverouiller semaphore DataInfo
 	msgPoolDataTabUnlock(space);
 
 	// deverouiller semaphore ressource.
-  msgPoolSemIdIntern(ressourceSemId,space->externId,poolIndex);
+	msgPoolSemIdIntern(ressourceSemId, space->externId, poolIndex);
-  ressourceSemFd = sem_open(ressourceSemId,O_CREAT,SEM_DEFAULT_MODE,0);
+	ressourceSemFd = sem_open(ressourceSemId, O_CREAT, SEM_DEFAULT_MODE, 0);
-  if (ressourceSemFd == SEM_FAILED){ 
+	if (ressourceSemFd == SEM_FAILED) {
-	NZG_ERROR("sem_open",ressourceSemId);
+		NZG_ERROR("sem_open", ressourceSemId);
 		goto ERROR;
 	}
 	sem_post(ressourceSemFd);
 	sem_close(ressourceSemFd);
 	return 0;
-ERROR:
+ ERROR:
 	return -1;
 }
-

src/get.c

@@ -2,59 +2,60 @@
 
 #define NONBLOCK -1
 
-void * msgGet(msgSpace * space,int queueIndex,int option){
+void *msgGet(msgSpace * space, int queueIndex, int option)
-  void * resultAddr;
+{
+	void *resultAddr;
 	msgQueueId queueId;
-  msgQueue * queue;
+	msgQueue *queue;
 	msgQueueElemId oldElemId;
-  msgQueueElem * oldElem;
+	msgQueueElem *oldElem;
-  msgPoolData * poolDataTab;
+	msgPoolData *poolDataTab;
 	// on teste la possibilité de lecture sur la liste...
-  if (option == NONBLOCK){
+	if (option == NONBLOCK) {
-	if (msgQueueReadTryLock(space->externId,queueIndex) <0){
+		if (msgQueueReadTryLock(space->externId, queueIndex) < 0) {
-	  NZG_ERROR("msgQueueReadTryLock",space->externId);
+			NZG_ERROR("msgQueueReadTryLock", space->externId);
 			goto ERROR;
 		}
 	} else {
-	if (msgQueueReadLock(space->externId,queueIndex) <0){
+		if (msgQueueReadLock(space->externId, queueIndex) < 0) {
-	  NZG_ERROR("msgQueueReadLock",space->externId);
+			NZG_ERROR("msgQueueReadLock", space->externId);
 			goto ERROR;
 		}
 	}
 	// la lecture est possible
 	// on essaye donc de modifier la liste
-  msgQueueProtLock(space->externId,queueIndex);
+	msgQueueProtLock(space->externId, queueIndex);
-  msgQueueIdIntern(queueId,space->externId,queueIndex);
+	msgQueueIdIntern(queueId, space->externId, queueIndex);
 	// ouvrir la file
 	queue = msgQueueOpen(queueId);
-  if (queue==NULL){
+	if (queue == NULL) {
-	NZG_ERROR("msgQueueOpen",queueId);
+		NZG_ERROR("msgQueueOpen", queueId);
 		goto ERROR;
 	}
 	// recupérer l'id de l'ancien element...
 	msgQueueRem(queue, oldElemId);
 
 	oldElem = msgQueueElemOpen(oldElemId);
-  if (oldElem == NULL){
+	if (oldElem == NULL) {
-	NZG_ERROR("msgQueueElemOpen",oldElemId);
+		NZG_ERROR("msgQueueElemOpen", oldElemId);
 		goto ERROR;
 	}
 	/* on récupere la taille des buffer dans la pool du buffer */
-  poolDataTab=msgPoolDataTabOpen(space);
+	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);
-	NZG_ERROR("msgBufferAttachProc",oldElemId);
 		goto ERROR;
 	}
 
-  msgPoolDataTabClose(space,poolDataTab);
+	msgPoolDataTabClose(space, poolDataTab);
-  if (msgQueueElemClose(oldElem) <0){
+	if (msgQueueElemClose(oldElem) < 0) {
-	NZG_ERROR("msgQueueElemClose",oldElemId);
+		NZG_ERROR("msgQueueElemClose", oldElemId);
 	}
 
 	shm_unlink(oldElemId);
@@ -63,9 +64,9 @@ void * msgGet(msgSpace * space,int queueIndex,int option){
 	msgQueueClose(queue);
 
 	// on a fini de modifier la liste
-  msgQueueProtUnlock(space->externId,queueIndex);
+	msgQueueProtUnlock(space->externId, queueIndex);
 
 	return resultAddr;
-ERROR:
+ ERROR:
 	return NULL;
 }

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,158 +1,150 @@
 #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){
+{
+	if (strlen(src) > MSGSPACE_ID_LEN) {
 		return -1;
 	}
 	/* sprintf(resNzgId,"/tmp/.nzg-%s",(char *)spaceId); */
 #ifdef _NZG_REALFILEID
-  sprintf(dest,"/tmp/nzgSpace%s",(char *)src);
+	sprintf(dest, "/tmp/nzgSpace%s", (char *)src);
 #else
-  sprintf(dest,"/nzgSpace%s",(char *)src);
+	sprintf(dest, "/nzgSpace%s", (char *)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){
+	if (strlen(externId) > MSGSPACE_ID_LEN * 4) {
 		return -1;
 	}
 	/* sprintf(resNzgId,"/tmp/.nzg-%s",(char *)spaceId); */
 #ifdef _NZG_REALFILEID
-  sprintf(destSemId,"/tmp/nzgPoolDTSem-%s",(char *)externId);
+	sprintf(destSemId, "/tmp/nzgPoolDTSem-%s", (char *)externId);
 #else
-  sprintf(destSemId,"/nzgPoolDTSem-%s",(char *)externId);
+	sprintf(destSemId, "/nzgPoolDTSem-%s", (char *)externId);
 #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){
+	if (strlen(srcPoolId) > MSGSPACE_ID_LEN * 4) {
 		return -1;
 	}
 	/* sprintf(resNzgId,"/tmp/.nzg-%s",(char *)spaceId); */
 #ifdef _NZG_REALFILEID
-  sprintf(destSemId,"/tmp/nzgPoolSem-%s-%d",(char *)srcPoolId,poolIdx);
+	sprintf(destSemId, "/tmp/nzgPoolSem-%s-%d", (char *)srcPoolId, poolIdx);
 #else
-  sprintf(destSemId,"/nzgPoolSem-%s-%d",(char *)srcPoolId,poolIdx);
+	sprintf(destSemId, "/nzgPoolSem-%s-%d", (char *)srcPoolId, poolIdx);
 #endif
 	return 0;
 }
 
-int msgPoolDataIdIntern(msgPoolDataTabId dest,const msgSpaceId src ){
+int msgPoolDataIdIntern(msgPoolDataTabId dest, const msgSpaceId src)
-  if (strlen(src)>MSGSPACE_ID_LEN){
+{
+	if (strlen(src) > MSGSPACE_ID_LEN) {
 		return -1;
 	}
 	/* sprintf(resNzgId,"/tmp/.nzg-%s",(char *)spaceId); */
 #ifdef _NZG_REALFILEID
-  sprintf(dest,"/tmp/nzgPoolData-%s",(char *)src);
+	sprintf(dest, "/tmp/nzgPoolData-%s", (char *)src);
 #else
-  sprintf(dest,"/nzgPoolData-%s",(char *)src);
+	sprintf(dest, "/nzgPoolData-%s", (char *)src);
 #endif
 	return 0;
 }
 
-
+int msgPoolIdIntern(msgPoolId dest, msgPoolId src, int num)
-int msgPoolIdIntern(msgPoolId dest,msgPoolId src, int num){
+{
-  if (strlen(src)>MSGSPACE_ID_LEN){
+	if (strlen(src) > MSGSPACE_ID_LEN) {
 		return -1;
 	}
 #ifdef _NZG_REALFILEID
-  sprintf(dest,"/tmp/nzgPool-%s-%d",(char *)src,num);
+	sprintf(dest, "/tmp/nzgPool-%s-%d", (char *)src, num);
 #else
-  sprintf(dest,"/nzgPool-%s-%d",(char *)src,num);
+	sprintf(dest, "/nzgPool-%s-%d", (char *)src, num);
 #endif
 	return 0;
 }
 
-int msgBufferInfoTabIdIntern(
+int msgBufferInfoTabIdIntern(msgBufferInfoTabId dest, msgSpaceId src, int num)
-	msgBufferInfoTabId dest,
+{
-	msgSpaceId src, 
+	if (strlen(src) > MSGSPACE_ID_LEN) {
-	int num){
-  if (strlen(src)>MSGSPACE_ID_LEN){
 		return -1;
 	}
 #ifdef _NZG_REALFILEID
-  sprintf(dest,"/tmp/nzgBufferInfo-%s-%d",(char *)src,num);
+	sprintf(dest, "/tmp/nzgBufferInfo-%s-%d", (char *)src, num);
 #else
-  sprintf(dest,"/nzgBufferInfo-%s-%d",(char *)src,num);
+	sprintf(dest, "/nzgBufferInfo-%s-%d", (char *)src, num);
 #endif
 	return 0;
 }
 
-int msgQueueProtSemIdIntern(
+int msgQueueProtSemIdIntern(msgQueueSemId dest,
-	msgQueueSemId dest,
+			    msgSpaceId externId, int queueIdx)
-	msgSpaceId externId, 
+{
-	int queueIdx){
+	if (strlen(externId) > MSGSPACE_ID_LEN) {
-  if (strlen(externId)>MSGSPACE_ID_LEN){
 		return -1;
 	}
 #ifdef _NZG_REALFILEID
-  sprintf(dest,"/tmp/nzgQueueProtSem-%s-%d",(char *)externId,queueIdx);
+	sprintf(dest, "/tmp/nzgQueueProtSem-%s-%d", (char *)externId, queueIdx);
 #else
-  sprintf(dest,"/nzgQueueProtSem-%s-%d",(char *)externId,queueIdx);
+	sprintf(dest, "/nzgQueueProtSem-%s-%d", (char *)externId, queueIdx);
 #endif
 	return 0;
 }
 
-int msgQueueReadSemIdIntern(
+int msgQueueReadSemIdIntern(msgQueueSemId dest,
-	msgQueueSemId dest,
+			    msgSpaceId externId, int queueIdx)
-	msgSpaceId externId, 
+{
-	int queueIdx){
+	if (strlen(externId) > MSGSPACE_ID_LEN) {
-  if (strlen(externId)>MSGSPACE_ID_LEN){
 		return -1;
 	}
 #ifdef _NZG_REALFILEID
-  sprintf(dest,"/tmp/nzgQueueReadSem-%s-%d",(char *)externId,queueIdx);
+	sprintf(dest, "/tmp/nzgQueueReadSem-%s-%d", (char *)externId, queueIdx);
 #else
-  sprintf(dest,"/nzgQueueReadSem-%s-%d",(char *)externId,queueIdx);
+	sprintf(dest, "/nzgQueueReadSem-%s-%d", (char *)externId, queueIdx);
 #endif
 	return 0;
 }
 
-int msgQueueIdIntern(
+int msgQueueIdIntern(msgQueueId dest, msgSpaceId externId, int queueIdx)
-	msgQueueId dest,
+{
-	msgSpaceId externId, 
+	if (strlen(externId) > MSGSPACE_ID_LEN) {
-	int queueIdx){
-  if (strlen(externId)>MSGSPACE_ID_LEN){
 		return -1;
 	}
 #ifdef _NZG_REALFILEID
-  sprintf(dest,"/tmp/nzgQueue-%s-%d",(char *)externId,queueIdx);
+	sprintf(dest, "/tmp/nzgQueue-%s-%d", (char *)externId, queueIdx);
 #else
-  sprintf(dest,"/nzgQueue-%s-%d",(char *)externId,queueIdx);
+	sprintf(dest, "/nzgQueue-%s-%d", (char *)externId, queueIdx);
 #endif
 	return 0;
 }
 
-int msgQueueElemIdIntern(
+int msgQueueElemIdIntern(msgQueueElemId dest, msgQueueId src, int counter)
-	msgQueueElemId dest,
+{
-	msgQueueId src,
+	if (strlen(src) > MSGSPACE_ID_LEN) {
-	int counter){
-  if (strlen(src)>MSGSPACE_ID_LEN){
 		return -1;
 	}
-  sprintf(dest,"%s-%d",(char *)src,counter);
+	sprintf(dest, "%s-%d", (char *)src, counter);
 	return 0;
 }
 
-int msgSpaceListElemIdIntern(msgSpaceListElemId elemListId,msgSpaceId externId){
+int msgSpaceListElemIdIntern(msgSpaceListElemId elemListId, msgSpaceId externId)
-   if (strlen(externId)>MSGSPACE_ID_LEN){
+{
+	if (strlen(externId) > MSGSPACE_ID_LEN) {
 		return -1;
 	}
 	/* sprintf(resNzgId,"/tmp/.nzg-%s",(char *)spaceId); */
 #ifdef _NZG_REALFILEID
-  sprintf(elemListId,"/tmp/nzgSpaceListElem-%s",(char *)externId);
+	sprintf(elemListId, "/tmp/nzgSpaceListElem-%s", (char *)externId);
 #else
-  sprintf(elemListId,"/nzgSpaceListElem-%s",(char *)externId);
+	sprintf(elemListId, "/nzgSpaceListElem-%s", (char *)externId);
 #endif
 	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 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

@@ -3,26 +3,26 @@
 
 #include "global.h"
 
-typedef enum { true=1, false=0} bool;
+typedef enum { true = 1, false = 0 } bool;
 
 typedef char msgSpaceId[MSGSPACE_ID_LEN];
 
-typedef char msgSpaceListId[4*MSGSPACE_ID_LEN]; 
+typedef char msgSpaceListId[4 * MSGSPACE_ID_LEN];
-typedef char msgSpaceListSemId[4*MSGSPACE_ID_LEN]; 
+typedef char msgSpaceListSemId[4 * MSGSPACE_ID_LEN];
-typedef char msgSpaceListElemId[4*MSGSPACE_ID_LEN];
+typedef char msgSpaceListElemId[4 * MSGSPACE_ID_LEN];
 
-typedef char msgPoolDataTabId[4*MSGSPACE_ID_LEN];
+typedef char msgPoolDataTabId[4 * MSGSPACE_ID_LEN];
-typedef char msgPoolDataTabSemId[4*MSGSPACE_ID_LEN];
+typedef char msgPoolDataTabSemId[4 * MSGSPACE_ID_LEN];
 
-typedef char msgBufferInfoTabId[4*MSGSPACE_ID_LEN];
+typedef char msgBufferInfoTabId[4 * MSGSPACE_ID_LEN];
 
-typedef char msgPoolId[4*MSGSPACE_ID_LEN];
+typedef char msgPoolId[4 * MSGSPACE_ID_LEN];
-typedef char msgPoolSemId[4*MSGSPACE_ID_LEN];
+typedef char msgPoolSemId[4 * MSGSPACE_ID_LEN];
 
-typedef char msgQueueDataId[4*MSGSPACE_ID_LEN];
+typedef char msgQueueDataId[4 * MSGSPACE_ID_LEN];
-typedef char msgQueueId[4*MSGSPACE_ID_LEN];
+typedef char msgQueueId[4 * MSGSPACE_ID_LEN];
-typedef char msgQueueElemId[4*MSGSPACE_ID_LEN];
+typedef char msgQueueElemId[4 * MSGSPACE_ID_LEN];
-typedef char msgQueueSemId[4*MSGSPACE_ID_LEN];
+typedef char msgQueueSemId[4 * MSGSPACE_ID_LEN];
 
   /* pid[] */
   /* liste des processus demandeurs */
@@ -33,7 +33,7 @@ typedef struct MsgPool {
 
 typedef struct MsgBufferInfo {
 	pid_t ownerPid;
-  void * addr;
+	void *addr;
 } msgBufferInfo;
 
 typedef struct MsgPoolData {
@@ -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,49 +1,51 @@
 #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;
+	sem_t *ressourceSemFd;
 	msgPoolId poolId;
 	msgPoolSemId poolRessourceSemId;
 
 	/* creation des buffers DEBUT */
-	if (msgPoolIdIntern(poolId,externId,poolIdx) == -1){
+	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 =
-	if (poolFd == -1 ) {
+	    shm_open(poolId, O_RDWR | O_CREAT | O_EXCL | O_TRUNC,
-	  fprintf( stderr, "msgPool : %s creation failed: %s\n",poolId,
+		     MSGSPACE_DEFAULT_MODE);
-		  strerror( errno ) );
+	if (poolFd == -1) {
+		fprintf(stderr, "msgPool : %s creation failed: %s\n", poolId,
+			strerror(errno));
 		return -1;
 	}
-	if (ftruncate(poolFd, (buffSize*buffNb)) == -1){
+	if (ftruncate(poolFd, (buffSize * buffNb)) == -1) {
-	  fprintf( stderr, "msgPool resizing failed: %s\n",
+		fprintf(stderr, "msgPool resizing failed: %s\n",
-		  strerror( errno ) );
+			strerror(errno));
 		return -1;
 	}
 	/* creation des buffers FIN */
 
-	if (msgPoolSemIdIntern(poolRessourceSemId,externId,poolIdx) == -1){
+	if (msgPoolSemIdIntern(poolRessourceSemId, externId, poolIdx) == -1) {
-	  fprintf( stderr, "msgPoolId creation failed for id %s\n",
+		fprintf(stderr, "msgPoolId creation failed for id %s\n",
-		  (char*)poolRessourceSemId );
+			(char *)poolRessourceSemId);
 		return -1;
 	}
-
 	// on met un semaphore sur le pool
-	ressourceSemFd = sem_open(poolRessourceSemId, O_CREAT|O_EXCL,SEM_DEFAULT_MODE, buffNb);
+	ressourceSemFd =
-		if (ressourceSemFd == SEM_FAILED){ 
+	    sem_open(poolRessourceSemId, O_CREAT | O_EXCL, SEM_DEFAULT_MODE,
-		  NZG_ERROR("sem_open : creation de la ressource",poolRessourceSemId);
+		     buffNb);
+	if (ressourceSemFd == SEM_FAILED) {
+		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
@@ -55,7 +57,6 @@ int msgPoolCreate(
 	close(poolFd);
 
 	return 0;
-ERROR:
+ ERROR:
 	return -1;
 }
-

src/poolDataTabClose.c

@@ -1,13 +1,14 @@
 #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){
+	if (munmap(addr, (space->poolNb) * sizeof(msgPoolData)) < 0) {
- 	NZG_ERROR("unmap",space->poolDataTabId);
+		NZG_ERROR("unmap", space->poolDataTabId);
 		goto ERROR;
 	}
 	return 0;
-ERROR:
+ ERROR:
 	return -1;
 }

src/poolDataTabCreate.c

@@ -1,29 +1,28 @@
 #include "libnazgul.h"
 #include "ids.h"
 
-void * msgPoolDataTabCreate(msgSpace * space){
+void *msgPoolDataTabCreate(msgSpace * space)
+{
 	int poolDataFd;		// shm file descriptor
-  msgPoolData * poolDataTabAddr;
+	msgPoolData *poolDataTabAddr;
-  poolDataFd=shm_open(
+	poolDataFd = shm_open(space->poolDataTabId,
-	  space->poolDataTabId,
+			      O_RDWR | O_CREAT | O_EXCL | O_TRUNC,
-	  O_RDWR|O_CREAT|O_EXCL|O_TRUNC,
+			      MSGSPACE_DEFAULT_MODE);
-	  MSGSPACE_DEFAULT_MODE
+	if (poolDataFd == -1) {
-	  );
+		NZG_ERROR("shm_open :create", space->poolDataTabId);
-  if (poolDataFd == -1 ) {
-	NZG_ERROR("shm_open :create",space->poolDataTabId);
 		goto ERROR;
 	}
 
 	/* allocation de la bonne zone mémoire pour le poolData */
-  if (ftruncate(poolDataFd, (space->poolNb)*sizeof(msgPoolData)) == -1){
+	if (ftruncate(poolDataFd, (space->poolNb) * sizeof(msgPoolData)) == -1) {
-	NZG_ERROR("ftruncate",space->poolDataTabId);
+		NZG_ERROR("ftruncate", space->poolDataTabId);
 		goto ERROR;
 	}
 
 	close(poolDataFd);
 	poolDataTabAddr = msgPoolDataTabOpen(space);
-  if (poolDataTabAddr == NULL){
+	if (poolDataTabAddr == NULL) {
-	NZG_ERROR("msgPoolDataTabOpen : create",space->poolDataTabId);
+		NZG_ERROR("msgPoolDataTabOpen : create", space->poolDataTabId);
 		goto ERROR;
 	}
 	/*mmap( 0, sizeof( *mSAddr ),
@@ -32,11 +31,9 @@ void * msgPoolDataTabCreate(msgSpace * space){
 	   if( poolDataAddr == MAP_FAILED ) {
 	   NZG_ERROR("mmap",poolDataTabId);
 	   goto ERROR;
-	}*/
+	   } */
 
 	return poolDataTabAddr;
-ERROR:
+ ERROR:
 	return NULL;
 }
-
-

src/poolDataTabLock.c

@@ -3,34 +3,35 @@
 
 #define DEBUG 0
 
-int msgPoolDataTabLock(msgSpace * space){
+int msgPoolDataTabLock(msgSpace * space)
+{
 	int semval;
-  sem_t * poolDataTabSemFd;
+	sem_t *poolDataTabSemFd;
-  semval=0;
+	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,
+	if (poolDataTabSemFd == SEM_FAILED) {
-	  SEM_DEFAULT_MODE,
+		NZG_ERROR("sem_open", space->poolDataTabSemId);
-	  1);
-  if(poolDataTabSemFd==SEM_FAILED){
-	NZG_ERROR("sem_open",space->poolDataTabSemId);
 		goto ERROR;
 	}
 
-  if(sem_wait(poolDataTabSemFd)==-1){
+	if (sem_wait(poolDataTabSemFd) == -1) {
-	NZG_ERROR("sem_wait",space->poolDataTabSemId);
+		NZG_ERROR("sem_wait", space->poolDataTabSemId);
 		goto ERROR;
 	}
 
-  sem_getvalue(poolDataTabSemFd,&semval);
+	sem_getvalue(poolDataTabSemFd, &semval);
-  if (DEBUG) { printf("(AfternValue:%d)\n",semval);}
+	if (DEBUG) {
+		printf("(AfternValue:%d)\n", semval);
+	}
 
 	sem_close(poolDataTabSemFd);
 
 	return 0;
-ERROR:
+ ERROR:
 	return -1;
 }
-

src/poolDataTabOpen.c

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

src/poolDataTabUnlock.c

@@ -3,33 +3,34 @@
 
 #define DEBUG 0
 
-int msgPoolDataTabUnlock(msgSpace * space){
+int msgPoolDataTabUnlock(msgSpace * space)
+{
 	int semval;
-  sem_t * poolDataTabSemFd;
+	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) {
-  if(poolDataTabSemFd==SEM_FAILED){
+		NZG_ERROR("sem_open", space->poolDataTabSemId);
-	NZG_ERROR("sem_open",space->poolDataTabSemId);
 		goto ERROR;
 	}
 
-  if(sem_post(poolDataTabSemFd)==-1){
+	if (sem_post(poolDataTabSemFd) == -1) {
-	NZG_ERROR("sem_post",space->poolDataTabSemId);
+		NZG_ERROR("sem_post", space->poolDataTabSemId);
 		goto ERROR;
 	}
 
-  semval=0;
+	semval = 0;
-  sem_getvalue(poolDataTabSemFd,&semval);
+	sem_getvalue(poolDataTabSemFd, &semval);
-  if (DEBUG) { printf("(AfternValue:%d)\n",semval); }
+	if (DEBUG) {
+		printf("(AfternValue:%d)\n", semval);
+	}
 
 	sem_close(poolDataTabSemFd);
 
 	return 0;
-ERROR:
+ ERROR:
 	return -1;
 }
-

src/poolDelete.c

@@ -1,45 +1,44 @@
 #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){
+	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 ) {
+	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){
+	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 ) {
+	if (shm_unlink(poolId) < 0) {
-	fprintf( stderr, "msgPool : %s deletion failed: %s\n",poolId,
+		fprintf(stderr, "msgPool : %s deletion failed: %s\n", poolId,
-		strerror( errno ) );
+			strerror(errno));
 		return -1;
 	}
 	/* suppression des buffers FIN */
 
 	/* suppression de la sémaphore */
-	if (msgPoolSemIdIntern(poolRessourceSemId,spaceId,poolIdx) == -1){
+	if (msgPoolSemIdIntern(poolRessourceSemId, spaceId, poolIdx) == -1) {
-	  fprintf( stderr, "msgPoolId creation failed for id %s\n",
+		fprintf(stderr, "msgPoolId creation failed for id %s\n",
-		(char*)poolRessourceSemId );
+			(char *)poolRessourceSemId);
 		return -1;
 	}
 	// on met un semaphore sur le pool

src/proto.h

@@ -2,66 +2,77 @@
 #define _NZG_PROTO 1
 
 /* allocate.c */
-void *msgAllocate(msgSpace *space, int pool, int taille, int option);
+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);
+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);
+int msgBufferInfoTabInit(msgPoolData * poolDataTabAddr, int poolIndex);
 /* bufferMap.c */
-void *msgBufferMap(msgPoolData *poolDataTab, int poolIndex, int bufferIndex);
+void *msgBufferMap(msgPoolData * poolDataTab, int poolIndex, int bufferIndex);
 /* free.c */
-int msgFree(msgSpace *space, void *addr);
+int msgFree(msgSpace * space, void *addr);
 /* get.c */
-void *msgGet(msgSpace *space, int queueIndex, int option);
+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);
 /* poolDataTabClose.c */
-int msgPoolDataTabClose(msgSpace *space, void *addr);
+int msgPoolDataTabClose(msgSpace * space, void *addr);
 /* poolDataTabCreate.c */
-void *msgPoolDataTabCreate(msgSpace *space);
+void *msgPoolDataTabCreate(msgSpace * space);
 /* poolDataTabLock.c */
-int msgPoolDataTabLock(msgSpace *space);
+int msgPoolDataTabLock(msgSpace * space);
 /* poolDataTabOpen.c */
-void *msgPoolDataTabOpen(msgSpace *space);
+void *msgPoolDataTabOpen(msgSpace * space);
 /* poolDataTabUnlock.c */
-int msgPoolDataTabUnlock(msgSpace *space);
+int msgPoolDataTabUnlock(msgSpace * space);
 /* poolDelete.c */
 int msgPoolDelete(msgSpaceId spaceId, int poolIdx);
 /* put.c */
-int msgPut(msgSpace *space, int queueIndex, void *addr);
+int msgPut(msgSpace * space, int queueIndex, void *addr);
 /* queueAdd.c */
-int msgQueueAdd(msgQueue *queue, msgQueueElemId newElemId);
+int msgQueueAdd(msgQueue * queue, msgQueueElemId newElemId);
 /* queueClose.c */
-int msgQueueClose(msgQueue *queue);
+int msgQueueClose(msgQueue * queue);
 /* queueDelete.c */
 int msgQueueDelete(msgQueueId externId, int queueIdx);
 /* queueElemClose.c */
-int msgQueueElemClose(msgQueueElem *queueElem);
+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 */
@@ -81,21 +92,22 @@ int msgQueueReadTryLock(msgSpaceId externId, int queueIdx);
 /* queueReadUnlock.c */
 int msgQueueReadUnlock(msgSpaceId externId, int queueIdx);
 /* queueRem.c */
-int msgQueueRem(msgQueue *queue, msgQueueElemId oldElemId);
+int msgQueueRem(msgQueue * queue, msgQueueElemId oldElemId);
 /* spaceClose.c */
-int msgSpaceClose(msgSpace *space);
+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 */
 int msgSpaceListAdd(msgSpaceListElemId newElemId);
 /* spaceListClose.c */
-int msgSpaceListClose(msgSpaceList *list);
+int msgSpaceListClose(msgSpaceList * list);
 /* spaceListElemClose.c */
-int msgSpaceListElemClose(msgSpaceListElem *listElem);
+int msgSpaceListElemClose(msgSpaceListElem * listElem);
 /* spaceListElemCreate.c */
-int msgSpaceListElemCreate(msgSpaceListElemId listElemId, msgSpace *space);
+int msgSpaceListElemCreate(msgSpaceListElemId listElemId, msgSpace * space);
 /* spaceListElemLink.c */
 /* spaceListElemOpen.c */
 void *msgSpaceListElemOpen(msgSpaceListElemId listElemId);

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,74 +1,66 @@
 #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;
+	msgPoolData *poolDataTabAddr;
 	int poolIndex;
 	int bufferIndex;
 	int err;
 	msgQueueElemId newElemId;
-  msgQueueElem * queueElem;
+	msgQueueElem *queueElem;
 	msgQueueId queueId;
-  msgQueue * queue;
+	msgQueue *queue;
 
 	msgPoolDataTabLock(space);
-  poolDataTabAddr=msgPoolDataTabOpen(space);
+	poolDataTabAddr = msgPoolDataTabOpen(space);
-  if (poolDataTabAddr == NULL){
+	if (poolDataTabAddr == NULL) {
-	NZG_ERROR("msgPoolDataTabOpen",space->poolDataTabId);
+		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);
+	msgQueueIdIntern(queueId, space->externId, queueIndex);
 
-  msgQueueProtLock(space->externId,queueIndex);
+	msgQueueProtLock(space->externId, queueIndex);
 	queue = msgQueueOpen(queueId);
 
 	// creer un element vide
 
-  msgQueueElemCreate(newElemId,queueId,queue->elemCounter);
+	msgQueueElemCreate(newElemId, queueId, queue->elemCounter);
 	// ouvrir l'element
-  queueElem=msgQueueElemOpen(newElemId);
+	queueElem = msgQueueElemOpen(newElemId);
 
 	// modifier les index pour retrouver le buffer
-  queueElem->poolIndex=poolIndex;
+	queueElem->poolIndex = poolIndex;
-  queueElem->bufferIndex=bufferIndex;
+	queueElem->bufferIndex = bufferIndex;
 
 	// fermer l'element
-  if (msgQueueElemClose(queueElem) <0 ){
+	if (msgQueueElemClose(queueElem) < 0) {
-	NZG_ERROR("msgQueueElemClose","");
+		NZG_ERROR("msgQueueElemClose", "");
 		goto ERROR;
 	}
-
 	//ajouter le message a la bonne file...
-  if (msgQueueAdd(queue,newElemId) < 0){
+	if (msgQueueAdd(queue, newElemId) < 0) {
-	NZG_ERROR("msgQueueAdd",newElemId);
+		NZG_ERROR("msgQueueAdd", newElemId);
 		goto ERROR;
 	}
-
 	// fermer la file
 	msgQueueClose(queue);
-  msgQueueProtUnlock(space->externId,queueIndex);
+	msgQueueProtUnlock(space->externId, queueIndex);
 
-  msgPoolDataTabClose(space,poolDataTabAddr);
+	msgPoolDataTabClose(space, poolDataTabAddr);
 	msgPoolDataTabUnlock(space);
 
 	// on laisse une nouvelle ressource de la liste au get
-  msgQueueReadUnlock(space->externId,queueIndex);
+	msgQueueReadUnlock(space->externId, queueIndex);
 	return 0;
 
-ERROR:
+ ERROR:
 	return -1;
 }
-
-

src/queueAdd.c

@@ -2,47 +2,48 @@
 
 // on ajoute en fin de queue...
 
-int msgQueueAdd(msgQueue * queue, msgQueueElemId newElemId){
+int msgQueueAdd(msgQueue * queue, msgQueueElemId newElemId)
-	msgQueueElem * queueOldTailElem;
+{
-	msgQueueElem * queueNewTailElem;
+	msgQueueElem *queueOldTailElem;
+	msgQueueElem *queueNewTailElem;
 
 	// on informe l'element qu'il est le dernier
-	queueNewTailElem=msgQueueElemOpen(newElemId);
+	queueNewTailElem = msgQueueElemOpen(newElemId);
-	if (queueNewTailElem == NULL){
+	if (queueNewTailElem == NULL) {
-	  NZG_ERROR("msgQueueElemOpen",newElemId);
+		NZG_ERROR("msgQueueElemOpen", newElemId);
 		goto ERROR;
 	}
-	strcpy(queueNewTailElem->next,newElemId);
+	strcpy(queueNewTailElem->next, newElemId);
- 	if (msgQueueElemClose(queueNewTailElem) <0 ){
+	if (msgQueueElemClose(queueNewTailElem) < 0) {
-	  NZG_ERROR("msgQueueElemClose",newElemId);
+		NZG_ERROR("msgQueueElemClose", newElemId);
 		goto ERROR;
 	}
 
 	/* TODO: verifier si la liste n'est pas vide... */
-	if((strcmp(queue->headId,queue->id)==0) 
+	if ((strcmp(queue->headId, queue->id) == 0)
-		&& (strcmp(queue->tailId,queue->id)==0)) {
+	    && (strcmp(queue->tailId, queue->id) == 0)) {
 		printf("- premier elem de queue -\n");
 		// on donne a la queue l'id de l'element
-	  strcpy(queue->headId,newElemId);
+		strcpy(queue->headId, newElemId);
-	  strcpy(queue->tailId,newElemId);
+		strcpy(queue->tailId, newElemId);
 	} else {
 		/* on informe son prédecesseur qu'il a un suivant */
-	  queueOldTailElem=msgQueueElemOpen(queue->tailId);
+		queueOldTailElem = msgQueueElemOpen(queue->tailId);
-	  if (queueOldTailElem == NULL){
+		if (queueOldTailElem == NULL) {
-		NZG_ERROR("msgQueueElemOpen",queue->tailId);
+			NZG_ERROR("msgQueueElemOpen", queue->tailId);
 			goto ERROR;
 		}
-	  strcpy(queueOldTailElem->next,newElemId);
+		strcpy(queueOldTailElem->next, newElemId);
-	  if (msgQueueElemClose(queueOldTailElem) < 0){
+		if (msgQueueElemClose(queueOldTailElem) < 0) {
-		NZG_ERROR("msgQueueElemClose",queue->tailId);
+			NZG_ERROR("msgQueueElemClose", queue->tailId);
 			goto ERROR;
 		}
 		// on donne a la queue l'id du dernier element
-	  strcpy(queue->tailId,newElemId);
+		strcpy(queue->tailId, newElemId);
 	}
 	// on incremente elemCounter
 	queue->elemCounter++;
 	return 0;
-ERROR:
+ ERROR:
 	return -1;
 }

src/queueClose.c

@@ -1,16 +1,17 @@
 #include "libnazgul.h"
 #include "ids.h"
 
-int msgQueueClose(msgQueue * queue){
+int msgQueueClose(msgQueue * queue)
+{
 	msgQueueId qId;
-  strcpy(qId,queue->id);
+	strcpy(qId, queue->id);
 
-  if (munmap(queue,sizeof(msgQueue)) < 0){
+	if (munmap(queue, sizeof(msgQueue)) < 0) {
-	NZG_ERROR("unmap",qId);
+		NZG_ERROR("unmap", qId);
 		goto ERROR;
 	}
 
 	return 0;
-ERROR: 
+ ERROR:
 	return -1;
 }

src/queueDelete.c

@@ -1,35 +1,34 @@
 #include "libnazgul.h"
 
-int msgQueueDelete(msgQueueId externId,int queueIdx){
+int msgQueueDelete(msgQueueId externId, int queueIdx)
-  msgQueue * queue;
+{
+	msgQueue *queue;
 	msgQueueId queueId;
 	msgQueueSemId queueProtLockSemId;
 	msgQueueSemId queueReadLockSemId;
 
-  msgQueueIdIntern(queueId,externId,queueIdx);
+	msgQueueIdIntern(queueId, externId, queueIdx);
 	queue = msgQueueOpen(queueId);
 
-  if (strcmp(queue->headId,queue->id)!=0){
+	if (strcmp(queue->headId, queue->id) != 0) {
 		// liste non-vide
-	if (msgQueueElemDelete(queue->headId) <0){
+		if (msgQueueElemDelete(queue->headId) < 0) {
-	  NZG_ERROR("msgQueueElemDelete",queue->headId);
+			NZG_ERROR("msgQueueElemDelete", queue->headId);
 			goto ERROR;
 		}
 	}
 
-  msgQueueProtSemIdIntern(queueProtLockSemId,externId,queueIdx);
+	msgQueueProtSemIdIntern(queueProtLockSemId, externId, queueIdx);
-  msgQueueReadSemIdIntern(queueReadLockSemId,externId,queueIdx);
+	msgQueueReadSemIdIntern(queueReadLockSemId, externId, queueIdx);
 	sem_unlink(queueProtLockSemId);
 	sem_unlink(queueReadLockSemId);
 
-  if (shm_unlink(queueId) < 0){
+	if (shm_unlink(queueId) < 0) {
-	NZG_ERROR("shm_unlink msgQueueElem",queueId);
+		NZG_ERROR("shm_unlink msgQueueElem", queueId);
 		goto ERROR;
 	}
 
 	return 0;
-ERROR:
+ ERROR:
 	return -1;
 }
-
-

src/queueElemClose.c

@@ -1,15 +1,16 @@
 #include "libnazgul.h"
 
-int msgQueueElemClose(msgQueueElem * queueElem){
+int msgQueueElemClose(msgQueueElem * queueElem)
+{
 	msgQueueElemId qId;
-  strcpy(qId,queueElem->id);
+	strcpy(qId, queueElem->id);
 
-  if (munmap(queueElem,sizeof(msgQueueElem)) < 0){
+	if (munmap(queueElem, sizeof(msgQueueElem)) < 0) {
-	NZG_ERROR("unmap",qId);
+		NZG_ERROR("unmap", qId);
 		goto ERROR;
 	}
 
 	return 0;
-ERROR: 
+ ERROR:
 	return -1;
 }

src/queueElemCreate.c

@@ -1,31 +1,30 @@
 #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;
 
-  msgQueueElemIdIntern(queueElemId,queueId,counter);
+	msgQueueElemIdIntern(queueElemId, queueId, counter);
-  strcpy(finalQueueElemId,queueElemId);
+	strcpy(finalQueueElemId, queueElemId);
 
-  queueElemFd=shm_open(queueElemId,
+	queueElemFd = shm_open(queueElemId,
-	  O_RDWR|O_CREAT|O_EXCL|O_TRUNC,
+			       O_RDWR | O_CREAT | O_EXCL | O_TRUNC,
 			       SHM_DEFAULT_MODE);
-  if (queueElemFd == -1 ) {
+	if (queueElemFd == -1) {
-	NZG_ERROR("shm_open : msgQueueElem creation",queueElemId);
+		NZG_ERROR("shm_open : msgQueueElem creation", queueElemId);
 		goto ERROR;
 	}
 
-  if (ftruncate(queueElemFd, sizeof(msgQueueElem)) < 0){
+	if (ftruncate(queueElemFd, sizeof(msgQueueElem)) < 0) {
 		NZG_ERROR("ftruncate", queueElemId);
 		goto ERROR;
 	}
 
 	close(queueElemFd);
 	return 0;
-ERROR:
+ ERROR:
 	return -1;
 }

src/queueElemDelete.c

@@ -1,26 +1,26 @@
 #include "libnazgul.h"
 
-int msgQueueElemDelete(msgQueueElemId queueElemId){
+int msgQueueElemDelete(msgQueueElemId queueElemId)
-  msgQueueElem * queueElem;
+{
+	msgQueueElem *queueElem;
 	msgQueueElemId nextIdToDie;
 
 	queueElem = msgQueueElemOpen(queueElemId);
-  if (queueElem==NULL){
+	if (queueElem == NULL) {
-	NZG_ERROR("msgQueueElemOpen",queueElemId);
+		NZG_ERROR("msgQueueElemOpen", queueElemId);
 		goto ERROR;
 	}
 
 	strcpy(nextIdToDie, queueElem->next);
 
-  if (msgQueueElemClose(queueElem) < 0){
+	if (msgQueueElemClose(queueElem) < 0) {
-  	NZG_ERROR("msgQueueElemClose",queueElemId);
+		NZG_ERROR("msgQueueElemClose", queueElemId);
 		goto ERROR;
 	}
-
 	// on détruit l'élément
 	shm_unlink(queueElemId);
 
-  if (nextIdToDie != queueElemId){
+	if (nextIdToDie != queueElemId) {
 		return msgQueueElemDelete(nextIdToDie);
 	} else {
 		printf("msgQueueElemDelete: EOL reached \n");
@@ -28,6 +28,6 @@ int msgQueueElemDelete(msgQueueElemId queueElemId){
 		return 0;
 	}
 
-ERROR:
+ ERROR:
 	return -1;
 }

src/queueElemOpen.c

@@ -1,29 +1,28 @@
 #include "libnazgul.h"
 #include "ids.h"
 
-void * msgQueueElemOpen(msgQueueElemId queueElemId){
+void *msgQueueElemOpen(msgQueueElemId queueElemId)
+{
 	int queueElemFd;
-  void * queueElemAddr;
+	void *queueElemAddr;
 
-  queueElemFd=shm_open(queueElemId,O_RDWR,SHM_DEFAULT_MODE);
+	queueElemFd = shm_open(queueElemId, O_RDWR, SHM_DEFAULT_MODE);
-  if (queueElemFd == -1 ) {
+	if (queueElemFd == -1) {
-	NZG_ERROR("shm_open : msgQueue open",queueElemId);
+		NZG_ERROR("shm_open : msgQueue open", queueElemId);
 		goto ERROR;
 	}
 
-  queueElemAddr=mmap(NULL,
+	queueElemAddr = mmap(NULL,
 			     sizeof(msgQueueElem),
-	  PROT_READ|PROT_WRITE,
+			     PROT_READ | PROT_WRITE,
-	  MAP_SHARED,
+			     MAP_SHARED, queueElemFd, 0);
-	  queueElemFd,
+	if (queueElemAddr == MAP_FAILED) {
-	  0);
+		NZG_ERROR("mmap", queueElemId);
-  if( queueElemAddr == MAP_FAILED ) {
-	NZG_ERROR("mmap",queueElemId);
 		goto ERROR;
 	}
 
 	close(queueElemFd);
 	return queueElemAddr;
-ERROR: 
+ ERROR:
 	return NULL;
 }

src/queueInit.c

@@ -1,33 +1,32 @@
 #include "libnazgul.h"
 #include "ids.h"
 
-msgQueue * msgQueueInit(msgSpaceId externId, int queueIdx) {
+msgQueue *msgQueueInit(msgSpaceId externId, int queueIdx)
+{
 	int queueFd;
-	msgQueue * queue;
+	msgQueue *queue;
-	sem_t * semProtectFd;
+	sem_t *semProtectFd;
 	msgQueueSemId queueSemProtectId;
-	sem_t * semReadableFd;
+	sem_t *semReadableFd;
 	msgQueueSemId queueSemReadableId;
 	msgQueueId queueId;
 
 	queue = NULL;
 
-
+	msgQueueProtSemIdIntern(queueSemProtectId, externId, queueIdx);
-	msgQueueProtSemIdIntern(queueSemProtectId,externId,queueIdx);
+	msgQueueReadSemIdIntern(queueSemReadableId, externId, queueIdx);
-	msgQueueReadSemIdIntern(queueSemReadableId,externId,queueIdx);
 
 	// creation du semaphore de lecture 
 	semReadableFd = sem_open(queueSemReadableId,
-		O_CREAT|O_EXCL, SEM_DEFAULT_MODE, 0);
+				 O_CREAT | O_EXCL, SEM_DEFAULT_MODE, 0);
-	if(semReadableFd == SEM_FAILED) {
+	if (semReadableFd == SEM_FAILED) {
 		NZG_ERROR("sem_open", queueSemReadableId);
 		goto ERROR;
 	}
-	
 	// creation du semaphore de protection
 	semProtectFd = sem_open(queueSemProtectId,
-		O_CREAT|O_EXCL, SEM_DEFAULT_MODE, 0);
+				O_CREAT | O_EXCL, SEM_DEFAULT_MODE, 0);
-	if(semProtectFd == SEM_FAILED) {
+	if (semProtectFd == SEM_FAILED) {
 		NZG_ERROR("sem_open", queueSemProtectId);
 		goto ERROR;
 	}
@@ -37,35 +36,36 @@ msgQueue * msgQueueInit(msgSpaceId externId, int queueIdx) {
 	  goto ERROR;
 	} */
 
-	if(msgQueueIdIntern(queueId, externId, queueIdx) < 0) {
+	if (msgQueueIdIntern(queueId, externId, queueIdx) < 0) {
 		return NULL;
 	}
 
-	queueFd = shm_open(queueId, O_RDWR|O_CREAT|O_EXCL|O_TRUNC, MSGSPACE_DEFAULT_MODE);
+	queueFd =
-	if(queueFd == -1) {
+	    shm_open(queueId, O_RDWR | O_CREAT | O_EXCL | O_TRUNC,
-	  NZG_ERROR("shm_open : queueInit",queueId);
+		     MSGSPACE_DEFAULT_MODE);
+	if (queueFd == -1) {
+		NZG_ERROR("shm_open : queueInit", queueId);
 		return NULL;
 	}
 
-	if(ftruncate(queueFd, sizeof(msgQueue)) == -1) {
+	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;
 	}
 
-	queue=msgQueueOpen(queueId);
+	queue = msgQueueOpen(queueId);
 	/* on remplit la structure msgQueue */
 	queue->elemCounter = 0;
-	strcpy(queue->id,queueId);
+	strcpy(queue->id, queueId);
-	strcpy(queue->headId,queue->id);
+	strcpy(queue->headId, queue->id);
-	strcpy(queue->tailId,queue->id);
+	strcpy(queue->tailId, queue->id);
 
 	/* on ferme tout ce qu'il faut */
 	close(queueFd);
-	msgQueueProtUnlock(externId,queueIdx);
+	msgQueueProtUnlock(externId, queueIdx);
 
 	return queue;
-ERROR:
+ ERROR:
 	return NULL;
 
 }

src/queueOpen.c

@@ -1,29 +1,27 @@
 #include "libnazgul.h"
 #include "ids.h"
 
-void * msgQueueOpen(msgQueueId queueId){
+void *msgQueueOpen(msgQueueId queueId)
+{
 	int queueFd;
-  void * queueAddr;
+	void *queueAddr;
 
-  queueFd=shm_open(queueId,O_RDWR,SHM_DEFAULT_MODE);
+	queueFd = shm_open(queueId, O_RDWR, SHM_DEFAULT_MODE);
-  if (queueFd == -1 ) {
+	if (queueFd == -1) {
-	NZG_ERROR("shm_open : msgQueue open",queueId);
+		NZG_ERROR("shm_open : msgQueue open", queueId);
 		goto ERROR;
 	}
 
-  queueAddr=mmap(NULL,
+	queueAddr = mmap(NULL,
 			 sizeof(msgQueue),
-	  PROT_READ|PROT_WRITE,
+			 PROT_READ | PROT_WRITE, MAP_SHARED, queueFd, 0);
-	  MAP_SHARED,
+	if (queueAddr == MAP_FAILED) {
-	  queueFd,
+		NZG_ERROR("mmap", queueId);
-	  0);
-  if( queueAddr == MAP_FAILED ) {
-	NZG_ERROR("mmap",queueId);
 		goto ERROR;
 	}
 
 	close(queueFd);
 	return queueAddr;
-ERROR: 
+ ERROR:
 	return NULL;
 }

src/queueProtLock.c

@@ -2,32 +2,36 @@
 #include "ids.h"
 
 #define DEBUG 0
-int msgQueueProtLock(msgSpaceId externId,int queueIdx){
+int msgQueueProtLock(msgSpaceId externId, int queueIdx)
+{
 	int semval;
-  sem_t * queueSemFd;
+	sem_t *queueSemFd;
 	msgQueueSemId queueSemId;
 
-  msgQueueProtSemIdIntern(queueSemId,externId,queueIdx);
+	msgQueueProtSemIdIntern(queueSemId, externId, queueIdx);
-  if (DEBUG) { printf("Locking %s\n",queueSemId);}
+	if (DEBUG) {
-  queueSemFd=sem_open(queueSemId,O_CREAT,SEM_DEFAULT_MODE,1);
+		printf("Locking %s\n", queueSemId);
-  if(queueSemFd==SEM_FAILED){
+	}
-	NZG_ERROR("sem_open",queueSemId);
+	queueSemFd = sem_open(queueSemId, O_CREAT, SEM_DEFAULT_MODE, 1);
+	if (queueSemFd == SEM_FAILED) {
+		NZG_ERROR("sem_open", queueSemId);
 		goto ERROR;
 	}
 
-  if(sem_wait(queueSemFd)==-1){
+	if (sem_wait(queueSemFd) == -1) {
-	NZG_ERROR("sem_wait",queueSemId);
+		NZG_ERROR("sem_wait", queueSemId);
 		goto ERROR;
 	}
-  semval=0;
+	semval = 0;
- sem_getvalue(queueSemFd,&semval);
+	sem_getvalue(queueSemFd, &semval);
- if (DEBUG) { printf("(AfterValue:%d)\n",semval); }
+	if (DEBUG) {
+		printf("(AfterValue:%d)\n", semval);
+	}
 
 	sem_close(queueSemFd);
 	sem_close(queueSemFd);
 
 	return 0;
-ERROR:
+ ERROR:
 	return -1;
 }
-

src/queueProtUnlock.c

@@ -3,32 +3,36 @@
 
 #define DEBUG 0
 
-int msgQueueProtUnlock(msgSpaceId externId,int queueIdx){
+int msgQueueProtUnlock(msgSpaceId externId, int queueIdx)
+{
 	int semval;
-  sem_t * queueSemFd;
+	sem_t *queueSemFd;
 	msgQueueSemId queueSemId;
 
-  msgQueueProtSemIdIntern(queueSemId,externId,queueIdx);
+	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);
+	queueSemFd = sem_open(queueSemId, O_CREAT, SEM_DEFAULT_MODE, 1);
-  if(queueSemFd==SEM_FAILED){
+	if (queueSemFd == SEM_FAILED) {
-	NZG_ERROR("sem_open",queueSemId);
+		NZG_ERROR("sem_open", queueSemId);
 		goto ERROR;
 	}
 
-  if(sem_post(queueSemFd)==-1){
+	if (sem_post(queueSemFd) == -1) {
-	NZG_ERROR("sem_post",queueSemId);
+		NZG_ERROR("sem_post", queueSemId);
 		goto ERROR;
 	}
-  semval=0;
+	semval = 0;
-  sem_getvalue(queueSemFd,&semval);
+	sem_getvalue(queueSemFd, &semval);
-  if (DEBUG) { printf("(AfterValue:%d)\n",semval); }
+	if (DEBUG) {
+		printf("(AfterValue:%d)\n", semval);
+	}
 
 	sem_close(queueSemFd);
 
 	return 0;
-ERROR:
+ ERROR:
 	return -1;
 }
-

src/queueReadLock.c

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

src/queueReadTryLock.c

@@ -3,31 +3,35 @@
 
 #define DEBUG 0
 
-int msgQueueReadTryLock(msgSpaceId externId,int queueIdx){
+int msgQueueReadTryLock(msgSpaceId externId, int queueIdx)
+{
 	int semval;
-  sem_t * queueSemFd;
+	sem_t *queueSemFd;
 	msgQueueSemId queueSemId;
 
-  msgQueueReadSemIdIntern(queueSemId,externId,queueIdx);
+	msgQueueReadSemIdIntern(queueSemId, externId, queueIdx);
-  queueSemFd=sem_open(queueSemId,O_CREAT,SEM_DEFAULT_MODE,1);
+	queueSemFd = sem_open(queueSemId, O_CREAT, SEM_DEFAULT_MODE, 1);
-  if(queueSemFd==SEM_FAILED){
+	if (queueSemFd == SEM_FAILED) {
-	NZG_ERROR("sem_open",queueSemId);
+		NZG_ERROR("sem_open", queueSemId);
 		goto ERROR;
 	}
 
-  if(sem_trywait(queueSemFd)==-1){
+	if (sem_trywait(queueSemFd) == -1) {
-	NZG_ERROR("sem_wait",queueSemId);
+		NZG_ERROR("sem_wait", queueSemId);
 		goto ERROR;
 	}
-  if (DEBUG) { printf("Locking %s\n",queueSemId); }
+	if (DEBUG) {
-  semval=0;
+		printf("Locking %s\n", queueSemId);
-  sem_getvalue(queueSemFd,&semval);
+	}
-  if (DEBUG) { printf("(AfterValue:%d)\n",semval); }
+	semval = 0;
+	sem_getvalue(queueSemFd, &semval);
+	if (DEBUG) {
+		printf("(AfterValue:%d)\n", semval);
+	}
 
 	sem_close(queueSemFd);
 
 	return 0;
-ERROR:
+ ERROR:
 	return -1;
 }
-

src/queueReadUnlock.c

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

src/queueRem.c

@@ -2,37 +2,36 @@
 
 // l'id de l'element enlevé vas dans oldElemId
 
-int msgQueueRem(msgQueue * queue, msgQueueElemId oldElemId){
+int msgQueueRem(msgQueue * queue, msgQueueElemId oldElemId)
-  msgQueueElem * queueOldHeadElem;
+{
+	msgQueueElem *queueOldHeadElem;
 
-	
+	if (strcmp(queue->headId, queue->id) == 0) {
-	if (strcmp(queue->headId,queue->id)==0){
+		NZG_ERROR("msgQueueElemRem : Empty queue", queue->id);
-	NZG_ERROR("msgQueueElemRem : Empty queue",queue->id);
 		goto ERROR;
 	}
-  strcpy(oldElemId,queue->headId);
+	strcpy(oldElemId, queue->headId);
 
-  queueOldHeadElem=msgQueueElemOpen(oldElemId);
+	queueOldHeadElem = msgQueueElemOpen(oldElemId);
-  if (queueOldHeadElem == NULL){
+	if (queueOldHeadElem == NULL) {
-	NZG_ERROR("msgQueueElemOpen",oldElemId);
+		NZG_ERROR("msgQueueElemOpen", oldElemId);
 		goto ERROR;
 	}
-
 	// on indique à la queue le nouveau premier element
-  strcpy(queue->headId,queueOldHeadElem->next);
+	strcpy(queue->headId, queueOldHeadElem->next);
-  if (strcmp(queueOldHeadElem->next,oldElemId)==0){
+	if (strcmp(queueOldHeadElem->next, oldElemId) == 0) {
-  strcpy(queue->headId,queue->id);
+		strcpy(queue->headId, queue->id);
 	}
 	// on fait en sorte que l'element ne connaisse plus
 	// ses voisins (utile pour le Delete)
-  strcpy(queueOldHeadElem->next,queueOldHeadElem->id);
+	strcpy(queueOldHeadElem->next, queueOldHeadElem->id);
 
-  if (msgQueueElemClose(queueOldHeadElem)<0 ){
+	if (msgQueueElemClose(queueOldHeadElem) < 0) {
-	NZG_ERROR("msgQueueElemClose",oldElemId);
+		NZG_ERROR("msgQueueElemClose", oldElemId);
 		goto ERROR;
 
 	}
 	return 0;
-ERROR:
+ ERROR:
 	return -1;
 }

src/spaceClose.c

@@ -1,15 +1,16 @@
 #include "libnazgul.h"
 
-int msgSpaceClose(msgSpace * space){
+int msgSpaceClose(msgSpace * space)
+{
 	msgSpaceId spaceId;
-  strcpy(spaceId,space->id);
+	strcpy(spaceId, space->id);
 
-  if (munmap(space,sizeof(msgSpace)) < 0){
+	if (munmap(space, sizeof(msgSpace)) < 0) {
-	NZG_ERROR("unmap",spaceId);
+		NZG_ERROR("unmap", spaceId);
 		goto ERROR;
 	}
 
 	return 0;
-ERROR:
+ ERROR:
 	return -1;
 }

src/spaceCreate.c

@@ -2,10 +2,10 @@
 #include "ids.h"
 
 /* prototypes des fonctions annexes à ne pas exporter */
-int msgSpaceIdIntern(msgSpaceId dest,const msgSpaceId src );
+int msgSpaceIdIntern(msgSpaceId dest, const msgSpaceId src);
-int msgPoolDataIdIntern(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,109 +13,105 @@ 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
 	int i;
 	int err;
-  static int mSIdNum=-1;
+	static int mSIdNum = -1;
-  msgSpace * space;
+	msgSpace *space;
 	msgSpaceListElemId listElemId;
 
 	msgPoolDataTabId poolDataTabId;
-  msgPoolData * poolDataTabAddr; 
+	msgPoolData *poolDataTabAddr;
 	msgBufferInfoTabId bufferInfoTabId;
 	msgPoolId poolId;
-  sem_t * mSDataTabSemFd;
+	sem_t *mSDataTabSemFd;
 
 	mSIdNum++;
-  space=NULL;
+	space = NULL;
   /** recuperation de la liste des msgSpace **/
 	/* (creation si elle n'existe pas */
 
   /** on créee le nouvel element **/
-  printf("PAGESIZE : %d\n",(int)PAGESIZE);
+	printf("PAGESIZE : %d\n", (int)PAGESIZE);
-  if (msgSpaceIdIntern(nzgId,externId) < 0){
+	if (msgSpaceIdIntern(nzgId, externId) < 0) {
 		return NULL;
 	}
 
-  if (msgSpaceListInit() <0){
+	if (msgSpaceListInit() < 0) {
-	NZG_ERROR("msgSpaceListInit",nzgId);
+		NZG_ERROR("msgSpaceListInit", nzgId);
 		goto ERROR;
 	};
-  if (msgSpaceListLock() <0){
+	if (msgSpaceListLock() < 0) {
-	NZG_ERROR("msgSpaceListLock","");
+		NZG_ERROR("msgSpaceListLock", "");
 		goto ERROR;
 	}
-  if ((err=msgSpaceListFindId(externId)) < 1){
+	if ((err = msgSpaceListFindId(externId)) < 1) {
-	if (err==0){
+		if (err == 0) {
 			// soit le msgSpace existe deja
-	  NZG_ERROR("spaceListFindId : existing ",nzgId);
+			NZG_ERROR("spaceListFindId : existing ", nzgId);
 		} else {
 			// zut, il y a soit une erreur
-	  NZG_ERROR("spaceListFindId : error ",nzgId);
+			NZG_ERROR("spaceListFindId : error ", nzgId);
 		}
 		msgSpaceListUnlock();
 		// on quitte
 		goto ERROR;
 	}
 	printf("spaceListFind ok\n");
-  if (msgSpaceListUnlock() < 0){
+	if (msgSpaceListUnlock() < 0) {
-	NZG_ERROR("msgSpaceListUnlock","");
+		NZG_ERROR("msgSpaceListUnlock", "");
 		goto ERROR;
 	}
 	printf("spaceListUnlock ok\n");
 
-  fprintf(stderr,"Creating msgSpace with id : %s\n",nzgId);
+	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,
-	  O_RDWR|O_CREAT|O_EXCL|O_TRUNC,
+			MSGSPACE_DEFAULT_MODE);
-	  MSGSPACE_DEFAULT_MODE
+	if (mSFd == -1) {
-	  );
+		NZG_ERROR("shm_open : msgSpace creation", nzgId);
-  if (mSFd == -1 ) {
-	NZG_ERROR("shm_open : msgSpace creation",nzgId);
 		goto ERROR;
 	}
 
 	/* on redimentionne l'element */
-  if (ftruncate(mSFd, sizeof(* space)) == -1){
+	if (ftruncate(mSFd, sizeof(*space)) == -1) {
-	NZG_ERROR("ftruncate",nzgId);
+		NZG_ERROR("ftruncate", nzgId);
 		goto ERROR;
 	}
 
 	/* Map the memory object */
-  space = mmap( 0, sizeof( *space ),
+	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) {
-  if( space == MAP_FAILED ) {
+		NZG_ERROR("mmap", nzgId);
-	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);
 
 	/* on remplit la structure */
-  strcpy(space->id,nzgId);
+	strcpy(space->id, nzgId);
-  space->poolNb=poolNb;
+	space->poolNb = poolNb;
-  space->queueNb=queueNb;
+	space->queueNb = queueNb;
-  space->pid=getpid();
+	space->pid = getpid();
-  msgPoolDataTabSemIdIntern(space->poolDataTabSemId,externId);
+	msgPoolDataTabSemIdIntern(space->poolDataTabSemId, externId);
 	/*  creation du poolData */
-  msgPoolDataIdIntern(poolDataTabId,externId);
+	msgPoolDataIdIntern(poolDataTabId, externId);
-  strcpy(space->poolDataTabId,poolDataTabId);
+	strcpy(space->poolDataTabId, poolDataTabId);
-  strcpy(space->externId,externId);
+	strcpy(space->externId, externId);
 
-  mSDataTabSemFd=sem_open(space->poolDataTabSemId,
+	mSDataTabSemFd = sem_open(space->poolDataTabSemId,
-	  O_CREAT|O_EXCL,SEM_DEFAULT_MODE,0);
+				  O_CREAT | O_EXCL, SEM_DEFAULT_MODE, 0);
-  if (mSDataTabSemFd == SEM_FAILED){ 
+	if (mSDataTabSemFd == SEM_FAILED) {
 		NZG_ERROR("sem_open : creation de la ressource",
 			  space->poolDataTabSemId);
 		goto ERROR;
@@ -126,60 +122,67 @@ msgSpace * msgSpaceCreate(
 	sem_close(mSDataTabSemFd);
 
 	/*  attacher le tableau des msgPoolData */
-  poolDataTabAddr=msgPoolDataTabCreate(space);
+	poolDataTabAddr = msgPoolDataTabCreate(space);
-  if (poolDataTabAddr == NULL){
+	if (poolDataTabAddr == NULL) {
-	NZG_ERROR("msgPoolDataTabCreate",space->poolDataTabId);
+		NZG_ERROR("msgPoolDataTabCreate", space->poolDataTabId);
 		goto ERROR;
 	}
 
-  for (i=0;i<poolNb;i++){
+	for (i = 0; i < poolNb; i++) {
 		/* Pour chacun des poolData
 		 * - y écrire les informations passées en param
 		 * - creer les zones mémoires de chacune des pool
 		 */
 		// creation d'une pool
-	poolDataTabAddr[i].bufferNb=poolInfos[i].bufferNb;
+		poolDataTabAddr[i].bufferNb = poolInfos[i].bufferNb;
-	poolDataTabAddr[i].bufferSize=poolInfos[i].bufferSize;
+		poolDataTabAddr[i].bufferSize = poolInfos[i].bufferSize;
-	poolDataTabAddr[i].allocDispBuffer=0;
+		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) {
-		  (char*)poolId );
+			fprintf(stderr,
+				"msgBufferInfoTabId creation failed for id %s\n",
+				(char *)poolId);
 			return NULL;
 		}
-	strcpy(poolDataTabAddr[i].bufferInfoTabId,bufferInfoTabId);
+		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){
+		if (msgPoolIdIntern(poolId, externId, i) == -1) {
-	  fprintf( stderr, "msgPoolId creation failed for id %s\n",
+			fprintf(stderr, "msgPoolId creation failed for id %s\n",
-		  (char*)poolId );
+				(char *)poolId);
 			return NULL;
 		}
-	strcpy(poolDataTabAddr[i].poolId,poolId);
+		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++){
+	for (i = 0; i < queueNb; i++) {
-	printf("- queue %i...",i); fflush(stdout);
+		printf("- queue %i...", i);
-	if (msgQueueInit(space->externId,i) < 0){
+		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");
 	}
-  msgPoolDataTabClose(space,poolDataTabAddr);
+	msgPoolDataTabClose(space, poolDataTabAddr);
 	/* on ajoute spaceId a la liste des msgSpace connus */
 	printf("spaceListInit...\n");
 
 	printf("ok\n");
 	msgSpaceListLock();
 	printf("spaceListLock...ok\n");
-  msgSpaceListElemCreate(listElemId,space);
+	msgSpaceListElemCreate(listElemId, space);
 	printf("spaceListElemCreate...ok\n");
 	msgSpaceListAdd(listElemId);
 	printf("spaceListAdd...ok\n");
@@ -189,9 +192,6 @@ msgSpace * msgSpaceCreate(
 	/* on renvoie un pointeur sur le bon spaceId */
 	msgPoolDataTabUnlock(space);
 	return space;
-ERROR:
+ ERROR:
 	return NULL;
 }
-
-
-

src/spaceDelete.c

@@ -2,66 +2,66 @@
 #include "ids.h"
 
 /* prototypes des fonctions annexes à ne pas exporter */
-int msgSpaceIdIntern(msgSpaceId dest,const msgSpaceId src );
+int msgSpaceIdIntern(msgSpaceId dest, const msgSpaceId src);
-int msgPoolDataIdIntern(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;
+	msgSpace *space;
 	int i;
-  fprintf(stderr,"Deleting msgSpace with id : %s\n",externId);
+	fprintf(stderr, "Deleting msgSpace with id : %s\n", externId);
-  if (msgSpaceIdIntern(nzgId,externId) == -1){
+	if (msgSpaceIdIntern(nzgId, externId) == -1) {
-	NZG_ERROR("msgSpaceIdIntern",externId);
+		NZG_ERROR("msgSpaceIdIntern", externId);
 		goto ERROR;
 	}
 
 	space = msgSpaceOpen(externId);
 	/* supprimer chaque pool */
-  for (i=0;i<space->poolNb;i++){
+	for (i = 0; i < space->poolNb; i++) {
-	msgPoolDelete(externId,i);
+		msgPoolDelete(externId, i);
 	}
 
 	/* supprimer chaque queue */
-  for (i=0;i<space->queueNb;i++){
+	for (i = 0; i < space->queueNb; i++) {
-	msgQueueDelete(externId,i);
+		msgQueueDelete(externId, i);
 	}
 	printf("openned successfully !\n");
 	printf("Unlinking DataTab... ");
-  if (shm_unlink(space->poolDataTabId) < 0){
+	if (shm_unlink(space->poolDataTabId) < 0) {
 		perror("shm_unlink");
 		return -1;
 	}
 	printf("ok\n");
 
 	printf("Unlinking DataTabSem... ");
-  if (sem_unlink(space->poolDataTabSemId) < 0){
+	if (sem_unlink(space->poolDataTabSemId) < 0) {
-	NZG_ERROR("sem_unlink",space->poolDataTabSemId);
+		NZG_ERROR("sem_unlink", space->poolDataTabSemId);
 		return -1;
 	}
 	printf("ok\n");
 
-  if (shm_unlink(nzgId)<0){
+	if (shm_unlink(nzgId) < 0) {
-	NZG_ERROR("shm_unlink",nzgId);
+		NZG_ERROR("shm_unlink", nzgId);
 		goto ERROR;
 	};
-  if (msgSpaceListLock()<0){
+	if (msgSpaceListLock() < 0) {
-	NZG_ERROR("msgSpaceListLock","");
+		NZG_ERROR("msgSpaceListLock", "");
 		goto ERROR;
 	}
 
-  if (msgSpaceListRem(nzgId) < 0){
+	if (msgSpaceListRem(nzgId) < 0) {
-	NZG_ERROR("msgSpaceListRem",nzgId);
+		NZG_ERROR("msgSpaceListRem", nzgId);
 		goto ERROR;
 	}
-  if (msgSpaceListUnlock()< 0){
+	if (msgSpaceListUnlock() < 0) {
-	NZG_ERROR("msgSpaceListUnlock","");
+		NZG_ERROR("msgSpaceListUnlock", "");
 		goto ERROR;
 	}
 	return 0;
-ERROR:
+ ERROR:
 	return -1;
 }
-

src/spaceListAdd.c

@@ -3,54 +3,55 @@
 // 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;
+	msgSpaceListElem *listOldTailElem;
-	msgSpaceList * list;
+	msgSpaceListElem *listNewTailElem;
+	msgSpaceList *list;
 
-	list=msgSpaceListOpen();
+	list = msgSpaceListOpen();
-	if (list == NULL){
+	if (list == NULL) {
-	  NZG_ERROR("msgSpaceListOpen","");
+		NZG_ERROR("msgSpaceListOpen", "");
 		goto ERROR;
 	}
 	// on informe l'element qui est le dernier
-	listNewTailElem=msgSpaceListElemOpen(newElemId);
+	listNewTailElem = msgSpaceListElemOpen(newElemId);
-	if (listNewTailElem==NULL){
+	if (listNewTailElem == NULL) {
-	  NZG_ERROR("msgSpaceListElemOpen",newElemId);
+		NZG_ERROR("msgSpaceListElemOpen", newElemId);
 		goto ERROR;
 	}
-	strcpy(listNewTailElem->next,newElemId);
+	strcpy(listNewTailElem->next, newElemId);
-	if (msgSpaceListElemClose(listNewTailElem) <0 ){
+	if (msgSpaceListElemClose(listNewTailElem) < 0) {
-	  NZG_ERROR("msgSpaceListElemClose",newElemId);
+		NZG_ERROR("msgSpaceListElemClose", newElemId);
 		goto ERROR;
 	}
 
 	/* verifier si la liste n'est pas vide... */
-	if((strcmp(list->headId,list->id)==0) 
+	if ((strcmp(list->headId, list->id) == 0)
-		&& (strcmp(list->tailId,list->id)==0)) {
+	    && (strcmp(list->tailId, list->id) == 0)) {
 		printf("- premier elem de spaceList -\n");
 		// on donne a la queue l'id de l'element
-	  strcpy(list->headId,newElemId);
+		strcpy(list->headId, newElemId);
-	  strcpy(list->tailId,newElemId);
+		strcpy(list->tailId, newElemId);
 	} else {
 		/* on informe son prédecesseur qu'il a un suivant */
-	  listOldTailElem=msgSpaceListElemOpen(list->tailId);
+		listOldTailElem = msgSpaceListElemOpen(list->tailId);
-	  if (listOldTailElem == NULL){
+		if (listOldTailElem == NULL) {
-		NZG_ERROR("msgSpaceListElemOpen",list->tailId);
+			NZG_ERROR("msgSpaceListElemOpen", list->tailId);
 			goto ERROR;
 		}
-	  strcpy(listOldTailElem->next,newElemId);
+		strcpy(listOldTailElem->next, newElemId);
-	  if (msgSpaceListElemClose(listOldTailElem) < 0){
+		if (msgSpaceListElemClose(listOldTailElem) < 0) {
-		NZG_ERROR("msgSpaceListElemClose",list->tailId);
+			NZG_ERROR("msgSpaceListElemClose", list->tailId);
 			goto ERROR;
 		}
 		// on donne a la queue l'id du dernier element
-	  strcpy(list->tailId,newElemId);
+		strcpy(list->tailId, newElemId);
 	}
 	// on incremente elemCounter
 	msgSpaceListClose(list);
 	return 0;
-ERROR:
+ ERROR:
 	return -1;
 
 }

src/spaceListClose.c

@@ -1,17 +1,18 @@
 #include "libnazgul.h"
 #include "ids.h"
 
-int msgSpaceListClose(msgSpaceList * list){
+int msgSpaceListClose(msgSpaceList * list)
+{
 
 	msgSpaceListId spaceListId;
-  strcpy(spaceListId,DEFAULT_MSGSPACELISTID);
+	strcpy(spaceListId, DEFAULT_MSGSPACELISTID);
 
-  if (munmap(list,sizeof(msgSpaceList)) < 0){
+	if (munmap(list, sizeof(msgSpaceList)) < 0) {
-	NZG_ERROR("unmap",spaceListId);
+		NZG_ERROR("unmap", spaceListId);
 		goto ERROR;
 	}
 
 	return 0;
-ERROR: 
+ ERROR:
 	return -1;
 }

src/spaceListElemClose.c

@@ -5,14 +5,14 @@ int msgSpaceListElemClose(msgSpaceListElem * listElem)
 {
 
 	msgSpaceListElemId eId;
-  strcpy(eId,listElem->id);
+	strcpy(eId, listElem->id);
 
-  if (munmap(listElem,sizeof(msgSpaceListElem)) < 0){
+	if (munmap(listElem, sizeof(msgSpaceListElem)) < 0) {
-	NZG_ERROR("unmap",eId);
+		NZG_ERROR("unmap", eId);
 		goto ERROR;
 	}
 
 	return 0;
-ERROR:
+ ERROR:
-  return-1;
+	return -1;
 };

src/spaceListElemCreate.c

@@ -2,47 +2,43 @@
 #include "ids.h"
 
 // cree un nouvel elemen
-int msgSpaceListElemCreate(
+int msgSpaceListElemCreate(msgSpaceListElemId listElemId, msgSpace * space)
-	msgSpaceListElemId listElemId,
-	msgSpace * space)
 {
 
 	int listElemFd;
-  msgSpaceListElem * listElem;
+	msgSpaceListElem *listElem;
-  msgSpaceListElemIdIntern(listElemId,space->externId);
+	msgSpaceListElemIdIntern(listElemId, space->externId);
 
-  listElemFd=shm_open(listElemId,
+	listElemFd = shm_open(listElemId,
-	  O_RDWR|O_CREAT|O_EXCL|O_TRUNC,
+			      O_RDWR | O_CREAT | O_EXCL | O_TRUNC,
 			      SHM_DEFAULT_MODE);
 
-  if (listElemFd == -1 ) {
+	if (listElemFd == -1) {
-	NZG_ERROR("shm_open : msgSpaceListElem creation",listElemId);
+		NZG_ERROR("shm_open : msgSpaceListElem creation", listElemId);
 		goto ERROR;
 	}
 
-  if (ftruncate(listElemFd, sizeof(msgSpaceListElem)) < 0){
+	if (ftruncate(listElemFd, sizeof(msgSpaceListElem)) < 0) {
 		NZG_ERROR("ftruncate", listElemId);
 		goto ERROR;
 	}
 
 	close(listElemFd);
-  listElem=msgSpaceListElemOpen(listElemId);
+	listElem = msgSpaceListElemOpen(listElemId);
-  if (listElem ==NULL){
+	if (listElem == NULL) {
-	NZG_ERROR("msgSpaceListElemOpen",listElemId);
+		NZG_ERROR("msgSpaceListElemOpen", listElemId);
 		goto ERROR;
 	}
-  strcpy(listElem->id,listElemId);
+	strcpy(listElem->id, listElemId);
-  strcpy(listElem->next,listElemId);
+	strcpy(listElem->next, listElemId);
-  strcpy(listElem->spaceId,space->id);
+	strcpy(listElem->spaceId, space->id);
 	printf("[ ListElem : id %s,next: %s, Sid: %s ]\n",
-	  listElem->id,
+	       listElem->id, listElem->next, listElem->spaceId);
-	  listElem->next,
+	if (msgSpaceListElemClose(listElem) < 0) {
-	  listElem->spaceId);
+		NZG_ERROR("msgSpaceListElemClose", listElemId);
-  if (msgSpaceListElemClose(listElem) <0){
-	NZG_ERROR("msgSpaceListElemClose",listElemId);
 	}
 	return 0;
-ERROR:
+ ERROR:
 	return -1;
 
 };

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,32 +2,29 @@
 #include "ids.h"
 
 // cree un nouvel elemen
-void * msgSpaceListElemOpen(msgSpaceListElemId listElemId){
+void *msgSpaceListElemOpen(msgSpaceListElemId listElemId)
+{
 	int listElemFd;
-  void * listElemAddr;
+	void *listElemAddr;
 
-  listElemFd=shm_open(listElemId,O_RDWR,SHM_DEFAULT_MODE);
+	listElemFd = shm_open(listElemId, O_RDWR, SHM_DEFAULT_MODE);
-  if (listElemFd == -1 ) {
+	if (listElemFd == -1) {
-	NZG_ERROR("shm_open : msgSpaceListElem open",listElemId);
+		NZG_ERROR("shm_open : msgSpaceListElem open", listElemId);
 		goto ERROR;
 	}
 
-  listElemAddr=mmap(NULL,
+	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 ) {
+	if (listElemAddr == MAP_FAILED) {
-	NZG_ERROR("mmap",listElemId);
+		NZG_ERROR("mmap", listElemId);
 		goto ERROR;
 	}
 
 	close(listElemFd);
 	return listElemAddr;
-ERROR: 
+ ERROR:
 	return NULL;
 
-
 };

src/spaceListFindId.c

@@ -2,78 +2,84 @@
 
 #define DEBUG 1
 
-int msgSpaceListFindId(msgSpaceId externId){
+int msgSpaceListFindId(msgSpaceId externId)
-  msgSpaceList * list;
+{
+	msgSpaceList *list;
 	msgSpaceId spaceId;
 	msgSpaceListElemId listHeadElemId;
 	msgSpaceListElemId listTailElemId;
 	msgSpaceListId listId;
 
-  msgSpaceIdIntern(spaceId,externId);
+	msgSpaceIdIntern(spaceId, externId);
-  list=msgSpaceListOpen();
+	list = msgSpaceListOpen();
-  if (list==NULL){
+	if (list == NULL) {
-	NZG_ERROR("msgSpaceListOpen","");
+		NZG_ERROR("msgSpaceListOpen", "");
 		goto ERROR;
 	}
-  if (DEBUG) { printf("Before ListStrCpy\n"); }
+	if (DEBUG) {
-  strcpy(listHeadElemId,list->headId);
+		printf("Before ListStrCpy\n");
-  strcpy(listTailElemId,list->tailId);
+	}
-  strcpy(listId,list->id);
+	strcpy(listHeadElemId, list->headId);
-  if (DEBUG) { printf("After ListStrCpy\n"); }
+	strcpy(listTailElemId, list->tailId);
-  if ((strcmp(listHeadElemId,listId)==0) 
+	strcpy(listId, list->id);
-	  && strcmp(listTailElemId,listId)==0){
+	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);
+		return msgSpaceListElemFindId(listHeadElemId, spaceId);
 	}
-  if (msgSpaceListClose(list) < 0){
+	if (msgSpaceListClose(list) < 0) {
-	NZG_ERROR("msgSpaceListClose","");
+		NZG_ERROR("msgSpaceListClose", "");
 		goto ERROR;
 	}
 	return 0;
-ERROR:
+ ERROR:
-return -1;
+	return -1;
 }
 
-int msgSpaceListElemFindId(msgSpaceListElemId elemId,msgSpaceId spaceId){
+int msgSpaceListElemFindId(msgSpaceListElemId elemId, msgSpaceId spaceId)
-  msgSpaceListElem * listElem;
+{
+	msgSpaceListElem *listElem;
 	msgSpaceListElemId listElemIdNext;
 	msgSpaceId currentElemSpaceId;
 
-  listElem=msgSpaceListElemOpen(elemId);
+	listElem = msgSpaceListElemOpen(elemId);
-  if (listElem==NULL){
+	if (listElem == NULL) {
-	NZG_ERROR("msgSpaceListElemOpen",elemId);
+		NZG_ERROR("msgSpaceListElemOpen", elemId);
 		goto ERROR;
 	}
-  strcpy(listElemIdNext,listElem->next);
+	strcpy(listElemIdNext, listElem->next);
-  strcpy(currentElemSpaceId,listElem->spaceId);
+	strcpy(currentElemSpaceId, listElem->spaceId);
-  if (msgSpaceListElemClose(listElem) < 0){
+	if (msgSpaceListElemClose(listElem) < 0) {
-	NZG_ERROR("msgSpaceListElemClose",elemId);
+		NZG_ERROR("msgSpaceListElemClose", elemId);
 		goto ERROR;
 	}
 
 	printf("Current ListElem: Next:%s, Sid:%s\n",
-	  listElemIdNext,currentElemSpaceId);
+	       listElemIdNext, currentElemSpaceId);
 	printf("comparisons...\n");
-  if (strcmp(currentElemSpaceId,spaceId)==0) {
+	if (strcmp(currentElemSpaceId, spaceId) == 0) {
-	printf("Found %s in spaceList !\n",spaceId);
+		printf("Found %s in spaceList !\n", spaceId);
 		return 0;
 	} else {
-	if (strcmp(listElemIdNext,elemId)==0){
+		if (strcmp(listElemIdNext, elemId) == 0) {
 			printf("End of spaceList reached.\n");
 			/* fin de liste ?? */
 			return 1;
 		} else {
 			/* continuer sur l'element suivant */
-	  return msgSpaceListElemFindId(listElemIdNext,spaceId);
+			return msgSpaceListElemFindId(listElemIdNext, spaceId);
 		}
 	}
 
 	return 0;
-ERROR:
+ ERROR:
 	return -1;
 }
-
-

src/spaceListInit.c

@@ -1,76 +1,73 @@
 #include "libnazgul.h"
 #include "ids.h"
 
-int msgSpaceListInit(){
+int msgSpaceListInit()
+{
 	int spaceListFd;
-  sem_t * spaceListSemFd;
+	sem_t *spaceListSemFd;
 	msgSpaceList *list;
 
 	msgSpaceListSemId spaceListSemId;
 	msgSpaceListId spaceListId;
 
-  strcpy(spaceListSemId,DEFAULT_MSGSPACELISTSEMID);
+	strcpy(spaceListSemId, DEFAULT_MSGSPACELISTSEMID);
-  strcpy(spaceListId,DEFAULT_MSGSPACELISTID);
+	strcpy(spaceListId, DEFAULT_MSGSPACELISTID);
 
 	/* Creation de semaphore */
-  spaceListSemFd=sem_open(spaceListSemId,O_CREAT|O_EXCL,0666,0);
+	spaceListSemFd = sem_open(spaceListSemId, O_CREAT | O_EXCL, 0666, 0);
-  if(spaceListSemFd==SEM_FAILED){
+	if (spaceListSemFd == SEM_FAILED) {
-	spaceListSemFd=sem_open(spaceListSemId,O_CREAT,0666,0);
+		spaceListSemFd = sem_open(spaceListSemId, O_CREAT, 0666, 0);
-	if(spaceListSemFd==SEM_FAILED){
+		if (spaceListSemFd == SEM_FAILED) {
-	  NZG_ERROR("sem_open",spaceListSemId);
+			NZG_ERROR("sem_open", spaceListSemId);
 			goto ERROR;
 		}
 	}
 
-
+	/*Fait un segment de memoir partager sur espace de listelement */
-
+	spaceListFd = shm_open(spaceListId,
-  /*Fait un segment de memoir partager sur espace de listelement*/
+			       O_RDWR | O_CREAT | O_EXCL | O_TRUNC, 0666);
-  spaceListFd=shm_open(spaceListId,
+	if (spaceListFd == -1) {
-	  O_RDWR|O_CREAT|O_EXCL|O_TRUNC,
+		spaceListFd = shm_open(spaceListId, O_RDWR, 0666);
-	  0666);
+		if (spaceListFd == -1) {
-  if (spaceListFd == -1){
+			NZG_ERROR("shm_open", spaceListId);
-	spaceListFd=shm_open(spaceListId,O_RDWR,0666);	
-	if (spaceListFd == -1){
-	  NZG_ERROR("shm_open",spaceListId);
 			goto ERROR;
 		} else {
 			close(spaceListFd);
 			goto EXISTING;
 		}
 	}
-  if (ftruncate(spaceListFd, sizeof(msgSpaceList)) < 0){
+	if (ftruncate(spaceListFd, sizeof(msgSpaceList)) < 0) {
-	NZG_ERROR("ftruncate",spaceListId);
+		NZG_ERROR("ftruncate", spaceListId);
 		goto ERROR;
 	}
 	close(spaceListFd);
 
-  list=msgSpaceListOpen();
+	list = msgSpaceListOpen();
-  if (list == NULL){
+	if (list == NULL) {
-	NZG_ERROR("msgSpaceListOpen","");
+		NZG_ERROR("msgSpaceListOpen", "");
 		goto ERROR;
 	}
-  strcpy(list->id,spaceListId);
+	strcpy(list->id, spaceListId);
-  strcpy(list->headId,spaceListId);
+	strcpy(list->headId, spaceListId);
-  strcpy(list->tailId,spaceListId);
+	strcpy(list->tailId, spaceListId);
-  if (msgSpaceListClose(list) <0){
+	if (msgSpaceListClose(list) < 0) {
-	NZG_ERROR("msgSpaceListClose","");
+		NZG_ERROR("msgSpaceListClose", "");
 		goto ERROR;
 	}
 
-  if (msgSpaceListUnlock() < 0){
+	if (msgSpaceListUnlock() < 0) {
-	NZG_ERROR("msgSpaceListUnlock","");
+		NZG_ERROR("msgSpaceListUnlock", "");
 		goto ERROR;
 	}
 
 	return 0;
-ERROR:
+ ERROR:
 	return -1;
-EXISTING:
+ EXISTING:
-  if (msgSpaceListUnlock() < 0){
+	if (msgSpaceListUnlock() < 0) {
-	NZG_ERROR("msgSpaceListUnlock","");
+		NZG_ERROR("msgSpaceListUnlock", "");
 		goto ERROR;
 	}
 
 	return 0;
 };
-

src/spaceListLocking.c

@@ -1,69 +1,65 @@
 #include "libnazgul.h"
 
-
 // verouille le semaphore de la liste
 
-int msgSpaceListLock(){
+int msgSpaceListLock()
-  sem_t * msgSpaceListSemFd;
+{
+	sem_t *msgSpaceListSemFd;
 	msgSpaceListSemId spaceListSemId;
-  strcpy(spaceListSemId,DEFAULT_MSGSPACELISTSEMID);
+	strcpy(spaceListSemId, DEFAULT_MSGSPACELISTSEMID);
 
 	/* Ouverture d'un semafore */
-  msgSpaceListSemFd=sem_open(spaceListSemId,O_CREAT,0666,1);
+	msgSpaceListSemFd = sem_open(spaceListSemId, O_CREAT, 0666, 1);
-  if(msgSpaceListSemFd==SEM_FAILED){
+	if (msgSpaceListSemFd == SEM_FAILED) {
-	NZG_ERROR("sem_open",spaceListSemId);
+		NZG_ERROR("sem_open", spaceListSemId);
 		goto ERROR;
 	}
 
 	/* Pose d'un semaphore et le verrouille */
-  if(sem_wait(msgSpaceListSemFd)==-1){
+	if (sem_wait(msgSpaceListSemFd) == -1) {
-	NZG_ERROR("sem_wait",spaceListSemId);
+		NZG_ERROR("sem_wait", spaceListSemId);
 		goto ERROR;
 	}
 
-  /*	Ferme le semaphore*/
+	/*    Ferme le semaphore */
 	/*            if(sem_close(msgSpaceListSemFd)==-1){
 	   NZG_ERROR("sem_close",spaceListSemId);
 	   return -1;
-			}*/
+	   } */
 	sem_close(msgSpaceListSemFd);
 
 	return 0;
-ERROR:
+ ERROR:
 	return -1;
 }
 
-
 // deverouille le semaphore de la liste
-int msgSpaceListUnlock(){
+int msgSpaceListUnlock()
-  sem_t * msgSpaceListSemFd;
+{
+	sem_t *msgSpaceListSemFd;
 	msgSpaceListSemId spaceListSemId;
-  strcpy(spaceListSemId,DEFAULT_MSGSPACELISTSEMID);
+	strcpy(spaceListSemId, DEFAULT_MSGSPACELISTSEMID);
 
-
+	/*Ouverture dun semaphore */
-  /*Ouverture dun semaphore*/
+	msgSpaceListSemFd = sem_open(spaceListSemId, O_CREAT, 0666, 0);
-  msgSpaceListSemFd=sem_open(spaceListSemId,O_CREAT,0666,0);
+	if (msgSpaceListSemFd == SEM_FAILED) {
-  if(msgSpaceListSemFd==SEM_FAILED){
+		NZG_ERROR("sem_open", spaceListSemId);
-	NZG_ERROR("sem_open",spaceListSemId);
 		goto ERROR;
 	}
 
-
+	/*Relachement du semaphore */
-  /*Relachement du semaphore*/
+	if (sem_post(msgSpaceListSemFd) == -1) {
-  if(sem_post(msgSpaceListSemFd)==-1){
+		NZG_ERROR("sem_relache", spaceListSemId);
-	NZG_ERROR("sem_relache",spaceListSemId);
 		goto ERROR;
 	}
 
-
 	/*    Ferme le semaphore */
-  if(sem_close(msgSpaceListSemFd)==-1){
+	if (sem_close(msgSpaceListSemFd) == -1) {
-	NZG_ERROR("sem_close",spaceListSemId);
+		NZG_ERROR("sem_close", spaceListSemId);
 		goto ERROR;
 	}
 
 	return 0;
-ERROR:
+ ERROR:
 	return -1;
 };
-

src/spaceListOpen.c

@@ -1,32 +1,30 @@
 #include "libnazgul.h"
 #include "ids.h"
 
-void * msgSpaceListOpen(){
+void *msgSpaceListOpen()
+{
 	int listFd;
-  void * listAddr;
+	void *listAddr;
 
 	msgSpaceListId spaceListId;
-  strcpy(spaceListId,DEFAULT_MSGSPACELISTID);
+	strcpy(spaceListId, DEFAULT_MSGSPACELISTID);
 
-  listFd=shm_open(spaceListId,O_RDWR,SHM_DEFAULT_MODE);
+	listFd = shm_open(spaceListId, O_RDWR, SHM_DEFAULT_MODE);
-  if (listFd == -1 ) {
+	if (listFd == -1) {
-	NZG_ERROR("shm_open : msgSpaceList open",spaceListId);
+		NZG_ERROR("shm_open : msgSpaceList open", spaceListId);
 		goto ERROR;
 	}
 
-  listAddr=mmap(NULL,
+	listAddr = mmap(NULL,
 			sizeof(msgSpaceList),
-	  PROT_READ|PROT_WRITE,
+			PROT_READ | PROT_WRITE, MAP_SHARED, listFd, 0);
-	  MAP_SHARED,
+	if (listAddr == MAP_FAILED) {
-	  listFd,
+		NZG_ERROR("mmap", spaceListId);
-	  0);
-  if( listAddr == MAP_FAILED ) {
-	NZG_ERROR("mmap",spaceListId);
 		goto ERROR;
 	}
 
 	close(listFd);
 	return listAddr;
-ERROR: 
+ ERROR:
 	return NULL;
 }

src/spaceListRem.c

@@ -2,8 +2,9 @@
 
 #define DEBUG 1
 
-int msgSpaceListRem(msgSpaceId spaceId){
+int msgSpaceListRem(msgSpaceId spaceId)
-  msgSpaceList * list;
+{
+	msgSpaceList *list;
 	msgSpaceListElemId listHeadElemId;
 	msgSpaceListElemId listTailElemId;
 	msgSpaceListId listId;
@@ -12,99 +13,116 @@ int msgSpaceListRem(msgSpaceId spaceId){
 	msgSpaceListElemId currElemId;
 	msgSpaceListElemId nextElemId;
 
-  msgSpaceListElem * prevElem;
+	msgSpaceListElem *prevElem;
-  msgSpaceListElem * currElem;
+	msgSpaceListElem *currElem;
 	msgSpaceId currSpaceId;
 
-  list=msgSpaceListOpen();
+	list = msgSpaceListOpen();
-  if (list==NULL){
+	if (list == NULL) {
-	NZG_ERROR("msgSpaceListOpen","");
+		NZG_ERROR("msgSpaceListOpen", "");
 		goto ERROR;
 	}
-  if (DEBUG) { printf("Before ListStrCpy\n"); }
+	if (DEBUG) {
-  strcpy(listHeadElemId,list->headId);
+		printf("Before ListStrCpy\n");
-  strcpy(listTailElemId,list->tailId);
+	}
-  strcpy(listId,list->id);
+	strcpy(listHeadElemId, list->headId);
-  if (DEBUG) { printf("After ListStrCpy\n"); }
+	strcpy(listTailElemId, list->tailId);
-  if ((strcmp(listHeadElemId,listId)==0) 
+	strcpy(listId, list->id);
-	  && strcmp(listTailElemId,listId)==0){
+	if (DEBUG) {
-	if (DEBUG) { printf("SpaceList : vide\n"); }
+		printf("After ListStrCpy\n");
+	}
+	if ((strcmp(listHeadElemId, listId) == 0)
+	    && strcmp(listTailElemId, listId) == 0) {
+		if (DEBUG) {
+			printf("SpaceList : vide\n");
+		}
 		return 1;
 	} else {
-	bool found=false;
+		bool found = false;
 
-	strcpy(prevElemId,list->headId);
+		strcpy(prevElemId, list->headId);
-	strcpy(currElemId,list->headId);
+		strcpy(currElemId, list->headId);
-	while(!found){
+		while (!found) {
-	  printf("Recherche dans l'element %s\n",listHeadElemId);
+			printf("Recherche dans l'element %s\n", listHeadElemId);
-	  currElem=msgSpaceListElemOpen(currElemId);
+			currElem = msgSpaceListElemOpen(currElemId);
-	  if (currElem==NULL){
+			if (currElem == NULL) {
-		NZG_ERROR("msgSpaceListElemOpen",currElemId);
+				NZG_ERROR("msgSpaceListElemOpen", currElemId);
 				goto ERROR;
 			}
-	  strcpy(nextElemId,currElem->next);
+			strcpy(nextElemId, currElem->next);
-	  strcpy(currSpaceId,currElem->spaceId);
+			strcpy(currSpaceId, currElem->spaceId);
-	  if (msgSpaceListElemClose(currElem) <0){
+			if (msgSpaceListElemClose(currElem) < 0) {
-		NZG_ERROR("msgSpaceListElemClose",currElemId);
+				NZG_ERROR("msgSpaceListElemClose", currElemId);
 				goto ERROR;
 			}
-	  if (strcmp(prevElemId,nextElemId)==0){
+			if (strcmp(prevElemId, nextElemId) == 0) {
 				// list à 1 seul élement
-		if (strcmp(currSpaceId,spaceId)==0){
+				if (strcmp(currSpaceId, spaceId) == 0) {
 					// on a trouvé l'elem
-		  strcpy(list->headId,list->id);
+					strcpy(list->headId, list->id);
-		  strcpy(list->tailId,list->id);
+					strcpy(list->tailId, list->id);
 					// on efface
 					shm_unlink(currElemId);
-		  found=true;
+					found = true;
 				} else {
 					break;
 				}
 			} else {
 				// liste à plusieurs élements...
-		if (strcmp(currSpaceId,spaceId)==0){
+				if (strcmp(currSpaceId, spaceId) == 0) {
 					// ca correspond
-		  if (strcmp(prevElemId,currElemId)==0){
+					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);
-			}else {
+							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
 					shm_unlink(currElemId);
-		  found=true;
+					found = true;
 					break;
 				} else {
 					//cela ne correspond pas
 					//on recopie
-		  strcpy(prevElemId,currElemId);
+					strcpy(prevElemId, currElemId);
-		  strcpy(currElemId,nextElemId);
+					strcpy(currElemId, nextElemId);
 				}
 			}
 
 		}
-	if (msgSpaceListClose(list) < 0){
+		if (msgSpaceListClose(list) < 0) {
-	  NZG_ERROR("msgSpaceListClose","");
+			NZG_ERROR("msgSpaceListClose", "");
 			goto ERROR;
 		}
 		return 0;
 	}
-ERROR:
+ ERROR:
 	return -1;
 }
-

src/spaceOpen.c

@@ -2,25 +2,26 @@
 #include "ids.h"
 
 /* prototypes des fonctions annexes à ne pas exporter */
-int msgSpaceIdIntern(msgSpaceId dest,const msgSpaceId src );
+int msgSpaceIdIntern(msgSpaceId dest, const msgSpaceId src);
-int msgPoolDataIdIntern(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;
+	msgSpace *mSAddr;
-  if (msgSpaceIdIntern(nzgId,externId) < 0){
+	if (msgSpaceIdIntern(nzgId, externId) < 0) {
 		return NULL;
 	}
-  if ((shmFd=shm_open(nzgId,O_RDWR,MSGSPACE_DEFAULT_MODE)) < 0){
+	if ((shmFd = shm_open(nzgId, O_RDWR, MSGSPACE_DEFAULT_MODE)) < 0) {
 		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,58 +6,57 @@
 
 #include "libnazgul.h"
 
-int main(void) {
+int main(void)
+{
 	//    msgSpace mS=0;
 
 	pid_t pid;
 	msgSpaceId testId;
-  msgSpace * mSPAC;
+	msgSpace *mSPAC;
 	msgPool poolInfos[3];
-  char * montext;
+	char *montext;
 
-  poolInfos[0].bufferNb=4;
+	poolInfos[0].bufferNb = 4;
-  poolInfos[0].bufferSize=200;
+	poolInfos[0].bufferSize = 200;
 
-  poolInfos[1].bufferNb=5;
+	poolInfos[1].bufferNb = 5;
-  poolInfos[1].bufferSize=250;
+	poolInfos[1].bufferSize = 250;
 
-  poolInfos[2].bufferNb=5;
+	poolInfos[2].bufferNb = 5;
-  poolInfos[2].bufferSize=280;
+	poolInfos[2].bufferSize = 280;
 
-  sprintf(testId,"test%d",(int)getuid());
+	sprintf(testId, "test%d", (int)getuid());
-  printf("RequestedId: %s\n",testId);
+	printf("RequestedId: %s\n", testId);
- printf("Void size: %d\n",(int)sizeof(void)); 
+	printf("Void size: %d\n", (int)sizeof(void));
-  mSPAC=msgSpaceCreate(testId,0,3,poolInfos);
+	mSPAC = msgSpaceCreate(testId, 0, 3, poolInfos);
- if (mSPAC ==NULL) {
+	if (mSPAC == NULL) {
-	NZG_ERROR("msgSpaceCreate",testId);
+		NZG_ERROR("msgSpaceCreate", testId);
 		exit(0);
 	}
 
-  pid=fork();
+	pid = fork();
 
-  
+	if (pid == 0) {
-  
+		mSPAC = msgSpaceOpen(testId);
-  if (pid ==0){
-	mSPAC=msgSpaceOpen(testId);
 		sleep(5);
-	montext=msgAllocate(mSPAC,2,180,0); 
+		montext = msgAllocate(mSPAC, 2, 180, 0);
 		sleep(5);
-	montext=msgAllocate(mSPAC,2,170,0); 
+		montext = msgAllocate(mSPAC, 2, 170, 0);
 		sleep(5);
-	montext=msgAllocate(mSPAC,2,270,0);
+		montext = msgAllocate(mSPAC, 2, 270, 0);
 
 	} else {
-	mSPAC=msgSpaceOpen(testId);
+		mSPAC = msgSpaceOpen(testId);
-	montext=msgAllocate(mSPAC,2,280,0); 
+		montext = msgAllocate(mSPAC, 2, 280, 0);
-	*montext=42;
+		*montext = 42;
-	printf("### test Valeur0 %d ###\n",(int)*montext);
+		printf("### test Valeur0 %d ###\n", (int)*montext);
 		//sleep(2);
-	montext=msgAllocate(mSPAC,2,270,0); 
+		montext = msgAllocate(mSPAC, 2, 270, 0);
-	*montext=17;
+		*montext = 17;
-	printf("### test Valeur1 %d ###\n",(int)*montext);
+		printf("### test Valeur1 %d ###\n", (int)*montext);
 		sleep(5);
-	montext=msgAllocate(mSPAC,2,270,0);
+		montext = msgAllocate(mSPAC, 2, 270, 0);
-	msgFree(mSPAC,(void *)montext);
+		msgFree(mSPAC, (void *)montext);
 		//msgFree(mSPAC,(void *)montext);
 		//msgFree(mSPAC,(void *)montext);
 		wait(NULL);

test/test_msgSpaceState.c

@@ -6,54 +6,64 @@
 
 #include "libnazgul.h"
 
-void usage(char * myname){
+void usage(char *myname)
-  printf("Usage: %s [--all | msgSpaceId1 msgSpaceId2 ... ]\n",myname);
+{
+	printf("Usage: %s [--all | msgSpaceId1 msgSpaceId2 ... ]\n", myname);
 }
 
-int about(char * spaceId){
+int about(char *spaceId)
+{
 	msgPoolDataTabSemId ressourceSemId;
-  sem_t * ressourceSemFd;
+	sem_t *ressourceSemFd;
 	int i;
-  msgPoolData * poolDataTab;
+	msgPoolData *poolDataTab;
-  msgSpace * space;
+	msgSpace *space;
 	int ressourceSemVal;
-  if (strlen(spaceId)> MSGSPACE_ID_LEN){
+	if (strlen(spaceId) > MSGSPACE_ID_LEN) {
 		//verif de la longueur
-	fprintf(stderr,"Too long ident : %s\n",spaceId);
+		fprintf(stderr, "Too long ident : %s\n", spaceId);
 		goto ERROR;
 	} else {
 		int err;
 		msgSpaceListLock();
-	err=msgSpaceListFindId(spaceId);
+		err = msgSpaceListFindId(spaceId);
 		msgSpaceListUnlock();
-	if (err < 1){
+		if (err < 1) {
-	  if (err==0){
+			if (err == 0) {
 				// le msgSpace existe
-		space=msgSpaceOpen(spaceId);
+				space = msgSpaceOpen(spaceId);
 				// on lit les informations sur le msgSpace
 				// les pool
-		for (i=0;i<space->poolNb;i++){
+				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);
-		  if (ressourceSemFd == SEM_FAILED){ 
+					ressourceSemFd =
-			NZG_ERROR("sem_open",ressourceSemId);
+					    sem_open(ressourceSemId, O_CREAT,
+						     SEM_DEFAULT_MODE, 0);
+					if (ressourceSemFd == SEM_FAILED) {
+						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);
+					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);
-		  msgPoolDataTabClose(space,poolDataTab);
 					msgPoolDataTabUnlock(space);
-		  if(sem_close(ressourceSemFd) <0){
+					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
@@ -62,36 +72,37 @@ int about(char * spaceId){
 				msgSpaceClose(space);
 			} else {
 				// zut, il y a soit une erreur
-		NZG_ERROR("spaceListFindId : error ",spaceId);
+				NZG_ERROR("spaceListFindId : error ", spaceId);
 			}
 		} else {
 			// on quitte : l'element n'existe
-	  fprintf(stderr,"Ident %s does not exist.\n",spaceId);
+			fprintf(stderr, "Ident %s does not exist.\n", spaceId);
 		}
 	}
 	return 0;
-ERROR:
+ ERROR:
 	return -1;
 }
 
-int main(int argc,char **argv){
+int main(int argc, char **argv)
-  printf("Args %d\n",argc);
+{
-  if (argc<2){
+	printf("Args %d\n", argc);
+	if (argc < 2) {
 		usage(argv[0]);
-  }else {
+	} else {
-	if (argc==2){
+		if (argc == 2) {
-	  if (strcmp("--all",argv[1])==0){
+			if (strcmp("--all", argv[1]) == 0) {
 				// listing
 				printf("[ Listing of msgSpaces ]\n");
 			} else {
 				// only one msgSpaceId
-		printf("[ About %s ]\n",argv[1]);
+				printf("[ About %s ]\n", argv[1]);
 				about(argv[1]);
 			}
 		} else {
 			int i;
-	  for (i=1;i<argc;i++){
+			for (i = 1; i < argc; i++) {
-		printf("[ About %s ]\n",argv[i]);
+				printf("[ About %s ]\n", argv[i]);
 				about(argv[i]);
 			}
 		}

test/test_put_get_mono.c

@@ -6,48 +6,50 @@
 
 #include "libnazgul.h"
 
-int main(void) {
+int main(void)
+{
 	//    msgSpace mS=0;
 
 	msgSpaceId testId;
-  msgSpace * mSPAC;
+	msgSpace *mSPAC;
 	msgPool poolInfos[3];
-  char * montext;
+	char *montext;
 
-  poolInfos[0].bufferNb=4;
+	poolInfos[0].bufferNb = 4;
-  poolInfos[0].bufferSize=200;
+	poolInfos[0].bufferSize = 200;
 
-  poolInfos[1].bufferNb=5;
+	poolInfos[1].bufferNb = 5;
-  poolInfos[1].bufferSize=250;
+	poolInfos[1].bufferSize = 250;
 
-  sprintf(testId,"test%d",(int)getuid());
+	sprintf(testId, "test%d", (int)getuid());
-  printf("RequestedId: %s\n",testId);
+	printf("RequestedId: %s\n", testId);
- printf("Void size: %d\n",(int)sizeof(void)); 
+	printf("Void size: %d\n", (int)sizeof(void));
 	//creation de l'espace de messages
-  mSPAC=msgSpaceCreate(testId,1,2,poolInfos);
+	mSPAC = msgSpaceCreate(testId, 1, 2, poolInfos);
-  if (mSPAC ==NULL) {
+	if (mSPAC == NULL) {
-	NZG_ERROR("msgSpaceCreate",testId);
+		NZG_ERROR("msgSpaceCreate", testId);
 		exit(0);
 	}
 
 	printf("CREATION ------------------ ok\n");
 
-  mSPAC=msgSpaceOpen(testId);
+	mSPAC = msgSpaceOpen(testId);
 
   /***** TEST 1 *****/
-  montext=msgAllocate(mSPAC,1,280,0); 
+	montext = msgAllocate(mSPAC, 1, 280, 0);
-  *montext=42;
+	*montext = 42;
-  printf("### test Valeur0 %d ###\n",(int)*montext);
+	printf("### test Valeur0 %d ###\n", (int)*montext);
-  printf("Put..."); fflush(stdout);
+	printf("Put...");
-  msgPut(mSPAC,0,montext);
+	fflush(stdout);
+	msgPut(mSPAC, 0, montext);
 	printf("put-ok\n");
 
-
+	printf("Get...");
-  printf("Get..."); fflush(stdout);
+	fflush(stdout);
-  montext=msgGet(mSPAC,0,0);
+	montext = msgGet(mSPAC, 0, 0);
 	printf("get-ok\n");
-  printf("### test Reception %d ###\n",(int)*montext);
+	printf("### test Reception %d ###\n", (int)*montext);
-  msgFree(mSPAC,montext);
+	msgFree(mSPAC, montext);
   /***** TEST 1 *****/
 	msgSpaceDelete(testId);
 	return 0;

test/test_put_get_multi.c

@@ -6,50 +6,53 @@
 
 #include "libnazgul.h"
 
-int main(void) {
+int main(void)
+{
 	//    msgSpace mS=0;
 
 	msgSpaceId testId;
-  msgSpace * mSPAC;
+	msgSpace *mSPAC;
 	msgPool poolInfos[3];
-  char * montext;
+	char *montext;
 
-  poolInfos[0].bufferNb=4;
+	poolInfos[0].bufferNb = 4;
-  poolInfos[0].bufferSize=200;
+	poolInfos[0].bufferSize = 200;
 
-  poolInfos[1].bufferNb=5;
+	poolInfos[1].bufferNb = 5;
-  poolInfos[1].bufferSize=250;
+	poolInfos[1].bufferSize = 250;
 
-  sprintf(testId,"test%d",(int)getuid());
+	sprintf(testId, "test%d", (int)getuid());
-  printf("RequestedId: %s\n",testId);
+	printf("RequestedId: %s\n", testId);
- printf("Void size: %d\n",(int)sizeof(void)); 
+	printf("Void size: %d\n", (int)sizeof(void));
 	//creation de l'espace de messages
-  mSPAC=msgSpaceCreate(testId,1,2,poolInfos);
+	mSPAC = msgSpaceCreate(testId, 1, 2, poolInfos);
-  if (mSPAC ==NULL) {
+	if (mSPAC == NULL) {
-	NZG_ERROR("msgSpaceCreate",testId);
+		NZG_ERROR("msgSpaceCreate", testId);
 		exit(0);
 	}
 
 	printf("CREATION ------------------ ok\n");
-pid_t pid=fork();
+	pid_t pid = fork();
-if (pid==0){
+	if (pid == 0) {
 		sleep(2);
-  mSPAC=msgSpaceOpen(testId);
+		mSPAC = msgSpaceOpen(testId);
-  montext=msgAllocate(mSPAC,1,280,0); 
+		montext = msgAllocate(mSPAC, 1, 280, 0);
-  *montext=42;
+		*montext = 42;
-  printf("### test Valeur0 %d ###\n",(int)*montext);
+		printf("### test Valeur0 %d ###\n", (int)*montext);
-  printf("Put1..."); fflush(stdout);
+		printf("Put1...");
-  msgPut(mSPAC,0,montext);
+		fflush(stdout);
+		msgPut(mSPAC, 0, montext);
 		printf("put1-ok\n");
-} else {
+	} else {
-  mSPAC=msgSpaceOpen(testId);
+		mSPAC = msgSpaceOpen(testId);
-  printf("Get..."); fflush(stdout);
+		printf("Get...");
-  montext=msgGet(mSPAC,0,0);
+		fflush(stdout);
+		montext = msgGet(mSPAC, 0, 0);
 		printf("get-ok\n");
-  printf("### test Reception %d ###\n",(int)*montext);
+		printf("### test Reception %d ###\n", (int)*montext);
-  msgFree(mSPAC,montext);
+		msgFree(mSPAC, montext);
 		wait(NULL);
 		msgSpaceDelete(testId);
-}
+	}
 	return 0;
 }