Discussion :

[gumpman]

Shalom, Bonjour,

Je travaille sur des devoirs à rendre et je dois concevoir un programme copian le contenu d'un fichier dans un autre.
Le souci est que ma primitive système read me renvoie -1, quand je lis la valeur de errno j'ai 14 qui correspond à un file descriptor invalide mais je ne sais pas d'où cela peut venir.
Voilà le code complet:

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
 
#include<stdio.h>
#include<stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include<errno.h>
 
#include <stdio.h>
#include <stdarg.h>
#include <stdnoreturn.h>
#include <stdlib.h>
 
#define CHK(op) do { if ((op) == -1) raler (1, #op); } while (0)
 
noreturn void raler (int syserr, const char *msg, ...)
{
    va_list ap;
 
    va_start (ap, msg);
    vfprintf (stderr, msg, ap);
    fprintf (stderr, "\n");
    va_end (ap);
 
    if (syserr == 1)
        perror ("");
 
    exit (EXIT_FAILURE);
}
 
 
int main(int argc, char ** argv) {
	// Vérification de la validité des arguments
	if(argc != 3) {
		printf("Utilisation du programme: ./cp_sys <nom_de_fichier_1> <nom_de_fichier_2>\n");
		return 0;
	}
 
	int fd1, fd2;
	char c;
	ssize_t lecture;
	// Ouverture et gestion des erreures des fichiers
	fd1 = open(argv[1], O_RDONLY);
	if(fd1 == -1) {
		raler(fd1, "raler fichier 1");
		return EXIT_FAILURE;
	}
	fd2 = open(argv[2],O_WRONLY);
	if(fd2 == -1) {
		fd2 = open(argv[2], O_CREAT | O_WRONLY | O_TRUNC, 0666);
		if(fd2 == -1) {
			raler(fd2, "raler fichier 2");
			return EXIT_FAILURE;
		}
	}
	//Copie du fichier 1 dans le fichier 2
	char * buffer;
	lecture = read(fd1, buffer, 100);
	if(lecture == -1) {
		printf("%d\n",errno);
		raler(lecture, "raler lecture du fichier 1");
	}
	write(fd2, buffer, lecture);
 
	// Fermeture des fichiers
	close(fd1);
	close(fd2);
 
	return 0;
}

Merci d'avance

[Sve@r]

Bonjour

Le souci est que ma primitive système read me renvoie -1, quand je lis la valeur de errno j'ai 14 qui correspond à un file descriptor invalide mais je ne sais pas d'où cela peut venir.

Peut-être parce que tu remplis un pointeur qui ne pointe sur rien. Accessoirement tu penses vraiment que 100 caratères suffiront pour tout copier???

Voilà le code complet

Puisque visiblement ça ne t'a pas marqué dans ton dernier topic, je vais te préciser certains détails : ici on place ses codes dans des balises permettant de les faire ressortir. Pourtant il y a eu des exemples dans ledit topic, c'est mentionné dans ma signature ainsi que dans les règles.

[gumpman]

Bonjour

Peut-être parce que tu remplis un pointeur qui ne pointe sur rien. Accessoirement tu penses vraiment que 100 caratères suffiront pour tout copier???


Puisque visiblement ça ne t'a pas marqué dans ton dernier topic, je vais te préciser certains détails : ici on place ses codes dans des balises permettant de les faire ressortir. Pourtant il y a eu des exemples dans ledit topic, c'est mentionné dans ma signature ainsi que dans les règles.

Oui je suis désolé j'ai trouvé la solution je vais poster le code correctement pour d'autres personnes qui en aurait besoin.
D'ailleur j'ai une question: quelle est la taille optimale pour une copie de fichiers volumineux en un temps minimal ?

[gumpman]

Voilà la solution, mon buffer ne pointait sur rien et n'étais pas alloué, de plus 100 caractères ne sont pas suffisant.

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
 
#include<stdio.h>
#include<stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include<errno.h>
 
#include <stdio.h>
#include <stdarg.h>
#include <stdnoreturn.h>
#include <stdlib.h>
 
#define CHK(op) do { if ((op) == -1) raler (1, #op); } while (0)
 
noreturn void raler (int syserr, const char *msg, ...)
{
    va_list ap;
 
    va_start (ap, msg);
    vfprintf (stderr, msg, ap);
    fprintf (stderr, "\n");
    va_end (ap);
 
    if (syserr == 1)
        perror ("");
 
    exit (EXIT_FAILURE);
}
 
 
int main(int argc, char ** argv) {
	// Vérification de la validité des arguments
	if(argc != 3) {
		printf("Utilisation du programme: ./cp_sys <nom_de_fichier_1> <nom_de_fichier_2>\n");
		return EXIT_FAILURE;
	}
 
	int fd1, fd2;
	ssize_t lecture;
	// Ouverture et gestion des erreures des fichiers
	fd1 = open(argv[1],O_RDONLY);
	if(fd1 == -1) {
		raler(fd1, "raler fichier 1");
		return EXIT_FAILURE;
	}
	fd2 = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, 0666);
	if(fd2 == -1) {
		raler(fd2, "raler fichier 2");
		close(fd1);
		return EXIT_FAILURE;
	}
	//Copie du fichier 1 dans le fichier 2
	char buffer[100];
	lecture = read(fd1, buffer, sizeof(buffer));
	if(lecture == -1) {
		raler(lecture, "raler lecture du fichier 1");
	}
	while(lecture > 0) {
		write(fd2, buffer, lecture);
		lecture = read(fd1, buffer, sizeof(buffer));
	}
	// Fermeture des fichiers
	close(fd1);
	close(fd2);
 
	return 0;
}

[Sve@r]

Voilà la solution, mon buffer ne pointait sur rien et n'étais pas alloué, de plus 100 caractères ne sont pas suffisant.

Code c :

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

1
2
3
4
5
6
7
8
lecture = read(fd1, buffer, sizeof(buffer));
if(lecture == -1) {
	raler(lecture, "raler lecture du fichier 1");
}
while(lecture > 0) {
	write(fd2, buffer, lecture);
	lecture = read(fd1, buffer, sizeof(buffer));
}

Code c :

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

1
2
while ((lecture = read(fd1, buffer, 100)) > 0) write(fd2, buffer, lecture);
if (lecture < 0) raler(lecture, "raler lecture du fichier 1");

On n'utilise jamais sizeof() pour récupérer la taille de ses tableaux. Parce que si demain le truc change et devient un pointeur alloué, sizeof(ptr) renverra 8 (taille d'une adresse). Tu gères tes tailles, tu dois t'en souvenir et réécrire leur valeur chaque fois que tu veux les nommer. Ou alors tu passes par des macros (ce qui, en plus, rend le code plus modulable).

On ne teste pas une erreur sur "-1" mais sur "<0" car il peut y avoir d'autres valeurs négatives pour affiner l'erreur. Et inutile de coller les parenthèses aux mots-clefs if(truc). Ca ne compilera pas moins vite d'aérer => if (truc)...

quelle est la taille optimale pour une copie de fichiers volumineux en un temps minimal ?

Ca dépend de tellement de facteurs...

• ta machine (sa mémoire physique)
• la bufferisation de l'OS
• la vitesse des disques

... qu'il est impossible de répondre. Je serais tenté de dire que c'est la valeur renvoyée par getpagesize() mais ça oblige à faire de l'allocation dynamique alors mon second choix se porterait pour une valeur de type 2^n (1024, 2048, 4096, etc).