Lectures argurments console en char*

**Vexored** · 07/01/2018, 01h59

Bonsoir,

Je suis en L2 Informatique a Paul Sabatier à Toulouse. J'ai un projet à rendre d'ici mercredi en Language C. Il s'agit d'un algorithme de cryptage XOR et de cassage de clef.

J'ai eu l'erreur de commencer le projet sans inclure dans mon main la lecture des arguments de la console Bash. Sauf que malgré toutes les recherches effectués, je n'arrive toujours pas à les lires et les mètres en char*.

Voici les lignes de commande :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
./xorcipher -i petit.txt -o petit_crypt1.txt -k abc // -i crypte le fichier et -o est la sortie, avec -k pour la clé de chiffrage
 
 
// Variable Const du nom et mode ouverture du fichier_in
const char* nomDuFichier_in = "texte_decrypt.txt";
const char* modeOuverture_in = "r";
 
// Variable Const du nom et mode ouverture du fichier_out
const char* nomDuFichier_out = "texte_crypt.txt";
const char* modeOuverture_out = "w+";

Avant j'utilisais donc les deux const char* pour appeler mon fichier, et j'aimerais faire de même avec les argv[] sauf que impossible de les mètres dans char* sans un vieux Segmentation Fault a la ligne 334. Après je ne vais pas vous cacher que niveau pointer et tableau sans oublier tout les cast, c'est vraiment la galère. De plus je m'excuse pour le code brouillon et pas vraiment commenter. Il serra dispatcher dans plusieurs fichiers après. Voici le code:

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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
 
// Variable Const du nom et mode ouverture du fichier_in
//const char* nomDuFichier_in = "texte_decrypt.txt";
const char* modeOuverture_in = "r";
 
// Variable Const du nom et mode ouverture du fichier_out
//const char* nomDuFichier_out = "texte_crypt.txt";
const char* modeOuverture_out = "w+";
 
 
unsigned char* lecture_Fichier(char* nomDuFichier_in, int *tab_Fichier_in_Size){
 
  int bloc_alloc = 100000;
 
  FILE* fichier_in = NULL; 
  fichier_in = fopen(nomDuFichier_in, modeOuverture_in);   
 
  unsigned char *tab_Fichier_in = malloc(bloc_alloc * sizeof(unsigned char)); 
 
  unsigned char temp;
 
  while(fscanf(fichier_in, "%c", &temp) != EOF){
    if (*tab_Fichier_in_Size == bloc_alloc){
      bloc_alloc+=100000;
      tab_Fichier_in = realloc(tab_Fichier_in, (bloc_alloc + 2) * sizeof(unsigned char));
    } 
    tab_Fichier_in[*tab_Fichier_in_Size] = temp;
    ++(*tab_Fichier_in_Size);
 
  } 
  fclose(fichier_in);
  return tab_Fichier_in;
}
 
unsigned char* XOR(unsigned char* tab_Fichier_in, int *tab_Fichier_in_Size, unsigned char* clef, int *longeur_CLEF) {
 
  int pos_XOR = 0;
  int pos_CLEF = 0;
 
  unsigned char* tab_Fichier_out = malloc((*tab_Fichier_in_Size + 2) * sizeof(unsigned char));
 
  while(pos_XOR <= *tab_Fichier_in_Size){
 
    if(pos_CLEF >= *longeur_CLEF){
      pos_CLEF = 0;
    }
    tab_Fichier_out[pos_XOR] = (unsigned char)(tab_Fichier_in[pos_XOR] ^ clef[pos_CLEF]);
    pos_XOR++;
    pos_CLEF++;
  }
  return tab_Fichier_out;
}
 
int clef_Valid(unsigned char text){
  if((text == 32) || (text >= 65 && text <= 90) || (text >= 97 && text <= 122)
  //Pontuations Only messages
  || (text == 33) || (text == 34) || (text == 39) || (text == 40) || (text == 41) || (text == 59)
  //Ponctuations clé & messages
  || (text == 44) || (text == 45) || (text == 46) || (text == 58) || (text == 63) || (text == 95) || (text == 123) || (text == 125)
  //ACCENTS
  // A
  || (text == 192) || (text == 194) || (text == 196) || (text == 224) || (text == 226) || (text == 228)
  // C
  || (text == 131) || (text == 199)
  // E
  || (text>=200 && text<=203) || (text>=232 && text<=235)
  // I
  || (text == 206) || (text == 207) || (text == 238) || (text == 239)
  // U
  || (text == 217) || (text == 219) || (text == 249) || (text == 251)
  // O
  || (text == 212) || (text == 214) || (text == 244) || (text == 246)
  // Carriage return and new line
  || (text == 13) || (text == 10)){
    return 1;
  }
  else{
    return 0;
  }
}
 
int caract_Valid(unsigned char text){
  if((text == 32) || (text >= 65 && text <= 90) || (text >= 97 && text <= 122)
  //Pontuations Only messages
  || (text == 33) || (text == 34) || (text == 39) || (text == 40) || (text == 41) || (text == 59)
  //Ponctuations clé & messages
  || (text == 44) || (text == 45) || (text == 46) || (text == 58) || (text == 63) || (text == 95) || (text == 123) || (text == 125)
  //ACCENTS
  // A
  || (text == 192) || (text == 194) || (text == 196) || (text == 224) || (text == 226) || (text == 228)
  // C
  || (text == 131) || (text == 199)
  // E
  || (text>=200 && text<=203) || (text>=232 && text<=235)
  // I
  || (text == 206) || (text == 207) || (text == 238) || (text == 239)
  // U
  || (text == 217) || (text == 219) || (text == 249) || (text == 251)
  // O
  || (text == 212) || (text == 214) || (text == 244) || (text == 246)
  // Carriage return and new line
  || (text == 13) || (text == 10)){
    return 1;
  }
  else{
    return 0;
  }
}
 
unsigned char** C1(unsigned char* tab_Fichier_in, int *tab_Fichier_in_Size, int clef_Size, int* nb_tab_Caract_Valid){
 
  unsigned char tab_Latin_1_Clef[70] = {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, 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, 44, 45, 46, 58, 63, 95, 123, 125, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57};
 
  int init_Form_C1 = 0;
  int coeff_Form_C1 = clef_Size;
 
  nb_tab_Caract_Valid = calloc(clef_Size, (clef_Size + 2) * sizeof(int) );
 
  unsigned char** tab_Char_Valid = malloc(clef_Size * sizeof(unsigned char*));
 
  for(int i = 0; i < coeff_Form_C1; i++){
 
    tab_Char_Valid[i] = malloc( 70 * sizeof(unsigned char));
    init_Form_C1 = i;
    nb_tab_Caract_Valid[i] = 0;
 
 
    for(int k = 0; k < 70; k++){
 
      int compt_Tab_Form = 0;
      int compt_Tab = init_Form_C1 + compt_Tab_Form  * coeff_Form_C1;
 
      unsigned char temp;
      int caract_OK = 1;
 
      while( compt_Tab < *tab_Fichier_in_Size){
        temp = (unsigned char)(tab_Fichier_in[compt_Tab] ^ tab_Latin_1_Clef[k]);
        if (caract_Valid(temp) == 0){
          caract_OK = 0;
          break;
        }
        compt_Tab_Form++;
        compt_Tab = init_Form_C1 + compt_Tab_Form  * coeff_Form_C1;
      }
 
      if(caract_OK == 1){
        tab_Char_Valid[i][nb_tab_Caract_Valid[i]] = tab_Latin_1_Clef[k];
        nb_tab_Caract_Valid[i]++;
      }
    }
 
  }
  for(int c = 0; c < coeff_Form_C1; c++){
    for(int machin = 0; machin < nb_tab_Caract_Valid[c]; machin++){
      printf("tab_Char_Valid[%d][%d] = %c \n", c, machin, tab_Char_Valid[c][machin]);
    }
  }
  return tab_Char_Valid;
}
 
unsigned char** assemb_Clef(unsigned char** tab_Char_Valid, int clef_Size, int *nb_Clef_Trouver, int* nb_tab_Caract_Valid){
 
  if (clef_Size > 3){
    if(clef_Size > 4){
      if(clef_Size > 5){
        if(clef_Size > 6){
          //Taille 7
          *nb_Clef_Trouver = nb_tab_Caract_Valid[0] * nb_tab_Caract_Valid[1] * nb_tab_Caract_Valid[2] * nb_tab_Caract_Valid[3] * nb_tab_Caract_Valid[4] * nb_tab_Caract_Valid[5] * nb_tab_Caract_Valid[6];
        }
        else{
          //Taille 6
          *nb_Clef_Trouver = nb_tab_Caract_Valid[0] * nb_tab_Caract_Valid[1] * nb_tab_Caract_Valid[2] * nb_tab_Caract_Valid[3] * nb_tab_Caract_Valid[4] * nb_tab_Caract_Valid[5];
       }
      }
      else{
        //Taille 5
        *nb_Clef_Trouver = nb_tab_Caract_Valid[0] * nb_tab_Caract_Valid[1] * nb_tab_Caract_Valid[2] * nb_tab_Caract_Valid[3] * nb_tab_Caract_Valid[4];
      }
    }
    else{
      //Taille 4
      *nb_Clef_Trouver = nb_tab_Caract_Valid[0] * nb_tab_Caract_Valid[1] * nb_tab_Caract_Valid[2] * nb_tab_Caract_Valid[3] ;
    }
  }
  else{
    // Taille 3
    *nb_Clef_Trouver = nb_tab_Caract_Valid[0] * nb_tab_Caract_Valid[1] * nb_tab_Caract_Valid[2];
 
  }
 
 
  printf("Nombre de clef possible: %d\n", *nb_Clef_Trouver);
  printf("Concatenation des clef possibles...\n");
 
  unsigned char** clef_Concat = malloc(*nb_Clef_Trouver * sizeof(unsigned char*));
  int nb_Clef_Concat = 0;
  for(int init_clef_Concat = 0; init_clef_Concat < *nb_Clef_Trouver; init_clef_Concat++ ){
    clef_Concat[init_clef_Concat] = malloc(clef_Size * sizeof(unsigned char));
  }
  for(int rang_1 = 0; rang_1 < nb_tab_Caract_Valid[0]; rang_1++){
    for(int rang_2 = 0; rang_2 < nb_tab_Caract_Valid[1]; rang_2++){
      for(int rang_3 = 0; rang_3 < nb_tab_Caract_Valid[2]; rang_3++){
 
        if(clef_Size > 3){
 
          for(int rang_4 = 0; rang_4 < nb_tab_Caract_Valid[3]; rang_4++){
 
            if(clef_Size > 4){
 
              for(int rang_5 = 0; rang_5 < nb_tab_Caract_Valid[4]; rang_5++){
 
                if(clef_Size > 5){
 
                  for(int rang_6 = 0; rang_6 < nb_tab_Caract_Valid[5]; rang_6++){
 
                    if(clef_Size > 6){
 
                      for(int rang_7 = 0; rang_7 < nb_tab_Caract_Valid[6]; rang_7++){
 
                        clef_Concat[nb_Clef_Concat][0] = tab_Char_Valid[0][rang_1];
                        clef_Concat[nb_Clef_Concat][1] = tab_Char_Valid[1][rang_2];
                        clef_Concat[nb_Clef_Concat][2] = tab_Char_Valid[2][rang_3];
                        clef_Concat[nb_Clef_Concat][3] = tab_Char_Valid[3][rang_4];
                        clef_Concat[nb_Clef_Concat][4] = tab_Char_Valid[4][rang_5];
                        clef_Concat[nb_Clef_Concat][5] = tab_Char_Valid[5][rang_6];
                        clef_Concat[nb_Clef_Concat][6] = tab_Char_Valid[6][rang_7];
                        nb_Clef_Concat = nb_Clef_Concat + 1;
 
                      }
 
                    }
                    else{
 
                      clef_Concat[nb_Clef_Concat][0] = tab_Char_Valid[0][rang_1];
                      clef_Concat[nb_Clef_Concat][1] = tab_Char_Valid[1][rang_2];
                      clef_Concat[nb_Clef_Concat][2] = tab_Char_Valid[2][rang_3];
                      clef_Concat[nb_Clef_Concat][3] = tab_Char_Valid[3][rang_4];
                      clef_Concat[nb_Clef_Concat][4] = tab_Char_Valid[4][rang_5];
                      clef_Concat[nb_Clef_Concat][5] = tab_Char_Valid[5][rang_6];
                      nb_Clef_Concat = nb_Clef_Concat + 1;
 
                    }
                  }
 
                }
                else{
 
                  clef_Concat[nb_Clef_Concat][0] = tab_Char_Valid[0][rang_1];
                  clef_Concat[nb_Clef_Concat][1] = tab_Char_Valid[1][rang_2];
                  clef_Concat[nb_Clef_Concat][2] = tab_Char_Valid[2][rang_3];
                  clef_Concat[nb_Clef_Concat][3] = tab_Char_Valid[3][rang_4];
                  clef_Concat[nb_Clef_Concat][4] = tab_Char_Valid[4][rang_5];
                  nb_Clef_Concat = nb_Clef_Concat + 1;
 
                }
 
              }
 
            }
            else{
 
              clef_Concat[nb_Clef_Concat][0] = tab_Char_Valid[0][rang_1];
              clef_Concat[nb_Clef_Concat][1] = tab_Char_Valid[1][rang_2];
              clef_Concat[nb_Clef_Concat][2] = tab_Char_Valid[2][rang_3];
              clef_Concat[nb_Clef_Concat][3] = tab_Char_Valid[3][rang_4];
              nb_Clef_Concat = nb_Clef_Concat + 1;
 
            }
          }
 
        }
        else{
 
          clef_Concat[nb_Clef_Concat][0] = tab_Char_Valid[0][rang_1];
          clef_Concat[nb_Clef_Concat][1] = tab_Char_Valid[1][rang_2];
          clef_Concat[nb_Clef_Concat][2] = tab_Char_Valid[2][rang_3];
          nb_Clef_Concat = nb_Clef_Concat + 1;
 
         }    
       }
    }
  }
  printf("Liste de clef trouve de longeur %d : ", clef_Size);
  for(int blabla = 0; blabla < nb_Clef_Concat; blabla++){
    printf("[");
    for(int blabla2 = 0; blabla2 < clef_Size; blabla2++){
      printf("%c", clef_Concat[blabla][blabla2]);
    }
    printf("] ");
  }
  printf("\n");
return clef_Concat;
}
 
 
 
void ecriture_Fichier(char* nomDuFichier_out, unsigned char* tab_Crypter, int *tab_Fichier_in_Size){
  FILE* fichier_out = NULL; 
  fichier_out = fopen(nomDuFichier_out, modeOuverture_out); 
 
  for(int i = 0; i < *tab_Fichier_in_Size; i++){
    fprintf(fichier_out, "%c", tab_Crypter[i]);
  }
  fclose(fichier_out);
}
 
 
 
 
 
int main(int argc, char *argv[]){
 
  int tab_Fichier_in_Size = 0;
 
  int i_Ok = 0;
  int o_Ok = 0;
  int k_Ok = 0;
  int m_Ok = 0;
  int l_Ok = 0;
 
  char* inTextFile;
  char* outTextFile;
  char* inClef;
  char* inMode;
  int inCleTaille;
  printf("Test\n");
 
  for(int parcours_Argc = 0; parcours_Argc < (argc - 1); parcours_Argc++){
    if( (argv[parcours_Argc] = "-i") ){
      inTextFile = (char*)argv[parcours_Argc + 1];
      printf("%s",inTextFile);
      i_Ok = 1;
    }
    if( (argv[parcours_Argc] = "-o" ) ){
      outTextFile = argv[parcours_Argc + 1];
      o_Ok = 1;
    }
    if( (argv[parcours_Argc] = "-k") ){
      inCleTaille = strlen(argv[parcours_Argc + 1]);
      inClef = (char*)argv[parcours_Argc + 1];
      k_Ok = 1;
    }
    if( (argv[parcours_Argc] = "-m") ){
      inMode = (char*)argv[parcours_Argc + 1];
      m_Ok = 1;
    }
    if( (argv[parcours_Argc] = "-l") ){
      inCleTaille = *argv[parcours_Argc + 1];
      l_Ok = 1;
    }
  }
 
  if( i_Ok && o_Ok) {
    if(k_Ok){
      unsigned char* inClef_Cast = (unsigned char*)inClef;
      int clef_Valid_OK = 1;
      for(int verif_Clef = 0; verif_Clef < inCleTaille; verif_Clef++){
        if(!clef_Valid(inClef_Cast[verif_Clef])){
          clef_Valid_OK = 0;
        }
      }
      if(clef_Valid_OK){
        unsigned char* tab_Fichier_Decrypter = lecture_Fichier(inTextFile, &tab_Fichier_in_Size);
        unsigned char* tab_Fichier_Crypter = XOR(tab_Fichier_Decrypter, &tab_Fichier_in_Size, (unsigned char*)inClef, &inCleTaille); 
        ecriture_Fichier(outTextFile, tab_Fichier_Crypter, &tab_Fichier_in_Size);
      }
    }
    else{
      printf("Erreur Clef");
    }
  }
  else if( i_Ok && m_Ok){
    if( (inMode = "C1") ){
      if( (l_Ok = 1) ){
 
        int* nb_tab_Caract_Valid_rang_n;
 
        unsigned char* tab_Fichier_Crypter = lecture_Fichier(inTextFile, &tab_Fichier_in_Size);
        unsigned char** tab_Clef_rang_n = C1(tab_Fichier_Crypter, &tab_Fichier_in_Size, inCleTaille, nb_tab_Caract_Valid_rang_n);
      }
      else{
 
        int* nb_tab_Caract_Valid_rang_3;
        int* nb_tab_Caract_Valid_rang_4;
        int* nb_tab_Caract_Valid_rang_5;
        int* nb_tab_Caract_Valid_rang_6;
        int* nb_tab_Caract_Valid_rang_7;
 
 
        unsigned char* tab_Fichier_Crypter = lecture_Fichier(inTextFile, &tab_Fichier_in_Size);
        unsigned char** tab_Clef_rang_3 = C1(tab_Fichier_Crypter, &tab_Fichier_in_Size, 3, nb_tab_Caract_Valid_rang_3);
        unsigned char** tab_Clef_rang_4 = C1(tab_Fichier_Crypter, &tab_Fichier_in_Size, 4, nb_tab_Caract_Valid_rang_4);
        unsigned char** tab_Clef_rang_5 = C1(tab_Fichier_Crypter, &tab_Fichier_in_Size, 5, nb_tab_Caract_Valid_rang_5);
        unsigned char** tab_Clef_rang_6 = C1(tab_Fichier_Crypter, &tab_Fichier_in_Size, 6, nb_tab_Caract_Valid_rang_6);
        unsigned char** tab_Clef_rang_7 = C1(tab_Fichier_Crypter, &tab_Fichier_in_Size, 7, nb_tab_Caract_Valid_rang_7);
      }
    }
  }
  else{
    printf("Erreur Commande");
  }
  return 0;
}

Et en plus de ça, j'ai une autre erreur, surtout qu'elle est initialisé a la ligne juste avant, et puis malloc() dans la fonction.

Code :

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

1
2
3
 
main.c:383:25: warning: ‘nb_tab_Caract_Valid_rang_n’ may be used uninitialized in this function [-Wmaybe-uninitialized]
         unsigned char** tab_Clef_rang_n = C1(tab_Fichier_Crypter, &tab_Fichier_in_Size, inCleTaille, nb_tab_Caract_Valid_rang_n);

Merci d'avance pour votre aide, Florian

**dalfab** · 07/01/2018, 02h23

Bonjour,
pour comparer des chaines de caractères, ça n'est pas =, ça n'est pas non plus ==, c'est strcmp(str1,str2)==0Tu dois beaucoup aimer les pointeurs, car il y a plein qui ne sont pas nécessaires dans ton code.

**Vexored** · 07/01/2018, 04h46

Merci beaucoup !

J'ai honte d'avoir fait une erreur aussi stupide :/ D'ailleurs non, je n'aimes pas du tout les pointeurs. D'ailleurs peut-être que vous pourriez m'aidé ?

Je n'arrive pas à transmettre les valeurs d'un tableau globale passer en paramètre d'une fonction. Il est initialisé avec un (int* nb_tab_Caract_Valid_rang_n

ensuite j'appelle une fonction avec ce tableau en paramètre, dans ma fonction ce tableau est donc (nb_tab_Caract_Valid) et ensuite ce calloc ce tableau dans la fonction. Sauf que force de constater qu'il ne modifie pas le tableau d'origine.

J'espère que vous pourrez m'aider, Florian

EDIT :

Après avoir effectué plusieurs test, il faut faire un moins un malloc() pendant l'initialisation du tableau, pour pouvoir le modifier sans problème dans toute les autres fonctions ! Il semblerait que le codage nocturne et le mal de crane donnent la solution ! Merci encore, Florian.

**Matt_Houston** · 07/01/2018, 12h28

Ce que tu décris ressemble au symptôme d'une fonction dont la signature n'est pas adaptée.

En C, les paramètres sont passés par copie, ou par valeur. Si tu cherches à modifier la valeur d'une variable fournie par la fonction appelante, tu dois passer l'adresse de cette variable. Si cette variable est un pointeur, tu dois donc passer l'adresse du pointeur, et non sa valeur qui est pourtant également un adresse !

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
#include <assert.h>
#include <stdlib.h>
 
void f(int  *p) { *p = 0; }
void g(int **p) { *p = NULL; }
 
int main() {
    int i = 42;
    int *p = &i;
 
    f(&i); // i est modifié
    assert(i == 0);
    f(p); // p n'est *pas* modifié !
    assert(p == &i);
    g(&p); // p est modifié
    assert(p == NULL);
 
    return 0;
}

**Médinoc** · 11/01/2018, 11h59

Et sur le même sujet, ta fonction XOR a le problème inverse: Les paramètres de longueur ne sont jamais modifiés par la fonction, donc pourquoi sont-ils passés par pointeur?

Lectures argurments console en char*

C

Discussions similaires

Partager

Partager