Discussion :

[petith]

le contexte :
j'écris un programme qui permette d'envoyer/recevoir des données par port parallèle (pour une liaison fibre optique).
Pour l'émission, le programme se contente de dévider un fichier "tampon" en lisant n octets pour les envoyer ; ce sont des programmes fils qui écrivent sur ce fichiers par paquets de n également, avec un système de tickets.
le principe est le même en réception, le premier des n octets du packet permettant de savoir à qui il est destiné.

le problème :
je voudrais que chaque paquet de n octets lus soit effacé (si possible après confirmation de sa bonne réception), afin d'éviter qu'il ne grandisse démesurément et limiter le recours au lseek.
Est-ce possible sans avoir à recopier byte par byte le fichier dans un fichierbis en excluant ceux déjà lus, et à renommer fichierbis pour retrouver le même nom pour un accès futur?

En gros, faire comme si on avait une liste qu'on remplissait d'un côté (fin du fichier) et vidait de l'autre (début)

[josse95]

Tu peux gérer un fichier circulaire.

Le fichier commence par un en-tête comportant un pointeur de lecture et un pointeur d'écriture:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
struct
{
  unsigned long plect;
  unsigned long pecr;
} entete;

L'en-tête est initialisé (à la création du fichier et à chaque fois que entete.plect==entete.pecr suite à une lecture) à:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
entete.plect = sizeof(entete);
entete.pecr = sizeof(entete);

L'accès concurrentiel au fichier est géré par lockf (sous Unix. Si tu es sous Windows, utilise des sémaphores).

Pour écrire:

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
 
lseek(fd,0L,SEEK_SET);
lockf(fd,0L,F_LOCK);
if (read(fd,&entete,sizeof(entete))!=sizeof(entete))
{
  entete.plect = sizeof(entete);
  entete.pecr = sizeof(entete);
  lseek(fd,0L,SEEK_SET);
  write(fd,&entete,sizeof(entete));
}
lseek(fd,entete.pecr,SEEK_SET); /* edit: manquait 3ème paramètre */
if (write(fd,donnees,n)==n)
{
  entete.pecr += n;
  lseek(fd,0L,SEEK_SET);
  write(fd,&entete,sizeof(entete));
}
else
{
  /* à traiter */
}
lseek(fd,0L,SEEK_SET);
lockf(fd,0L,F_ULOCK);

Pour la lecture:

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
lseek(fd,0L,SEEK_SET);
lockf(fd,0L,F_LOCK);
if (read(fd,&entete,sizeof(entete))!=sizeof(entete))
{
  entete.plect = sizeof(entete);
  entete.pecr = sizeof(entete);
  lseek(fd,0L,SEEK_SET);
  write(fd,&entete,sizeof(entete));
}
if (entete.plect == entete.pecr)
{
  /* pas de données */
  entete.plect = entete.pecr = sizeof(entete);
  lseek(fd,0L,SEEK_SET);
  write(fd,&entete,sizeof(entete));
  lseek(fd,0L,SEEK_SET);
  lockf(fd,0L,F_ULOCK);
  return ...;
}
else
{
  lseek(fd,entete.plect,SEEK_SET);  /* edit: manquait 3ème paramètre */
  if (read(fd,donnees,n)==n)
  {
    entete.plect += n;
    lseek(fd,0L,SEEK_SET);
    write(fd,&entete,sizeof(entete));
  }
  lseek(fd,0L,SEEK_SET);
  lockf(fd,0L,F_ULOCK);
}

Le fait de réinitialiser plec et pecr à chaque fois que le fichier est vide évite que ce dernier grossisse en permanence.

[petith]

merci beaucoup !
après une première lecture du code, c'est exactement ce dont j'avais besoin