TP 3 - Fonctions d'entrée et sortie

Si, par exemple, nous voulons ouvrir le fichier in.txt pour la lecture et l'écriture, éventuellement le créer, et le fichier out.txt pour l'écriture, avec des troncatures, nous pouvons utiliser la séquence de code suivante:

import os
 
try:
	fd1 = os.open("in.txt", O_RDWR | O_CREAT, 0644);
 
	/* will fail if out.txt does not exist */
	fd2 = os,open("out.txt", O_WRONLY | O_TRUNC);
 
	os.close(fd1);
 
        os.close(fd2);
 
except Exception as e:
        print ("Error: {}".format (e))

Attention Une erreur courante est l'omission des droits de création de fichier (0644 dans l'exemple ci-dessus) lorsque l'indicateur O_CREAT ouvert est appelé.

==== Écrire et lire ==== === read === La fonction read est utilisée pour lire le nombre maximal de décomptes du fichier:

ssize_t read(int fd, void *buf, size_t count);

La fonction read renvoie le nombre d'octets réellement lus, tout au plus “count”. La valeur minimale est “1” octet, et quand il atteint la fin du fichier, il renvoie “0”. === write === La fonction write est utilisée pour écrire le nombre maximal d'octets count:

ssize_t write(int fd, const void *buf, size_t count);

La valeur de retour est le nombre d'octets réellement écrits, au plus “nombre”. Par défaut, il n'est pas garanti que le retour à write soit terminé. Pour forcer la mise à jour, vous pouvez utiliser fsync ou le fichier peut être ouvert à l'aide de l'indicateur O_FSYNC , auquel cas il est garanti qu'après chaque écriture le fichier a été mis à jour.

Note : Pour read, write, il y a pread, pwrite, qui vous permettent de spécifier un décalage de fichier à partir duquel effectuer l'opération de lecture / écriture. (Il existe également des versions pread64 et pwrite64 qui utilisent des décalages 64 bits - pour spécifier des tailles de décalage supérieures à 4 Go).

==== Positionnement dans un fichier (lseek) ====

=== lseek ===

La fonction lseek permet au curseur de déplacer un fichier vers une position absolue ou relative.

 off_t lseek(int fd, off_t offset, int whence)

Le paramètre “wherece” représente la position relative à partir de laquelle le déplacement est effectué:

• SEEK_SET - contre la position de départ
• SEEK_CUR - à la position actuelle
• SEEK_END - vers la position finale

Remarque lseek permet également le positionnement à la fin du fichier. L'écriture dans de telles zones n'est pas perdue, ce qui est obtenu en étant un fichier void , une zone ignorée - n'est pas allouée au disque.

Pour cette fonction, il existe une version de lseek64 dans laquelle le décalage est de 64 bits. ==== Recadrer des fichiers ==== En plus de tronquer à 0, ce qui peut être fait en appelant open avec l'indicateur O_TRUNC , vous pouvez spécifier de tronquer un fichier à une taille spécifiée par des appels système ftruncate et truncate:

int ftruncate(int fd, off_t length);         
int truncate(const char *path, off_t length);

Dans le cas de ftrunched, le paramètre fd est le fichier descripteur obtenu avec un appel ouvert fournissant l'autorisation d'écriture. Dans le cas de truncate, le fichier représenté par chemin doit avoir le droit d'écriture.

==== Exemple d'utilisation des opérations d'E / S ===

io-2.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
#include <sys/types.h>	/* open */
#include <sys/stat.h>	/* open */
#include <fcntl.h>	/* O_CREAT, O_RDONLY */
#include <unistd.h>	/* close, lseek, read, write */
 
#include "utils.h"
 
/* Print the last 100 bytes from a file */
 
int main (void)
{
	int fd, rc;
	char *buf;
	ssize_t bytes_read;
 
	/* alocate space for the read buffer */
	buf = malloc(101);
	DIE(buf == NULL, "malloc");
 
	/* open file */
	fd = open("file.txt", O_RDONLY);
	DIE(fd < 0, "open");
 
	/* set file pointer at 100 characters
	 _before_ the end of the file */
	rc = lseek(fd, -100, SEEK_END);
	DIE(rc < 0, "lseek");
 
	/* read the last 100 characthers */
	bytes_read = read(fd, buf, 100);
	DIE(bytes_read < 0, "read");
 
	/* set '\0' at end of buffer for printing purposes*/
	buf[bytes_read] = '\0';
 
	printf("the last %ld bytes: \n%s\n", bytes_read, buf);
 
	/* close file */
	rc = close(fd);
	DIE(rc < 0, "close");
 
	/* cleanup */
	free(buf);
 
	return 0;
}

==== Redirections ====

Sous Linux, les redirections sont effectuées à l'aide des fonctions de duplication de descripteur de fichier dup et dup2 (notez la différence entre 2 dans les liens précédents):

int dup(int oldfd);
int dup2(int oldfd, int newfd);

Par exemple, pour rediriger la sortie vers le fichier output.txt , deux lignes de code sont requises:

fd = open("output.txt", O_RDWR|O_CREAT|O_TRUNC, 0600);
dup2(fd, STDOUT_FILENO);

==== Opérations spéciales ====

La fonctionnalité fcntl vous permet d'effectuer des opérations spéciales sur les descripteurs de fichiers.

int fcntl(int fd, int cmd);
int fcntl(int fd, int cmd, long arg);
int fcntl(int fd, int cmd, struct flock *lock);

===== Exercices =====

Pour résoudre le laboratoire, utilisez des clones repository.

Observations : Pour vous aider à mettre en œuvre les exercices de laboratoire, il existe un fichier utils.h avec des fonctions utiles dans le répertoire utils de l'archive.

==== Exercice 1 - redirection (1p) ====

Allez dans le répertoire 1-redirect et regardez le contenu du fichier redirect.c .

Compilez le fichier (utilisez 'make'). Exécutez le programme à l'aide de la commande './redirect'.

Ouvrez un autre terminal et lancez la commande:

 watch -d lsof -p $(pidof redirect) 

lsof est un utilitaire qui affiche des informations sur les fichiers ouverts (fichiers ouverts dans le système, fichiers ouverts par un utilisateur particulier, etc.). Regardez dans le manuel ( man 8 lsof ) pour identifier la signification de la colonne FD et de la colonne TYPE.

Utilisez la commande Entrée pour continuer le programme. En parallèle, observez l’évolution de la table des descripteurs.

Dans le code, notez les paramètres de redirection avec dup2 (après 2 (fd2, STDERR_FILENO)). Remarquez ce qui se passe si les paramètres sont dans l'ordre inverse.

• Section de révision de redirections

==== Exercice 2 - read-write (3p) ====

Allez dans le répertoire 2-read-write et regardez le contenu du fichier read-write.c.

=== 2a. Écrivez votre nom (1p) === Mettez votre nom dans la variable name. Écrivez la variable à l'écran en utilisant uniquement la fonction write. Suivez les lignes avec TODO 1.

=== 2b. Lisez votre nom (1p) === Lisez votre nom depuis le clavier dans la variable name en utilisant uniquement la fonction read.

La fonction read lit les tampons, elle n’ajoutera pas le caractère \0 à la fin de la chaîne. Assurez-vous que le texte de la chaîne comporte le caractère \0 à la fin.

Ecrivez le nouveau nom lu sur l'écran en utilisant uniquement les fonctions write.

Suivez les lignes avec TODO 2.

=== 2c. Redirection de la sortie standard (1p) ===

Ecrivez votre nom dans le fichier output.txt en utilisant la fonction printf.

Suivez les lignes avec TODO 3.

==== Exercice 3 - lseek (1p) ====

Allez dans le répertoire 3-lseek et regardez le code source dans lseek.c . Quelle valeur le second appel de “lseek” retournera-t-il? Décommentez la ligne d'affichage, compilez et exécutez pour vérification.

Source ne ferme que le fichier descripteur fd1 . Avez-vous besoin de fermer et de classer le descripteur fd2 ? Pourquoi

==== Exercice 4 - mcat (4p) ====

Allez dans le répertoire 4-mcat .

=== 4a. Similarité de chat (1p) === Remplissez le fichier pour que le programme mcat résultant ait une fonctionnalité similaire à celle de 'cat' (suivez les commentaires avec TODO 1 )

Le programme 'mcat' recevra comme argument de ligne de commande le nom d'un fichier dont il affichera le contenu à la sortie standard. Vous ne pouvez pas lire le fichier entier en mémoire. Vous ne pouvez lire que des morceaux de taille maximale BUFSIZE.

Vérifiez le code d'erreur renvoyé par les appels système. Vous pouvez utiliser le DIE. Passez en revue les sections Création, ouverture et fermeture de fichiers et Écriture et lecture de fichiers.

Testez avec une commande comme:

./mcat Makefile 

=== 4b. Similarité cp (1p) === Étendez la fonctionnalité de sorte que la sortie soit redirigée vers un fichier reçu en tant que deuxième argument - une fonctionnalité similaire à l'utilitaire cp . (suivez les commentaires avec TODO 2 )

Consultez la section redirections.

Tester la fonctionnalité:

./mcat Makefile out ; ./mcat out 

=== 4c. / dev / méchant (2p) === Initialisez le fichier /dev/nasty:

 ./set_nasty.sh 

Essayez de copier les fonctionnalités sur /dev/nasty :

./mcat /dev/nasty
./mcat /dev/nasty out ; ./mcat out 

Si des différences se produisent, veillez à ce que les fonctions de lecture et d'écriture (affichent éventuellement ces valeurs) et résolvez le problème.

Testez l'écriture avec:

./mcat Makefile /dev/nasty ; cat /dev/nasty

==== Exercice 5 - Dépannage (1p) ====

Allez dans le répertoire 5-trouble . Compilez et exécutez le programme trouble .

Le programme devrait s'afficher dans tmp1.txt le message msg . Affichez le fichier tmp1.txt .

Que remarquez-vous? Identifiez et corrigez le problème. Passez en revue la section: Création, ouverture et fermeture de fichiers.

==== BONUS ====

=== Exercice 6 - Verrouillage de fichier ===

Nous voulons nous assurer que seule une instance d'un programme s'exécute à la fois. Pour cela, un fichier temporaire est en cours de création et tente d'obtenir un verrou à l'aide de la commande Flock.

Entrez le répertoire “6-singular” et remplissez la source “singular.c” (suivez les commentaires avec TODO).

./singular & sleep 3 ; ./singular

Trouvez une méthode permettant de vous assurer que notre programme n'a qu'une seule instance, en utilisant moins d'appels système .

==== EXTRA ====

• Opérations sur les fichiers en Python
• Étudiez les exemples dans archive, lisez la documentation et notez les différences entre les API.

===== Solutions =====

Solutions

===== Ressources utiles =====

1. Low level I/O (info libc “Low-Level I/O”)
2. Duplicating descriptors (info libc “Duplicating Descriptors”)
3. Low level I/O (Advanced Linux Programming)