Bonjour à tous,
Je suis ici aujourd'hui car je souhaite faire communiquer deux programmes entre eux via un espace en mémoire partagé.
J'ai un programme qui crée un segment mémoire partagée, puis qui récupère les informations qui se trouve dans ce segment.
Puis un second programmes qui doit écrire à l'intérieur de ce segment mémoire.
Voici le code de mon premier programme.
Voici la fonction utilisé pour créer l'espace mémoire
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56 int main() { StructAdresse adresseA_Envoyer; creerMp(&adresseA_Envoyer); //Enregistrement des adresses de reception et d'émission void * reception = adresseA_Envoyer.adresse_buffer_reception; void * emission = adresseA_Envoyer.adresse_buffer_emission; //Définition des structures qui permettrons d'échanger avec le buffer. StructBuffer structReception; StructBuffer structReceptionTemp; StructBuffer structEnvoi; //initialisation d'un des élément des structures strcpy(structReceptionTemp.trame,"null2"); strcpy(structReception.trame,"vide"); //DEBUG strcpy(structEnvoi.nomDst,"nom destination 16"); strcpy(structEnvoi.nomSrc, "nom source 16"); strcpy(structEnvoi.trame, "null"); int i=0; printf("adresse reception : %p\n",reception); printf("adresse emission : %p\n\n",emission); *((StructBuffer*)reception)=structEnvoi; while(i<30){ i++; //Lecture message en attente dans le buffer. structReception = *((StructBuffer*)reception); printf("Message reçu : %s\n",structReception.trame); sleep(1); if(strcmp(structReception.trame,structReceptionTemp.trame)!=0){ printf("Nouveau message reçu depuis %s\n",structReception.nomSrc); printf("\t Message : %s",structReception.trame); strcpy(structReceptionTemp.trame,structReception.trame); } } fermerMp(&adresseA_Envoyer); return 0; }
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58 void creerMp(StructAdresse * aEnvoyer) { char* mem_IDR = (char*) malloc(100*sizeof(char)); char* mem_IDE = (char*) malloc(100*sizeof(char)); mem_IDR = "sharedMemoryR"; mem_IDE = "sharedMemoryE"; //L'instruction ftok(name, (key_t) cle) permet de construire une cle identifiant le segment key_t clefR = ftok(mem_IDR, (key_t) CLEFA_R); key_t clefE = ftok(mem_IDE, (key_t) CLEFA_E); IDR = shmget(clefR,8, IPC_CREAT | IPC_EXCL|SHM_R|SHM_W); IDE = shmget(clefE,8, IPC_CREAT | IPC_EXCL|SHM_R|SHM_W); /* Je cherche le segment de mémoire associé à la CLEF et je récupère l'identificateur de ce segment mémoire.*/ if (IDR<0 || IDE<0) { IDR=0; IDE=0; IDR = shmget(clefR,8,0666); IDE = shmget(clefE,8,0666); if (IDR<0 || IDE<0) { puts("la création du segment de mémoire à échoué"); perror("shmget"); // Je m'assure que l'espace mémoire a correctement été crée. exit(1); } } /* J'attache le segment de mémoire partagée identifié par mem_ID_R au segment de donnée du processus de Reception dans une zone libre déterminée par l'OS*/ aEnvoyer->adresse_buffer_emission = shmat(IDE, NULL,0); aEnvoyer->adresse_buffer_reception = shmat(IDR, NULL,0); aEnvoyer->shmid_emission = IDE; aEnvoyer->shmid_reception = IDR; if(aEnvoyer->adresse_buffer_reception == (void*)-1) { puts("Un problème est survenue lors de l'afféctation du segment mémoire crée"); perror("shmat");// Je m'assure que le segment de mémoire à été correctement attaché au process. exit(1); } if(aEnvoyer->adresse_buffer_emission == (void*)-1) { puts("Un problème est survenue lors de l'afféctation du segment mémoire crée"); perror("shmat");// Je m'assure que le segment de mémoire à été correctement attaché au process. exit(1); } }
Et voici le code du second programme qui doit venir écrire à l'intérieur du segment mémoire.
Et voici la fonction que j'utilise pour récupérer l'accès au segment mémoire
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 StructBuffer aEnvoyer; //MàJ de la structure "aEnvoyer" qui va être écrite dans le buffer de reception du prog DST strcpy(aEnvoyer.nomDst, "nomdstTest"); strcpy(aEnvoyer.trame, "trameTest"); strcpy(aEnvoyer.nomSrc, "nomSrcTest"); recupAdresseBufferReception_Nom(&aEnvoyer); printf("Le programme source est : %s\n",aEnvoyer.nomSrc); printf("Le programme de destination est : %s \n",aEnvoyer.nomDst); printf("Message transmit : %s\n",aEnvoyer.trame); printf("\tAdresse cible pour l'écriture : %p\n\n",aEnvoyer.ptr_adresse_buffer); //Récupération des info lié au segment de mémoire partagé recupSegmentMemoire(); //Ecriture dans le buffer du premier programme *((StructBuffer*)aEnvoyer.ptr_adresse_buffer)=aEnvoyer; puts("message ecrit dans le buffer");
Et enfin voici la structure structBuffer
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12 void recupSegmentMemoire() { printf("\n\n --SHMID-- : %d\n",carnetAdresses[0].shmid_reception); if((shmctl(carnetAdresses[0].shmid_reception,IPC_STAT,NULL))!=0){ puts("problème lors de l'accès au segment mémoire"); perror("Shmctl : "); exit(EXIT_FAILURE); } }
Voilà pour mon code, donc toute la partie lié au premier code fonctionne comme je le souhaite, en tout cas en apparence. Pour le second programme je récupère bien toutes les informations que je souhaite.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8 struct StructBuffer{ int synchro; char nomDst[40]; char nomSrc[40]; char trame[40]; void* ptr_adresse_buffer; };
Par contre je n'arrive pas à accéder à l'espace mémoire créer depuis le second programmes.
J'ai essayé plusieurs méthodes et j'ai fait de nombreuses recherches mais je n'arrive pas a trouver la solutions à mon problèmes.
Je vous remercie pour vos pistes et votre aide.
Partager