Primitive système qui ne fonctionne pas

Version imprimable

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:

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

23/02/2023, 13h52
Sve@r

Bonjour

Citation:

Envoyé par gumpman

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???

Citation:

Envoyé par gumpman

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.
23/02/2023, 13h57
gumpman

Citation:

Envoyé par Sve@r

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 ?

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

Code:

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;
}

Citation:
Envoyé par 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:

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:

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)...

Citation:

Envoyé par gumpman

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).