.gitignore

@@ -1,6 +1 @@
-*.a
-*.c~
-*.h~
 *.log
-*.o
-test/test_*

.ssh-agent

@@ -0,0 +1,3 @@
+SSH_AUTH_SOCK=/tmp/ssh-QHib2992/agent.2992; export SSH_AUTH_SOCK;
+SSH_AGENT_PID=2993; export SSH_AGENT_PID;
+echo Agent pid 2993;

doc/rapport/rapport.tex

@@ -1,9 +1,9 @@
 \documentclass[12pt,a4paper]{report}
-%\usepackage{a4wide}
+\usepackage{a4wide}
 \usepackage{geometry}
-%\usepackage{typehtml}
+\usepackage{typehtml}
 \usepackage[latin1]{inputenc}
-%\usepackage{listings}
+\usepackage{listings}
 \usepackage[french]{babel}
 \usepackage{fancyheadings}
 \usepackage{color}

src/allocate.c

@@ -9,9 +9,12 @@
 
 /* TODO: prevoir le cas des négatifs dans la taille ... */
 
-void *msgAllocate(msgSpace * space, int pool, int taille, int option)
+void * msgAllocate(msgSpace *space,
-{
+	int pool,
-	void *resultAddr = NULL;
+	int taille,
+	int option
+	){
+  void * resultAddr=NULL;
   int bufferFreeSize;
   int i;
   msgPoolId resultPoolId;
@@ -21,21 +24,23 @@ void *msgAllocate(msgSpace * space, int pool, int taille, int option)
   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;
 
-	mSPoolDataTabAddr = msgPoolDataTabOpen(space);
+  selectedPoolIndex=-1;
-	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,
@@ -59,82 +64,68 @@ void *msgAllocate(msgSpace * space, int pool, int taille, int option)
 	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);
+	  printf("- boucle %d\n",i); fflush(stdout);
-			fflush(stdout);
+	  if(mSPoolDataTabAddr[i].bufferSize >= taille) {
-			if (mSPoolDataTabAddr[i].bufferSize >= taille) {
+		printf("( buffSize > taille )\n"); fflush(stdout);
-				printf("( buffSize > taille )\n");
-				fflush(stdout);
 		/* choisir le numero du semaphore
 		   en fonction du nombre de lock poses / nombre de buffer */
-				msgPoolSemIdIntern(ressourceSemId, space->id,
+		msgPoolSemIdIntern(ressourceSemId,space->id,i);
-						   i);
+		ressourceSemFd = sem_open(ressourceSemId,O_CREAT,SEM_DEFAULT_MODE,0);
-				ressourceSemFd =
+		if (ressourceSemFd == SEM_FAILED){ 
-				    sem_open(ressourceSemId, O_CREAT,
+		  NZG_ERROR("sem_open",ressourceSemId);
-					     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
+		if (sem_getvalue(ressourceSemFd, &ressourceSemVal) < 0){ 
-				    (ressourceSemFd, &ressourceSemVal) < 0) {
+		  NZG_ERROR("sem_getvalue",ressourceSemId);
-					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",
+		  printf("resVal < 0 : %d\n",ressourceSemVal);
-					       ressourceSemVal);
 		  /* il y a ressourceSemVal processus qui attendent déja... */
 		  semPoolCoef[nbLockedSem] = 
-					    (float)((1 -
+			(float) ((1-ressourceSemVal) / mSPoolDataTabAddr[i].bufferNb);
-						     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",
+		  NZG_ERROR("sem_getvalue",ressourceSemId);
-						  ressourceSemId);
 		  return NULL; 
 		}
 	  } // if buffSize > taille
 	} // for
 
-		printf("ERRORDETECT outFor\n");
+	printf("ERRORDETECT outFor\n"); fflush(stdout);
-		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,
+		printf("Coef %d : %d\n",i,(int)semPoolCoef[i]);
-				       (int)semPoolCoef[i]);
 		if ((semPoolCoef[i] != -1) 
 			&& (semPoolCoef[i] < minPoolCoef)) {
 		  minPoolCoef = semPoolCoef[i];
@@ -142,40 +133,40 @@ void *msgAllocate(msgSpace * space, int pool, int taille, int option)
 		}
 	  }
 
-			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,
+	msgPoolSemIdIntern(ressourceSemId,space->externId,selectedPoolIndex);
-				   selectedPoolIndex);
+	ressourceSemFd=sem_open(ressourceSemId,O_CREAT,SEM_DEFAULT_MODE,0);
-		ressourceSemFd =
+	if(ressourceSemFd==SEM_FAILED){
-		    sem_open(ressourceSemId, O_CREAT, SEM_DEFAULT_MODE, 0);
+	  NZG_ERROR("sem_open",ressourceSemId);
-		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 */
@@ -183,43 +174,41 @@ void *msgAllocate(msgSpace * space, int pool, int taille, int option)
   
   /* on modifie maintenant les données */
   /* - on récupere l'index du premier buffer libre */
-	bufferFreeIndex =
+  bufferFreeIndex = msgBufferGetFreeIndex(mSPoolDataTabAddr,selectedPoolIndex);
-	    msgBufferGetFreeIndex(mSPoolDataTabAddr, selectedPoolIndex);
+  if (bufferFreeIndex < 0){
-	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 =
+ resultAddr=msgBufferMap(mSPoolDataTabAddr,selectedPoolIndex,bufferFreeIndex);
-	    msgBufferMap(mSPoolDataTabAddr, selectedPoolIndex, bufferFreeIndex);
+ if (resultAddr==NULL){
-	if (resultAddr == NULL) {
+   NZG_ERROR("msgBufferMap",mSPoolDataTabAddr[selectedPoolIndex].poolId);
-		NZG_ERROR("msgBufferMap",
-			  mSPoolDataTabAddr[selectedPoolIndex].poolId);
    goto ERROR;
  }
 
   /* - on s'enregistre aupres de ce buffer */  
  msgBufferAttachProc(mSPoolDataTabAddr,
-			    selectedPoolIndex, bufferFreeIndex, resultAddr);
+	 selectedPoolIndex,
+	 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 0x%08x\n", (int)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,11 +1,15 @@
 #include "libnazgul.h"
 
-int msgBufferGetAttachedProcIndex(msgPoolData * poolDataTabAddr,
+int msgBufferGetAttachedProcIndex(
-				  int poolIndex, void *addr)
+	msgPoolData * poolDataTabAddr,
-{
+	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,36 +1,41 @@
 #include "libnazgul.h"
 
-int msgBufferAttachProc(msgPoolData * poolDataTabAddr,
+int msgBufferAttachProc(
-			int poolIndex, int bufferIndex, void *addr)
+	msgPoolData * poolDataTabAddr,
+	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);
+
-	if (bufferInfoTabFd < 0) {
+  bufferInfoTabFd=shm_open(bufferInfoTabId,O_RDWR,SHM_DEFAULT_MODE);
-		NZG_ERROR("sem_open", bufferInfoTabId);
+  if (bufferInfoTabFd<0){
+	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,
+	  PROT_READ|PROT_WRITE,MAP_SHARED,bufferInfoTabFd,(off_t)0);
-				 bufferInfoTabFd, (off_t) 0);
+  printf("atta gooo %s\n",bufferInfoTabId);
-	printf("atta gooo %s\n", bufferInfoTabId);
 
   bufferInfoTabAddr[bufferIndex].ownerPid = getpid();
   bufferInfoTabAddr[bufferIndex].addr = addr;
 
-	if (munmap(bufferInfoTabAddr, bufferInfoNb * sizeof(msgBufferInfo)) < 0) {
+  if (munmap(bufferInfoTabAddr,bufferInfoNb*sizeof(msgBufferInfo))< 0)
-		NZG_ERROR("munmap", bufferInfoTabId);
+  {	
-		return -1;
+	NZG_ERROR("munmap",bufferInfoTabId);
-	}
+	return -1; }
 
   return 0;
 }
+
+

src/bufferDetachProc.c

@@ -1,37 +1,42 @@
 #include "libnazgul.h"
 
-int msgBufferDetachProc(msgPoolData * poolDataTabAddr,
+int msgBufferDetachProc(
-			int poolIndex, int bufferIndex, void *addr)
+	msgPoolData * poolDataTabAddr,
-{
+	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,
+	  PROT_READ|PROT_WRITE,MAP_SHARED,bufferInfoTabFd,(off_t)0);
-				 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,43 +1,39 @@
 #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,
+	  PROT_READ,MAP_SHARED,bufferInfoTabFd,(off_t)0);
-				 (off_t) 0);
 
-	i = 0;
+  i=0;
-	while ((i < bufferInfoNb)
+  while ((i<bufferInfoNb) 
-	       && (bufferInfoTabAddr[i].ownerPid != (pid_t) - 1)) {
+	  && (bufferInfoTabAddr[i].ownerPid != (pid_t)-1)){ i++; }
-		i++;
+  if (i == bufferInfoNb){ return -1; }
-	}
+  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,61 +1,51 @@
 #include "libnazgul.h"
 
-int msgBufferGetProcAttach(msgPoolData * poolDataTabAddr,
+int msgBufferGetProcAttach(
+	msgPoolData * poolDataTabAddr,
 	int poolNb,
-			   int *poolIndex, int *bufferIndex, void *addr)
+	int * poolIndex,
-{
+	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 =
+	bufferInfoTabFd=shm_open(bufferInfoTabId,O_RDWR,SHM_DEFAULT_MODE);
-		    shm_open(bufferInfoTabId, O_RDWR, SHM_DEFAULT_MODE);
+	if (bufferInfoTabFd<0)
-		if (bufferInfoTabFd < 0) {
+	{ NZG_ERROR("shm_open",bufferInfoTabId); return -1; 	}
-			NZG_ERROR("shm_open", bufferInfoTabId);
-			return -1;
-		}
 
 	/** on regarde dans le tableau d'infos de buffer **/
-		bufferInfoTabAddr =
+	bufferInfoTabAddr=mmap(NULL,bufferInfoNb*sizeof(msgBufferInfo),
-		    mmap(NULL, bufferInfoNb * sizeof(msgBufferInfo), PROT_READ,
+		PROT_READ,MAP_SHARED,bufferInfoTabFd,(off_t)0);
-			 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) {
+	if (found){ (*poolIndex)=pIdx; }
-			(*poolIndex) = pIdx;
-		}
 	/* on détache le morceau de mémoire */
-		if (munmap
+	if (munmap(bufferInfoTabAddr,bufferInfoNb*sizeof(msgBufferInfo))< 0)
-		    (bufferInfoTabAddr,
+	{ NZG_ERROR("munmap",bufferInfoTabId); return -1; }
-		     bufferInfoNb * sizeof(msgBufferInfo)) < 0) {
-			NZG_ERROR("munmap", bufferInfoTabId);
-			return -1;
-		}
 	close(bufferInfoTabFd);
 	pIdx++;
   }
 
-	if (found) {
+  if (found){ return 0; } else {return -1;}
-		return 0;
-	} else {
-		return -1;
-	}
 }
+

src/bufferInfoTabCreate.c

@@ -1,39 +1,37 @@
 #include "libnazgul.h"
 #include "ids.h"
 
-int msgBufferInfoTabCreate(msgSpaceId externId,
+int msgBufferInfoTabCreate(
+	msgSpaceId externId,
 	msgPoolData * poolDataTabAddr,
-			   int poolIdx, int bufferNb)
+	int poolIdx,
-{
+	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 =
+  bufferInfoTabFd=shm_open(bufferInfoTabId,O_RDWR|O_CREAT|O_EXCL|O_TRUNC,MSGSPACE_DEFAULT_MODE);
-	    shm_open(bufferInfoTabId, O_RDWR | O_CREAT | O_EXCL | O_TRUNC,
+  if (bufferInfoTabFd == -1 ) {
-		     MSGSPACE_DEFAULT_MODE);
+	fprintf( stderr, "msgInfoTab : %s creation failed: %s\n",bufferInfoTabId,
-	if (bufferInfoTabFd == -1) {
+		strerror( errno ) );
-		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;
+  return -1;NZG_ERROR("munmap",bufferInfoTabId);
-	NZG_ERROR("munmap", bufferInfoTabId);
 	return -1; 
 }

src/bufferInfoTabInit.c

@@ -1,38 +1,34 @@
 #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,
+  printf("msgBufferInfoTabId %d open >>%s<<\n",poolIndex,bufferInfoTabId);
-	       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("msgBufferInfoTabId open",bufferInfoTabId);
-		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,
+	  PROT_WRITE|PROT_READ,MAP_SHARED,bufferInfoTabFd,(off_t)0);
-				 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");
+  {	perror("munmap"); return -1; }
-		return -1;
-	}
 
   return 0;
 }
+

src/bufferMap.c

@@ -1,50 +1,52 @@
 #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;
+  bufferSize=poolDataTab[poolIndex].bufferSize;
-	bufferNb = poolDataTab[poolIndex].bufferNb;
+  bufferNb=poolDataTab[poolIndex].bufferNb;
-	if (bufferNb < 0) {
-		// 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, bufferSize * (bufferIndex + 1), PROT_READ | PROT_WRITE,	//PROT_NONE
+  resultAddr=mmap(NULL, 
-			  MAP_SHARED, poolBufferTabFd, (off_t) 0);
+	  bufferSize*(bufferIndex+1),  
-	if (resultAddr == MAP_FAILED) {
+	  PROT_READ|PROT_WRITE,  //PROT_NONE
+	  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 0x%08x to 0x%08x\n",
-	       (void *)resultAddr,
+	  (int)resultAddr,
-	       (void *)(resultAddr + bufferSize * (bufferIndex + 1))
+	  (int)resultAddr+ bufferSize*(bufferIndex+1)
 	  );
 
-	resultAddr = resultAddr + (bufferSize * bufferIndex);
+  resultAddr=resultAddr +( bufferSize*bufferIndex);
-	printf("Moved to %p\n", (void *)resultAddr);
+  printf( "Moved to 0x%08x\n",(int)resultAddr	);
 
  /* mprotect(
 	  resultAddr,
 	  bufferSize,
 	  PROT_READ|PROT_WRITE
-	   ); */
+	  );*/
 
   close(poolBufferTabFd);
 
   return resultAddr;
- ERROR:
+ERROR:
   return NULL;
 }

src/free.c

@@ -1,22 +1,21 @@
 #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 0x%08x ]\n",(int)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;
   };
 
@@ -26,38 +25,42 @@ int msgFree(msgSpace * space, void *addr)
 
   // TODO: verouiller semaphore DataInfo ??
 
-	poolIndex = -1;
+  poolIndex=-1; bufferIndex=-1;
-	bufferIndex = -1;
+  err=msgBufferGetProcAttach(
-	err = msgBufferGetProcAttach(poolDataTabAddr,
+	  poolDataTabAddr,
 	  space->poolNb,
-				     &poolIndex, &bufferIndex, addr);
+	  &poolIndex,
+	  &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,60 +2,59 @@
 
 #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 =
+  resultAddr=msgBufferMap(poolDataTab,oldElem->poolIndex,oldElem->bufferIndex);
-	    msgBufferMap(poolDataTab, oldElem->poolIndex, oldElem->bufferIndex);
   // attacher au buffer...
   if (msgBufferAttachProc(poolDataTab,
 		oldElem->poolIndex,
-				oldElem->bufferIndex, resultAddr) < 0) {
+		oldElem->bufferIndex,
-		NZG_ERROR("msgBufferAttachProc", oldElemId);
+		resultAddr) <0){
+	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);
@@ -64,9 +63,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,10 +25,12 @@
 #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~

@@ -1,48 +0,0 @@
-#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,150 +1,158 @@
 #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(
-int msgPoolDataTabSemIdIntern(msgPoolSemId destSemId, const msgSpaceId externId)
+	msgPoolSemId destSemId,
-{
+	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(
-int msgPoolSemIdIntern(msgPoolSemId destSemId,
+	msgPoolSemId destSemId,
-		       const msgSpaceId srcPoolId, int poolIdx)
+	const msgSpaceId srcPoolId,
-{
+	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(msgBufferInfoTabId dest, msgSpaceId src, int num)
+int msgBufferInfoTabIdIntern(
-{
+	msgBufferInfoTabId dest,
-	if (strlen(src) > MSGSPACE_ID_LEN) {
+	msgSpaceId src, 
+	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(msgQueueSemId dest,
+int msgQueueProtSemIdIntern(
-			    msgSpaceId externId, int queueIdx)
+	msgQueueSemId 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/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(msgQueueSemId dest,
+int msgQueueReadSemIdIntern(
-			    msgSpaceId externId, int queueIdx)
+	msgQueueSemId 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/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(msgQueueId dest, msgSpaceId externId, int queueIdx)
+int msgQueueIdIntern(
-{
+	msgQueueId dest,
-	if (strlen(externId) > MSGSPACE_ID_LEN) {
+	msgSpaceId externId, 
+	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(msgQueueElemId dest, msgQueueId src, int counter)
+int msgQueueElemIdIntern(
-{
+	msgQueueElemId dest,
-	if (strlen(src) > MSGSPACE_ID_LEN) {
+	msgQueueId src,
+	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,13 +2,21 @@
 #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 msgPoolSemIdIntern(msgPoolSemId destSemId, const msgSpaceId srcPoolId, int poolIdx);
-		       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(msgQueueSemId dest, msgSpaceId externId, int queueIdx);
+int msgQueueSemIdIntern(
-int msgQueueIdIntern(msgQueueId dest, msgSpaceId externId, int queueIdx);
+	msgQueueSemId dest,
+	msgSpaceId externId, 
+	int queueIdx);
+int msgQueueIdIntern(
+	msgQueueId dest,
+	msgSpaceId externId, 
+	int queueIdx);
 
 #endif

src/ids.h~

@@ -1,22 +0,0 @@
-#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,6 +46,7 @@ typedef struct MsgPoolData {
 
 /* TODO: queueId */
 
+
 typedef struct MsgSpace {
   msgSpaceId id;
   msgSpaceId externId;
@@ -56,6 +57,7 @@ typedef struct MsgSpace {
   msgPoolDataTabSemId poolDataTabSemId;
 } msgSpace;
 
+
 typedef struct MsgSpaceListElem {
   msgSpaceListElemId id;
 

src/iface.h~

@@ -1,91 +0,0 @@
-#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~

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

src/poolCreate.c

@@ -1,51 +1,49 @@
 #include "libnazgul.h"
 #include "ids.h"
 
-int msgPoolCreate(msgSpaceId externId, int poolIdx, int buffNb, int buffSize)
+int msgPoolCreate(
-{
+		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",
+	  fprintf( stderr, "msgPoolId creation failed for id %s\n", (char*)poolId );
-			(char *)poolId);
 	  return -1;
 	}
-	poolFd =
+	poolFd=shm_open(poolId,O_RDWR|O_CREAT|O_EXCL|O_TRUNC,MSGSPACE_DEFAULT_MODE);
-	    shm_open(poolId, O_RDWR | O_CREAT | O_EXCL | O_TRUNC,
+	if (poolFd == -1 ) {
-		     MSGSPACE_DEFAULT_MODE);
+	  fprintf( stderr, "msgPool : %s creation failed: %s\n",poolId,
-	if (poolFd == -1) {
+		  strerror( errno ) );
-		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 =
+	ressourceSemFd = sem_open(poolRessourceSemId, O_CREAT|O_EXCL,SEM_DEFAULT_MODE, buffNb);
-	    sem_open(poolRessourceSemId, O_CREAT | O_EXCL, SEM_DEFAULT_MODE,
+		if (ressourceSemFd == SEM_FAILED){ 
-		     buffNb);
+		  NZG_ERROR("sem_open : creation de la ressource",poolRessourceSemId);
-	if (ressourceSemFd == SEM_FAILED) {
-		NZG_ERROR("sem_open : creation de la ressource",
-			  poolRessourceSemId);
 		  goto ERROR;
 		} else {
-		printf("[ Created %s with %d ressources ]\n",
+		  printf("[ Created %s with %d ressources ]\n",poolRessourceSemId,buffNb);
-		       poolRessourceSemId, buffNb);
 		}
 
 	//TODO: verrifier les erreurs sur l'ouverture de la sem
@@ -57,6 +55,7 @@ int msgPoolCreate(msgSpaceId externId, int poolIdx, int buffNb, int buffSize)
 	close(poolFd);
 
 	return 0;
- ERROR:
+ERROR:
 	return -1;
 }
+

src/poolDataTabClose.c

@@ -1,14 +1,13 @@
 #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,28 +1,29 @@
 #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(space->poolDataTabId,
+  poolDataFd=shm_open(
-			      O_RDWR | O_CREAT | O_EXCL | O_TRUNC,
+	  space->poolDataTabId,
-			      MSGSPACE_DEFAULT_MODE);
+	  O_RDWR|O_CREAT|O_EXCL|O_TRUNC,
-	if (poolDataFd == -1) {
+	  MSGSPACE_DEFAULT_MODE
-		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 ),
@@ -31,9 +32,11 @@ void *msgPoolDataTabCreate(msgSpace * space)
 	if( poolDataAddr == MAP_FAILED ) {
 	NZG_ERROR("mmap",poolDataTabId);
 	goto ERROR;
-	   } */
+	}*/
 
   return poolDataTabAddr;
- ERROR:
+ERROR:
   return NULL;
 }
+
+

src/poolDataTabLock.c

@@ -3,35 +3,34 @@
 
 #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) {
+  if (DEBUG) {printf("Locking %s\n",space->poolDataTabSemId);}
-		printf("Locking %s\n", space->poolDataTabSemId);
-	}
 
-	poolDataTabSemFd = sem_open(space->poolDataTabSemId, O_CREAT,
+  poolDataTabSemFd=sem_open(
-				    SEM_DEFAULT_MODE, 1);
+	  space->poolDataTabSemId
-	if (poolDataTabSemFd == SEM_FAILED) {
+	  ,O_CREAT,
-		NZG_ERROR("sem_open", space->poolDataTabSemId);
+	  SEM_DEFAULT_MODE,
+	  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) {
+  if (DEBUG) { printf("(AfternValue:%d)\n",semval);}
-		printf("(AfternValue:%d)\n", semval);
-	}
 
   sem_close(poolDataTabSemFd);
 
   return 0;
- ERROR:
+ERROR:
   return -1; 
 }
+

src/poolDataTabOpen.c

@@ -1,30 +1,31 @@
 #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, MSGSPACE_DEFAULT_MODE);
+	  O_RDWR,
-	if (poolDataTabFd == -1) {
+	  MSGSPACE_DEFAULT_MODE);
-		NZG_ERROR("shm_open", space->poolDataTabId);
+  if (poolDataTabFd == -1 ) {
+	NZG_ERROR("shm_open",space->poolDataTabId);
 	goto ERROR;
   }
 
-	poolDataTabAddr = mmap(NULL, (space->poolNb) * sizeof(msgPoolData),
-			       PROT_READ | PROT_WRITE,
-			       MAP_SHARED, poolDataTabFd, 0);
 
-	if (poolDataTabAddr == MAP_FAILED) {
+  poolDataTabAddr = mmap( NULL, (space->poolNb) * sizeof( msgPoolData ),
-		NZG_ERROR("mmap", space->poolDataTabId);
+	  PROT_READ | PROT_WRITE,
+	  MAP_SHARED, poolDataTabFd, 0 );
+
+  if( poolDataTabAddr == MAP_FAILED) {
+	NZG_ERROR("mmap",space->poolDataTabId);
 	goto ERROR;
   }
 
   close(poolDataTabFd);
 
   return poolDataTabAddr;
- ERROR:
+ERROR:
   return NULL;
 }

src/poolDataTabUnlock.c

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

src/poolDelete.c

@@ -1,44 +1,45 @@
 #include "libnazgul.h"
 #include "ids.h"
 
-int msgPoolDelete(msgSpaceId spaceId, int poolIdx)
+int msgPoolDelete(
-{
+		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",
+	  fprintf( stderr, "msgPoolId creation failed for id %s\n", (char*)poolId );
-			(char *)poolId);
 	  return -1;
 	}
 	
-	if (shm_unlink(bufferInfoTabId) < 0) {
+	if (shm_unlink(bufferInfoTabId) <0 ) {
-		fprintf(stderr, "msgInfoTab : %s deletion failed: %s\n",
+	fprintf( stderr, "msgInfoTab : %s deletion failed: %s\n",bufferInfoTabId,
-			bufferInfoTabId, strerror(errno));
+		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",
+	  fprintf( stderr, "msgPoolId creation failed for id %s\n", (char*)poolId );
-			(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,77 +2,66 @@
 #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 msgBufferAttachProc(msgPoolData *poolDataTabAddr, int poolIndex, int bufferIndex, void *addr);
-			int bufferIndex, void *addr);
 /* buffer.c */
-int msgBufferGetAttachedProcIndex(msgPoolData * poolDataTabAddr, int poolIndex,
+int msgBufferGetAttachedProcIndex(msgPoolData *poolDataTabAddr, int poolIndex, void *addr);
-				  void *addr);
 /* bufferDetachProc.c */
-int msgBufferDetachProc(msgPoolData * poolDataTabAddr, int poolIndex,
+int msgBufferDetachProc(msgPoolData *poolDataTabAddr, int poolIndex, int bufferIndex, void *addr);
-			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 msgBufferGetProcAttach(msgPoolData *poolDataTabAddr, int poolNb, int *poolIndex, int *bufferIndex, void *addr);
-			   int *poolIndex, int *bufferIndex, void *addr);
 /* bufferInfoTabCreate.c */
-int msgBufferInfoTabCreate(msgSpaceId externId, msgPoolData * poolDataTabAddr,
+int msgBufferInfoTabCreate(msgSpaceId externId, msgPoolData *poolDataTabAddr, int poolIdx, int bufferNb);
-			   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,
+int msgPoolDataTabSemIdIntern(msgPoolSemId destSemId, const msgSpaceId externId);
-			      const msgSpaceId externId);
+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 msgBufferInfoTabIdIntern(msgBufferInfoTabId dest, msgSpaceId src, int num);
-int msgQueueProtSemIdIntern(msgQueueSemId dest, msgSpaceId externId,
+int msgQueueProtSemIdIntern(msgQueueSemId dest, msgSpaceId externId, int queueIdx);
-			    int queueIdx);
+int msgQueueReadSemIdIntern(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,
+int msgSpaceListElemIdIntern(msgSpaceListElemId elemListId, msgSpaceId externId);
-			     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 msgQueueElemCreate(msgQueueElemId finalQueueElemId, msgQueueId queueId, int counter);
-		       int counter);
 /* queueElemDelete.c */
 int msgQueueElemDelete(msgQueueElemId queueElemId);
 /* queueElemOpen.c */
@@ -92,22 +81,21 @@ 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,
+msgSpace *msgSpaceCreate(msgSpaceId externId, int queueNb, int poolNb, msgPool *poolInfos);
-			 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~

@@ -1,118 +0,0 @@
-#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,66 +1,70 @@
 #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(poolDataTabAddr,
+  err=msgBufferGetProcAttach(
+	  poolDataTabAddr,
 	  space->poolNb,
-				     &poolIndex, &bufferIndex, addr);
+	  &poolIndex,
-	if (err) {
+	  &bufferIndex,
-		//FIXME
+	  addr
-	}
+	  );
-	// ouvrir la queue avec le bon index
-	msgQueueIdIntern(queueId, space->externId, queueIndex);
 
-	msgQueueProtLock(space->externId, queueIndex);
+  // ouvrir la queue avec le bon index
+  msgQueueIdIntern(queueId,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,48 +2,47 @@
 
 // on ajoute en fin de queue...
 
-int msgQueueAdd(msgQueue * queue, msgQueueElemId newElemId)
+int msgQueueAdd(msgQueue * queue, msgQueueElemId newElemId){
-{
+	msgQueueElem * queueOldTailElem;
-	msgQueueElem *queueOldTailElem;
+	msgQueueElem * queueNewTailElem;
-	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,17 +1,16 @@
 #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,34 +1,35 @@
 #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,16 +1,15 @@
 #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,30 +1,31 @@
 #include "libnazgul.h"
 #include "ids.h"
 
-int msgQueueElemCreate(msgQueueElemId finalQueueElemId,
+int msgQueueElemCreate(
-		       msgQueueId queueId, int counter)
+	msgQueueElemId finalQueueElemId ,
-{
+	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,28 +1,29 @@
 #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, queueElemFd, 0);
+	  MAP_SHARED,
-	if (queueElemAddr == MAP_FAILED) {
+	  queueElemFd,
-		NZG_ERROR("mmap", queueElemId);
+	  0);
+  if( queueElemAddr == MAP_FAILED ) {
+	NZG_ERROR("mmap",queueElemId);
 	goto ERROR;
   }
 
   close(queueElemFd);
   return queueElemAddr; 
- ERROR:
+ERROR: 
   return NULL;
 }

src/queueInit.c

@@ -1,32 +1,33 @@
 #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);
+
-	msgQueueReadSemIdIntern(queueSemReadableId, externId, queueIdx);
+	msgQueueProtSemIdIntern(queueSemProtectId,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;
 	}
@@ -36,36 +37,35 @@ msgQueue *msgQueueInit(msgSpaceId externId, int queueIdx)
 	  goto ERROR;
 	} */
 
-	if (msgQueueIdIntern(queueId, externId, queueIdx) < 0) {
+	if(msgQueueIdIntern(queueId, externId, queueIdx) < 0) {
 		return NULL;
 	}
 	
-	queueFd =
+	queueFd = shm_open(queueId, O_RDWR|O_CREAT|O_EXCL|O_TRUNC, MSGSPACE_DEFAULT_MODE);
-	    shm_open(queueId, O_RDWR | O_CREAT | O_EXCL | O_TRUNC,
+	if(queueFd == -1) {
-		     MSGSPACE_DEFAULT_MODE);
+	  NZG_ERROR("shm_open : queueInit",queueId);
-	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", strerror(errno));
+	  fprintf( stderr, "Queue resizing failed: %s\n",
+		  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,27 +1,29 @@
 #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, MAP_SHARED, queueFd, 0);
+	  PROT_READ|PROT_WRITE,
-	if (queueAddr == MAP_FAILED) {
+	  MAP_SHARED,
-		NZG_ERROR("mmap", queueId);
+	  queueFd,
+	  0);
+  if( queueAddr == MAP_FAILED ) {
+	NZG_ERROR("mmap",queueId);
 	goto ERROR;
   }
 
   close(queueFd);
   return queueAddr; 
- ERROR:
+ERROR: 
   return NULL;
 }

src/queueProtLock.c

@@ -2,36 +2,32 @@
 #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) {
+  if (DEBUG) { printf("Locking %s\n",queueSemId);}
-		printf("Locking %s\n", queueSemId);
+  queueSemFd=sem_open(queueSemId,O_CREAT,SEM_DEFAULT_MODE,1);
-	}
+  if(queueSemFd==SEM_FAILED){
-	queueSemFd = sem_open(queueSemId, O_CREAT, SEM_DEFAULT_MODE, 1);
+	NZG_ERROR("sem_open",queueSemId);
-	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) {
+ if (DEBUG) { printf("(AfterValue:%d)\n",semval); }
-		printf("(AfterValue:%d)\n", semval);
-	}
 
   sem_close(queueSemFd);
   sem_close(queueSemFd);
 
   return 0;
- ERROR:
+ERROR:
   return -1; 
 }
+

src/queueProtUnlock.c

@@ -3,36 +3,32 @@
 
 #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) {
+  if (DEBUG) { printf("Unlocking %s\n",queueSemId); }
-		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) {
+  if (DEBUG) { printf("(AfterValue:%d)\n",semval); }
-		printf("(AfterValue:%d)\n", semval);
-	}
 
   sem_close(queueSemFd);
 
   return 0;
- ERROR:
+ERROR:
   return -1;
 }
+

src/queueReadLock.c

@@ -3,35 +3,31 @@
 
 #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) {
+  if (DEBUG) { printf("Locking %s\n",queueSemId); }
-		printf("Locking %s\n", queueSemId);
+  queueSemFd=sem_open(queueSemId,O_CREAT,SEM_DEFAULT_MODE,1);
-	}
+  if(queueSemFd==SEM_FAILED){
-	queueSemFd = sem_open(queueSemId, O_CREAT, SEM_DEFAULT_MODE, 1);
+	NZG_ERROR("sem_open",queueSemId);
-	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) {
+  if (DEBUG) { printf("(AfterValue:%d)\n",semval); }
-		printf("(AfterValue:%d)\n", semval);
-	}
 
   sem_close(queueSemFd);
 
   return 0;
- ERROR:
+ERROR:
   return -1; 
 }
+

src/queueReadTryLock.c

@@ -3,35 +3,31 @@
 
 #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) {
+  if (DEBUG) { printf("Locking %s\n",queueSemId); }
-		printf("Locking %s\n", queueSemId);
+  semval=0;
-	}
+  sem_getvalue(queueSemFd,&semval);
-	semval = 0;
+  if (DEBUG) { printf("(AfterValue:%d)\n",semval); }
-	sem_getvalue(queueSemFd, &semval);
-	if (DEBUG) {
-		printf("(AfterValue:%d)\n", semval);
-	}
 
   sem_close(queueSemFd);
 
   return 0;
- ERROR:
+ERROR:
   return -1; 
 }
+

src/queueReadUnlock.c

@@ -3,35 +3,32 @@
 
 #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) {
+  if (DEBUG) { printf("Unlocking %s\n",queueSemId); }
-		printf("Unlocking %s\n", queueSemId);
+  queueSemFd=sem_open(queueSemId,O_CREAT,SEM_DEFAULT_MODE,1);
-	}
+  if(queueSemFd==SEM_FAILED){
-	queueSemFd = sem_open(queueSemId, O_CREAT, SEM_DEFAULT_MODE, 1);
+	NZG_ERROR("sem_open",queueSemId);
-	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) {
+  if (DEBUG) { printf("(AfterValue:%d)\n",semval); }
-		printf("(AfterValue:%d)\n", semval);
+
-	}
 
   sem_close(queueSemFd);
 
   return 0;
- ERROR:
+ERROR:
   return -1;
 }
+

src/queueRem.c

@@ -2,36 +2,37 @@
 
 // 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) {
+	
-		NZG_ERROR("msgQueueElemRem : Empty queue", queue->id);
+	if (strcmp(queue->headId,queue->id)==0){
+	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,16 +1,15 @@
 #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(msgPoolSemId destSemId,
+int msgPoolDataTabSemIdIntern(
-			      const msgSpaceId externId);
+	msgPoolSemId destSemId,const msgSpaceId externId);
 /*
  * spaceId : identifiant externe de l'espace de msg
  * queueNb : nombre de files de messages
@@ -13,105 +13,109 @@ int msgPoolDataTabSemIdIntern(msgPoolSemId destSemId,
  * queueNbCar : tableau de caracteristiques des different pool
  */
 
-msgSpace *msgSpaceCreate(msgSpaceId externId,
+msgSpace * msgSpaceCreate(
-			 int queueNb, int poolNb, msgPool * poolInfos)
+	msgSpaceId externId, 
-{
+	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(nzgId,
+  mSFd=shm_open(
-			O_RDWR | O_CREAT | O_EXCL | O_TRUNC,
+	  nzgId,
-			MSGSPACE_DEFAULT_MODE);
+	  O_RDWR|O_CREAT|O_EXCL|O_TRUNC,
-	if (mSFd == -1) {
+	  MSGSPACE_DEFAULT_MODE
-		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, MAP_SHARED, mSFd, 0);
+	  PROT_READ | PROT_WRITE,
-	if (space == MAP_FAILED) {
+	  MAP_SHARED, mSFd, 0 );
-		NZG_ERROR("mmap", nzgId);
+  if( space == MAP_FAILED ) {
+	NZG_ERROR("mmap",nzgId);
 	goto ERROR;
   }
 
-	printf("CREAT: msgSpace mapped to 0x%08lx in %d\n", (long)space,
+  printf( "CREAT: msgSpace mapped to 0x%08x in %d\n", (int)space,(int)getpid());
-	       (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; 
@@ -122,67 +126,60 @@ msgSpace *msgSpaceCreate(msgSpaceId externId,
   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) ==
+	if (msgBufferInfoTabIdIntern(bufferInfoTabId,externId,i) == -1){
-		    -1) {
+	  fprintf( stderr, "msgBufferInfoTabId creation failed for id %s\n",
-			fprintf(stderr,
+		  (char*)poolId );
-				"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,
+	printf("buffIfoTab %d name : %s\n",i,poolDataTabAddr[i].bufferInfoTabId);
-		       poolDataTabAddr[i].bufferInfoTabId);
+	msgBufferInfoTabCreate(externId,poolDataTabAddr,i,poolInfos[i].bufferNb);
-		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,
+	msgPoolCreate(externId,i,poolInfos[i].bufferNb,poolInfos[i].bufferSize);
-			      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);
+	printf("- queue %i...",i); fflush(stdout);
-		fflush(stdout);
+	if (msgQueueInit(space->externId,i) < 0){
-		if (msgQueueInit(space->externId, i) < 0) {
 	  printf("fail.\n");
-			NZG_ERROR("msgQueueInit : queue ?? for",
+	  NZG_ERROR("msgQueueInit : queue ?? for",space->externId);
-				  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");
@@ -192,6 +189,9 @@ msgSpace *msgSpaceCreate(msgSpaceId externId,
   /* 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(msgPoolSemId destSemId,
+int msgPoolDataTabSemIdIntern(
-			      const msgSpaceId externId);
+	msgPoolSemId destSemId,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,55 +3,54 @@
 // 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 *listOldTailElem;
+	msgSpaceListElem * listNewTailElem;
-	msgSpaceListElem *listNewTailElem;
+	msgSpaceList * list;
-	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,18 +1,17 @@
 #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,43 +2,47 @@
 #include "ids.h"
 
 // cree un nouvel elemen
-int msgSpaceListElemCreate(msgSpaceListElemId listElemId, msgSpace * space)
+int msgSpaceListElemCreate(
+	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->next, listElem->spaceId);
+	  listElem->id,
-	if (msgSpaceListElemClose(listElem) < 0) {
+	  listElem->next,
-		NZG_ERROR("msgSpaceListElemClose", listElemId);
+	  listElem->spaceId);
+  if (msgSpaceListElemClose(listElem) <0){
+	NZG_ERROR("msgSpaceListElemClose",listElemId);
   }
   return 0;
- ERROR:
+ERROR:
   return -1;
 
 };

src/spaceListElemLink.c

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

src/spaceListElemOpen.c

@@ -2,29 +2,32 @@
 #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, MAP_SHARED, listElemFd, 0);
+	  PROT_READ|PROT_WRITE,
+	  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,84 +2,78 @@
 
 #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) {
+  if (DEBUG) { printf("Before ListStrCpy\n"); }
-		printf("Before ListStrCpy\n");
+  strcpy(listHeadElemId,list->headId);
-	}
+  strcpy(listTailElemId,list->tailId);
-	strcpy(listHeadElemId, list->headId);
+  strcpy(listId,list->id);
-	strcpy(listTailElemId, list->tailId);
+  if (DEBUG) { printf("After ListStrCpy\n"); }
-	strcpy(listId, list->id);
+  if ((strcmp(listHeadElemId,listId)==0) 
-	if (DEBUG) {
+	  && strcmp(listTailElemId,listId)==0){
-		printf("After ListStrCpy\n");
-	}
-	if ((strcmp(listHeadElemId, listId) == 0)
-	    && strcmp(listTailElemId, listId) == 0) {
 	// si la liste est vide
-		if (DEBUG) {
+	if (DEBUG) { printf("SpaceList : vide\n"); }
-			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,73 +1,76 @@
 #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,
+
-			       O_RDWR | O_CREAT | O_EXCL | O_TRUNC, 0666);
+  /*Fait un segment de memoir partager sur espace de listelement*/
-	if (spaceListFd == -1) {
+  spaceListFd=shm_open(spaceListId,
-		spaceListFd = shm_open(spaceListId, O_RDWR, 0666);
+	  O_RDWR|O_CREAT|O_EXCL|O_TRUNC,
-		if (spaceListFd == -1) {
+	  0666);
-			NZG_ERROR("shm_open", spaceListId);
+  if (spaceListFd == -1){
+	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,65 +1,69 @@
 #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 */
+
-	msgSpaceListSemFd = sem_open(spaceListSemId, O_CREAT, 0666, 0);
+  /*Ouverture dun semaphore*/
-	if (msgSpaceListSemFd == SEM_FAILED) {
+  msgSpaceListSemFd=sem_open(spaceListSemId,O_CREAT,0666,0);
-		NZG_ERROR("sem_open", spaceListSemId);
+  if(msgSpaceListSemFd==SEM_FAILED){
+	NZG_ERROR("sem_open",spaceListSemId);
 	goto ERROR;
   }
 
-	/*Relachement du semaphore */
+
-	if (sem_post(msgSpaceListSemFd) == -1) {
+  /*Relachement du semaphore*/
-		NZG_ERROR("sem_relache", spaceListSemId);
+  if(sem_post(msgSpaceListSemFd)==-1){
+	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,30 +1,32 @@
 #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, MAP_SHARED, listFd, 0);
+	  PROT_READ|PROT_WRITE,
-	if (listAddr == MAP_FAILED) {
+	  MAP_SHARED,
-		NZG_ERROR("mmap", spaceListId);
+	  listFd,
+	  0);
+  if( listAddr == MAP_FAILED ) {
+	NZG_ERROR("mmap",spaceListId);
 	goto ERROR;
   }
 
   close(listFd);
   return listAddr; 
- ERROR:
+ERROR: 
   return NULL;
 }

src/spaceListRem.c

@@ -2,9 +2,8 @@
 
 #define DEBUG 1
 
-int msgSpaceListRem(msgSpaceId spaceId)
+int msgSpaceListRem(msgSpaceId spaceId){
-{
+  msgSpaceList * list;
-	msgSpaceList *list;
   msgSpaceListElemId listHeadElemId;
   msgSpaceListElemId listTailElemId;
   msgSpaceListId listId;
@@ -13,116 +12,99 @@ 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) {
+  if (DEBUG) { printf("Before ListStrCpy\n"); }
-		printf("Before ListStrCpy\n");
+  strcpy(listHeadElemId,list->headId);
-	}
+  strcpy(listTailElemId,list->tailId);
-	strcpy(listHeadElemId, list->headId);
+  strcpy(listId,list->id);
-	strcpy(listTailElemId, list->tailId);
+  if (DEBUG) { printf("After ListStrCpy\n"); }
-	strcpy(listId, list->id);
+  if ((strcmp(listHeadElemId,listId)==0) 
-	if (DEBUG) {
+	  && strcmp(listTailElemId,listId)==0){
-		printf("After ListStrCpy\n");
+	if (DEBUG) { printf("SpaceList : vide\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,
+			strcpy(list->headId,nextElemId);
-						       nextElemId);
 		  } else {
-						if (strcmp
+			if (strcmp(currElemId,nextElemId)==0){
-						    (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,
+			  strcpy(list->tailId,prevElemId);
-							       prevElemId);
 			  // - on fait pointer le précédent sur lui-meme
-							prevElem =
+			  prevElem=msgSpaceListElemOpen(prevElemId);
-							    msgSpaceListElemOpen
+			  strcpy(prevElem->next,prevElemId);
-							    (prevElemId);
+			  msgSpaceListElemClose(prevElem);
-							strcpy(prevElem->next,
+			}else {
-							       prevElemId);
-							msgSpaceListElemClose
-							    (prevElem);
-						} else {
 			  // on est en milieu de liste
 			  // - on fait pointer le précédent sur le suivant
-							prevElem =
+			  prevElem=msgSpaceListElemOpen(prevElemId);
-							    msgSpaceListElemOpen
+			  strcpy(prevElem->next,nextElemId);
-							    (prevElemId);
+			  msgSpaceListElemClose(prevElem);
-							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,26 +2,25 @@
 #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 =
+  mSAddr=mmap(NULL,sizeof(msgSpace),PROT_READ|PROT_WRITE,MAP_SHARED,shmFd,(off_t)0);
-	    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,
+  printf( "OPEN: msgSpace mapped to 0x%08x in %d\n", (int)mSAddr,(int)getpid());
-	       (int)getpid());
   return mSAddr;
 }
+
+

src/spaceState.c

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

test/test_create_delete.c

@@ -6,57 +6,58 @@
 
 #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,64 +6,54 @@
 
 #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,
+		  msgPoolSemIdIntern(ressourceSemId,space->externId,i);
-							   space->externId, i);
+		  ressourceSemFd = sem_open(ressourceSemId,O_CREAT,SEM_DEFAULT_MODE,0);
-					ressourceSemFd =
+		  if (ressourceSemFd == SEM_FAILED){ 
-					    sem_open(ressourceSemId, O_CREAT,
+			NZG_ERROR("sem_open",ressourceSemId);
-						     SEM_DEFAULT_MODE, 0);
-					if (ressourceSemFd == SEM_FAILED) {
-						NZG_ERROR("sem_open",
-							  ressourceSemId);
 			goto ERROR;
 		  }
-					if (sem_getvalue
+		  if (sem_getvalue(ressourceSemFd, &ressourceSemVal) < 0){ 
-					    (ressourceSemFd,
+			NZG_ERROR("sem_getvalue",ressourceSemId);
-					     &ressourceSemVal) < 0) {
-						NZG_ERROR("sem_getvalue",
-							  ressourceSemId);
 			goto ERROR;
 		  }
 		  msgPoolDataTabLock(space);
-					poolDataTab = msgPoolDataTabOpen(space);
+		  poolDataTab= msgPoolDataTabOpen(space);
 		  // donner le nombre de buffer disponibles
-					printf
+		  printf("- %d/%d free buffers in pool #%d\n",
-					    ("- %d/%d free buffers in pool #%d\n",
 			  ressourceSemVal,
-					     poolDataTab[i].bufferNb, i);
+			  poolDataTab[i].bufferNb,
-					msgPoolDataTabClose(space, poolDataTab);
+			  i);
+		  msgPoolDataTabClose(space,poolDataTab);
 		  msgPoolDataTabUnlock(space);
-					if (sem_close(ressourceSemFd) < 0) {
+		  if(sem_close(ressourceSemFd) <0){
-						NZG_ERROR("sem_getvalue",
+			NZG_ERROR("sem_getvalue",ressourceSemId);
-							  ressourceSemId);
 			goto ERROR;
 		  }
 		  // pour chaque buffer, dire s'il est libre ou pas
@@ -72,37 +62,36 @@ 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);
-	printf("Args %d\n", argc);
+  if (argc<2){
-	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,50 +6,48 @@
 
 #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...");
+  printf("Put..."); fflush(stdout);
-	fflush(stdout);
+  msgPut(mSPAC,0,montext);
-	msgPut(mSPAC, 0, montext);
   printf("put-ok\n");
 
-	printf("Get...");
+
-	fflush(stdout);
+  printf("Get..."); 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,53 +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");
-	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...");
+  printf("Put1..."); fflush(stdout);
-		fflush(stdout);
+  msgPut(mSPAC,0,montext);
-		msgPut(mSPAC, 0, montext);
   printf("put1-ok\n");
-	} else {
+} else {
-		mSPAC = msgSpaceOpen(testId);
+  mSPAC=msgSpaceOpen(testId);
-		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);
   wait(NULL);
   msgSpaceDelete(testId);
-	}
+}
   return 0;
 }