Discussion :

[darkwall_37]

Bonjour,

J'aimerai savoir s'il est possible de déterminer la taille d'un fichier sans utiliser les fonction fscanf ou fread.
J'imagine que windows, quand on ouvre un fichier, ne s'amuse pas à recalculer la taille de chaque fichier, il doit bien y avoir une structure qui contient cette valeur ?

Merci d'avance.

[Bktero]

Bonjour,

--> langage c file size --> premier résultat :http://stackoverflow.com/questions/2...iles-size-in-c

Je clique sur le lien du sujet marqué comme dupliqué : http://stackoverflow.com/questions/8...of-a-file-in-c

Et j'ai une solution pour MinGW :

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
#include <stdlib.h>
#include <sys/stat.h>
 
int main(void)
{
    // http://stackoverflow.com/questions/8236/how-do-you-determine-the-size-of-a-file-in-c
 
    const char* filename = "main.c";
 
    struct stat st;
 
    if (stat(filename, &st) == 0)
        return st.st_size;
 
    return -1;
}

Un autre petit coup de Google --> language C stat msdn --> premier résultat : hop ! Façon Microsoft : http://msdn.microsoft.com/en-us/library/14h5k7ff.aspx

Et voilà le travail.

Après, comment stat() se débrouille, c'est une bonne question. Mais il est probable qu'elle ne s'amuse pas à ouvrir tous les fichiers. J'espère.

[Sve@r]

Bonjour,

J'aimerai savoir s'il est possible de déterminer la taille d'un fichier sans utiliser les fonction fscanf ou fread.
J'imagine que windows, quand on ouvre un fichier, ne s'amuse pas à recalculer la taille de chaque fichier, il doit bien y avoir une structure qui contient cette valeur ?

Bonjour
Oui, cette structure existe et se nomme "inode" sous Linux (Windows a son équivalent). Et on y accède en utilisant la fonction stat()

[darkwall_37]

Oui en effet, merci bien.
J'avais trouvé pour stat mais sur l'article en question, il était dit que c'était propre à LINUX alors autant pour moi.
Je teste cela immédiatement.

Merci pour vos réponse complètes =) Cordialement.

[darkwall_37]

Parfait, au taquet =) !

[Franck.H]

J'avais trouvé pour stat mais sur l'article en question, il était dit que c'était propre à LINUX alors autant pour moi.

C'est toujours un peu trompeur mais c'est en fait sous la norme POSIX.1, une des seule (la seule peut-être ?) partie de POSIX qui est portable donc disponible sous MingW ou Cygwin... Si je mes souvenirs sont bons

[CGi]

La fonction de API Windows qui fait cela, c'est GetFileAttributesEx

[Bktero]

Oui en effet, merci bien.
J'avais trouvé pour stat mais sur l'article en question, il était dit que c'était propre à LINUX alors autant pour moi.
Je teste cela immédiatement.

Merci pour vos réponse complètes =) Cordialement.

Dans un tel cas, pense à faire "stat for windows" dans Google ! De plus, je me suis souvent aperçu que MinGW portait pas mal de fonctions normalement réservés à Linux. Il y a aussi des ports en dehors de MinGW. J'ai par exemple trouvé les pthreads pour Windows.

De rien pour les réponses. Mais tu sais, je n'ai fait que demander à Google...

[darkwall_37]

Bonjour,

Je reviens à la charge...
Stat fais des bêtises avec des fichiers supérieurs à 2Gb.

En parcourant google, il a été dit que sous windows, il fallait utiliser _stat64 en incluant avant les include :

Code :

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

1
2
3
//#define __USE_LARGEFILE64
//#define _LARGEFILE_SOURCE
//#define _LARGEFILE64_SOURCE

Code :

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

1
2
3
4
5
    typedef struct __stat64 st;
    _stat64(file_path, &st);
    unsigned long long int flength = st.st_size;
 
    printf("\n size %I64u", flength);

Le compilateur me dit qu'il manque une expression avant 'st'.

Ca fait deux heures que je tourne en rond. Si vous avez une encore une idée...

Cordialement.

[Obsidian]

Hello,

J'aimerai savoir s'il est possible de déterminer la taille d'un fichier sans utiliser les fonction fscanf ou fread. J'imagine que windows, quand on ouvre un fichier, ne s'amuse pas à recalculer la taille de chaque fichier, il doit bien y avoir une structure qui contient cette valeur ?

stat() est effectivement la meilleure façon d'obtenir cette information (voir également ici).

La raison pour laquelle le C ne normalise pas lui-même un tel appel est que cette information dépend du système d'exploitation et n'est pas toujours disponible : c'est le cas par exemple avec les lecteurs de bandes, même s'il est possible de structurer ce qui y est inscrit quand même et surtout avec les tubes et sockets qui, par nature, sont des flux à la longueur indéterminée et potentiellement infinie (rien n'oblige un tube à être refermé un jour).

[Bktero]

Et avec ça ?

On 32-bit systems you should compile this with the option -D_FILE_OFFSET_BITS=64, otherwise off_t will only hold values up to 2 GB. See the "Using LFS" section of Large File Support in Linux for details.

[darkwall_37]

Oui, rajoutée dans les options de compilations sous codeblocks.
Mais l'erreur est toujours là.

Code :

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

main.c|77|error: expected expression before 'st'|

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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
#define __USE_LARGEFILE64
#define _LARGEFILE_SOURCE
#define _LARGEFILE64_SOURCE
 
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <time.h>
#include <windows.h>
 
 
#include "ptrop.h"
#include "file.h"
#include "logger.h"
#include "math.h"
#include "str.h"
#include "dictionnary.h"
#include "tim.h"
#include "crypt.h"
 
#define MO 1048576
 
typedef struct
{
    double avg;
    double transfert_rate;
    double file_size;
    double file_size_remaining;
    double time_init;
    double time_current;
}t_stat;
 
void stat_init(t_stat *s)
{
    s->avg=0.;
    s->transfert_rate=0.;
    s->file_size=0.;
    s->file_size_remaining=0.;
    s->time_init=0.;
    s->time_current=0.;
}
 
void stat_maj(t_stat *s, double u, double v, double w, double x, double y, double z)
{
    s->avg=u;
    s->transfert_rate=v;
    s->file_size=w;
    s->file_size_remaining=x;
    s->time_init=y;
    s->time_current=z;
}
 
void stat_printf(t_stat *s)
{
    system("cls");
    t_time *time = time_create_structure();
    time_format(s->time_current, time);
    printf("\n %.2f Mo / %.2f Mo @ %.2f Mo/s", s->file_size_remaining, s->file_size, s->transfert_rate);
    time_display(time);
    time_destroy_structure(time);
}
 
t_stat g_stat;
 
void gxor(const char *file_path, unsigned long long int key_length)
{
    char buffer[3];
    unsigned long long int byte_read=0;
    unsigned long long int byte_total=0;
 
    /* Taille du fichier à crypter */
    typedef struct __stat64 st;
    _stat64(file_path, &st);
    unsigned long long int flength = st.st_size;
 
    printf("\n size %I64u", flength);
    getchar();
 
    /* Décompose hle chemine du fichier à crypter */
    t_2Dc *path_element = path_decompose(file_path);
    /* Ajout des extentions .key et .crypt pour désigner le fichier qui contient la clé et le fichier crypté */
    char *key_path = str_concat(str_concat_multiple(path_element->da,path_element->x-1),str_concat(path_element->da[path_element->x-1],".key"));
    char *xor_path = str_concat(str_concat_multiple(path_element->da,path_element->x-1),str_concat(path_element->da[path_element->x-1],".crypt"));
 
    unsigned long long int *key = allocate_1D_ulli(key_length);
    FILE *f_key = file_open(key_path,"wb");
 
    /* Génération de la clé et création du fichier pour la sauvegarder */
    unsigned long long int i;
    for ( i=0 ; i<key_length ; i++)
    {
        buffer[1] = rand()%256;
        key[i]=buffer[1];
        fwrite(&buffer[1], sizeof(char), 1, f_key);
    }
 
    stat_init(&g_stat); /* Initialisation des variables pour l'affichage des statistiques */
    double time_zero = GetTickCount(); /* Valeur du timer au démarrage du cryptage */
    FILE *f     = file_open(file_path,"rb");
    FILE *f_xor = file_open(xor_path,"wb");
    /* Cryptage du fichier original */
    while ((byte_read=fread(&buffer[0],sizeof(char), 1,f)) > 0) /* Parcourir l'intégralité du fichier à crypter octet par octet */
    {
        byte_total+=1;
        /* Résultat de l'octet crypté */
        buffer[2]=buffer[0]^key[byte_total%key_length];
        /* Ecriture de l'octet crypté */
        fwrite(&buffer[2], sizeof(char), byte_read, f_xor);
 
        /* Afficher l'avancement du cryptage */
        if ( byte_total % MO == 0 )
            stat_maj(&g_stat,0,1000.*byte_total/(1024*1024*(GetTickCount()-time_zero)),flength/(1024*1024.),byte_total/(1024*1024.),0,((flength-byte_total)/MO)/(1000.*byte_total/(1024*1024*(GetTickCount()-time_zero)))), stat_printf(&g_stat);
    }
    stat_maj(&g_stat,0,1000.*byte_total/(1024*1024*(GetTickCount()-time_zero)),flength/(1024*1024.),byte_total/(1024*1024.),0,((flength-byte_total)/MO)/(1000.*byte_total/(1024*1024*(GetTickCount()-time_zero)))), stat_printf(&g_stat);
 
    /* Désallocation des ressources */
    destroy_2D_c(path_element);
    deallocate_1D_c(key_path);
    deallocate_1D_c(xor_path);
    deallocate_1D_ulli(key);
    /* Fermeture des fichiers ouverts */
    file_close(f_key);
    file_close(f_xor);
    file_close(f);
}

[darkwall_37]

Ceci à l'air d'être résolu, en ajoutant ces lignes :

Code :

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

1
2
3
#if __MINGW32__
#define __MSVCRT_VERSION__ 0x0601
#endif

Cdt.

[Médinoc]

Code :

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

1
2
    typedef struct __stat64 st;
    _stat64(file_path, &st);

Tu ne sais pas ce que typedef veut dire, sais-tu?