Je souhaite créer une liste chainée partagée entre 2 programmes, l'un écrit les données, l'autre les lit, donc pas de problème de conflit.
Le problème étant que je n'ai rien trouvé de mieu que de créer une mémoire partagée PAR élement de ma liste chainée.
De plus, étant donné qu'il faut avoir la même clé pour les deux applications, par élément qui existent dans la liste, j'ai utilisé ftok qui est sensé donner une clé par couple (url,pid), en lui donnant toujours le même pid et un pid bidon que je fais commencer à 0 et que j'incrémente à chaque nouvel élément que je crée, le tout dans l'espoir que ma clé soit la même sur les deux programmes.

Voilà déjà je trouve ça un peu moyen, mais je n'ai rien trouvé de mieu.
Qu'en pensez-vous? Pourrais-je faire autrement?

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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
typedef struct s_shared_elem
{
    char c;
    struct s_shared_elem* next;
    struct s_shared_elem* previous;
}shared_elem;
 
typedef struct s_shared_list
{
    s_shared_elem* first;
    s_shared_elem* last;
}shared_list;
 
int forthekey = 0;
char* url="/home/toor/Projet_cgi/";
 
shared_elem* shared_malloc(int pid, const char* url)
{
        shared_elem* shm;
        int shmid;
        int key=ftok(url,pid);
        if((shmid=shmget(key,1,IPC_CREAT | 0666)) < 0)
        {   
            perror("shmget");
            exit(1);
        }   
 
        if ((shm = shmat(shmid,NULL,0)) == (shared_elem*)-1)
        {
             perror("shmat");
             exit(1);
        }
        return shm;
}
 
void Init_shared_list(shared_list* liste)
{
    liste->first = NULL;
    liste->last = NULL;
}
 
void Ajouter_elem(shared_list* liste)
{
    shared_elem* new = shared_malloc(pid,url);
    new->next = NULL;
    new->previous = liste->last;
 
    if(liste->first == NULL)
    {
        liste->first = new;
        liste->last = new;
    }
 
    else
    {
        liste->last->next = new;
        liste->last = new;
    }
 
    forthekey++;
}
 
void shared_free(shared_elem* todelete,int pid, const char* url)
{
    shared_elem* shm;
    int shmid;
    int key=ftok(url,pid);
    if((shmid=shmget(key,1,IPC_CREAT | 0666)) < 0)
    {
        perror("shmget");
        exit(1);
    }
    shmdt(todelete);
    shmctl(shmid,IPC_RMID,NULL);
 
    forthekey--;
}
 
void Delete_list(shared_list* liste)
{
    while(liste->last != liste->first)
    {
        shared_elem* tmp=liste->last;
        liste->last=liste->last->previous;
        Shared_free(tmp,pid,url);
    }
    Shared_free(liste->first,pid,url);
}