Fonction à vérifier : 'return' brouillé :/

Version imprimable

Voici deux fonctions que j'ai écrit avec mes modestes connaissances en C...

Elles supposent une entrée sous forme de char* représentant un nom de domaine complet AVEC sous domaines. Exemple : toto.test.domaine.com, ce que j'appelerai FQDN.

Le résultat de la première fonction, getDomain, est de retourner en char* la partie "domain" du FQDN. Avec l'exemple ci-dessus, celà retournerait : domaine.com.

Le résultat de la seconde fonction, getSubDomain, est de retourner en char* la partie "sub" du FQDN. Avec l'exemple ci-dessus, celà retournerait : toto.test.

J'ai testé ces fonctions en "stand alone", à savoir dans un programme de test qui faisait appel à ces deux fonctions, mais qui ne faisait que ça. J'ai pu constater que tout marchait. Malheureusement, après avoir intégré ces deux fonctions dans mon applicatif final, je constate une sorte de brouillage (exemple : xøÔ·xøÔ·ätoto.test au lieu de toto.test).

Je suppose que j'ai du mal ecrire mon code et c'est pourquoi je me retourne vers vous pour me guider vers une version rectifiée de ces deux fonctions.

Merci par avance aux courageux qui auront lu ma situation :)

Voici les codes :
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 70 71 72 73 74 75 76 77 78 79 80 char *getSubDomain(char *FQDN) { char domainSubNAME[2048] = ""; char *outputSubDomain = malloc(sizeof(char)*2048); char buffer[2048] = ""; int i = 0; int j = 0; char * pchCount; char * pchMods; /* Stockage de FQDN dans un char[] nommé domainNAME */ sprintf(domainSubNAME, "%s", FQDN); pchCount = strtok(domainSubNAME, "."); while (pchCount != NULL) { pchCount = strtok(NULL, "."); /* Comptage du nombre de parties dans le FQDN */ i++; } /* Stockage de FQDN dans un char[] nommé domainNAME */ sprintf(domainSubNAME, "%s", FQDN); pchMods = strtok(domainSubNAME, "."); while (pchMods != NULL) { sprintf(buffer, "%s", pchMods); if (j < (i-2)) { if (j > 0) { sprintf(outputSubDomain, "%s.", outputSubDomain); } sprintf(outputSubDomain, "%s%s", outputSubDomain, buffer); } pchMods = strtok(NULL, "."); j++; } return outputSubDomain; } char *getDomain(char *FQDN) { char domainNAME[2048] = ""; char *outputDomain = malloc(sizeof(char)*2048); char buffer[2048] = ""; int i = 0; int j = 0; char * pchCount; char * pchMods; /* Stockage de FQDN dans un char[] nommé domainNAME */ sprintf(domainNAME, "%s", FQDN); pchCount = strtok(domainNAME, "."); while (pchCount != NULL) { pchCount = strtok(NULL, "."); /* Comptage du nombre de parties dans le FQDN */ i++; } /* Stockage de FQDN dans un char[] nommé domainNAME */ sprintf(domainNAME, "%s", FQDN); pchMods = strtok(domainNAME, "."); while (pchMods != NULL) { sprintf(buffer, "%s", pchMods); if (j >= (i-2)) { if (j > (i-2)) { sprintf(outputDomain, "%s.", outputDomain); } sprintf(outputDomain, "%s%s", outputDomain, buffer); } pchMods = strtok(NULL, "."); j++; } return outputDomain; }

28/01/2008, 20h06
diogene

Code:

sprintf(outputSubDomain, "%s.", outputSubDomain);

et bien d'autres du même genre.

La norme n1124 dit :

Citation:

7.19.6.6 The sprintf function
Synopsis
1 #include <stdio.h>
int sprintf(char * restrict s,
const char * restrict format, ...);
Description
2 The sprintf function is equivalent to fprintf, except that the output is written into
an array (specified by the argument s) rather than to a stream. A null character is written
at the end of the characters written; it is not counted as part of the returned value. If
copying takes place between objects that overlap, the behavior is undefined.

Utiliser strcpy et strcat

Merci pour ces conseils, celà dit, après modification dans mon code, je constate toujours et encore les mêmes soucis...

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
70
71
72
73
74
75
76
77
78
79
80
 
char *getSubDomain(char *FQDN) {
 
  char   domainSubNAME[2048]   = "";
  char   *outputSubDomain      = malloc(sizeof(char)*2048);
  char   buffer[2048]          = "";
  int    i                     = 0;
  int    j                     = 0;
  char * pchCount;
  char * pchMods;
 
  /* Stockage de FQDN dans un char[] nommé domainNAME */
  strcpy(domainSubNAME, FQDN);
 
  pchCount = strtok(domainSubNAME, ".");
  while (pchCount != NULL) {
    pchCount = strtok(NULL, ".");
    /* Comptage du nombre de parties dans le FQDN */
    i++;
  }
 
  /* Stockage de FQDN dans un char[] nommé domainNAME */
  strcpy(domainSubNAME, FQDN);
 
  pchMods = strtok(domainSubNAME, ".");
  while (pchMods != NULL) {
    strcpy(buffer, pchMods);
    if (j < (i-2)) {
      if (j > 0) {
        strcat(outputSubDomain, ".");
      }
      strcat(outputSubDomain, buffer);
    }
    pchMods = strtok(NULL, ".");
    j++;
  }
 
  return outputSubDomain;
 
}
 
char *getDomain(char *FQDN) {
 
  char   domainNAME[2048]      = "";
  char   *outputDomain         = malloc(sizeof(char)*2048);
  char   buffer[2048]          = "";
  int    i                     = 0;
  int    j                     = 0;
  char * pchCount;
  char * pchMods;
 
  /* Stockage de FQDN dans un char[] nommé domainNAME */
  strcpy(domainNAME, FQDN);
 
  pchCount = strtok(domainNAME, ".");
  while (pchCount != NULL) {
    pchCount = strtok(NULL, ".");
    /* Comptage du nombre de parties dans le FQDN */
    i++;
  }
 
  /* Stockage de FQDN dans un char[] nommé domainNAME */
  strcpy(domainNAME, FQDN);
 
  pchMods = strtok(domainNAME, ".");
  while (pchMods != NULL) {
    strcpy(buffer, pchMods);
    if (j >= (i-2)) {
      if (j > (i-2)) {
        strcat(outputDomain, ".");
      }
      strcat(outputDomain, buffer);
    }
    pchMods = strtok(NULL, ".");
    j++;
  }
 
  return outputDomain;
 
}

Résultat :

Code:

1
2
3
4
 
sub.domain.com  // Original
Ð·Ð·äsub        // Sub
Ð·Ð·domain.com  // Domain

Auriez vous une autre idée ? :cry:

28/01/2008, 21h20
gl

Citation:

Envoyé par Havran

Merci pour ces conseils, celà dit, après modification dans mon code, je constate toujours et encore les mêmes soucis...

Auriez vous une autre idée ? :cry:

Tu utilise strcat avec outputDomain mais outputDomain n'est pas une chaine valide (apres l'allocation, la memoire n'etant pas intialisee, elle contient n'importe quoi)
Il faut intialise outputDomain (avec outputDomain[0] = '\0') avant de l'utiliser.

En outre il serait preferable de tester le resultat du malloc avant d'utiliser l'adresse fournie
28/01/2008, 22h18
Havran

Je vais tester de suite, mais en attendant, on fait comment pour vérifier l'allocation de malloc ? :/

Désolé mais mes notions en C sont très récentes...
28/01/2008, 23h45
hegros

Citation:

Envoyé par Havran

Je vais tester de suite, mais en attendant, on fait comment pour vérifier l'allocation de malloc ? :/

Désolé mais mes notions en C sont très récentes...

http://man.developpez.com/man3/malloc.3.php

* Pour calloc() et malloc(), la valeur renvoyée est un pointeur sur la mémoire allouée, qui est correctement alignée pour n'importe quel type de variable, ou NULL si la demande échoue. *

J'avoue que je n'avais pas du tout pensé à tout ça... Je viens de tester à l'instant et... ça marche ! :yaisse2: Merci beaucoup à vous tous !

Voici les sources, au cas où ça interesserait quelqu'un... :)

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
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
 
char *getDomain(char *FQDN) {
 
  char   domainNAME[2048]      = "";
  char   *outputDomain         = malloc(sizeof(char)*2048);
  char   buffer[2048]          = "";
  int    i                     = 0;
  int    j                     = 0;
  char * pchCount;
  char * pchMods;
 
  if (outputDomain == NULL) {
    printf("Malloc Error");
    return NULL;
  }
 
  outputDomain[0] = '\0';
 
  /* Stockage de FQDN dans un char[] nommé domainNAME */
  strcpy(domainNAME, FQDN);
 
  pchCount = strtok(domainNAME, ".");
  while (pchCount != NULL) {
    pchCount = strtok(NULL, ".");
    /* Comptage du nombre de parties dans le FQDN */
    i++;
  }
 
  /* Stockage de FQDN dans un char[] nommé domainNAME */
  strcpy(domainNAME, FQDN);
 
  pchMods = strtok(domainNAME, ".");
  while (pchMods != NULL) {
    strcpy(buffer, pchMods);
    if (j >= (i-2)) {
      if (j > (i-2)) {
        strcat(outputDomain, ".");
      }
      strcat(outputDomain, buffer);
    }
    pchMods = strtok(NULL, ".");
    j++;
  }
 
  return outputDomain;
 
}
 
char *getSubDomain(char *FQDN) {
 
  char   domainSubNAME[2048]   = "";
  char   *outputSubDomain      = malloc(sizeof(char)*2048);
  char   buffer[2048]          = "";
  int    i                     = 0;
  int    j                     = 0;
  char * pchCount;
  char * pchMods;
 
  if (outputSubDomain == NULL) {
    printf("Malloc Error");
    return NULL;
  }
 
  outputSubDomain[0] = '\0';
 
  /* Stockage de FQDN dans un char[] nommé domainNAME */
  strcpy(domainSubNAME, FQDN);
 
  pchCount = strtok(domainSubNAME, ".");
  while (pchCount != NULL) {
    pchCount = strtok(NULL, ".");
    /* Comptage du nombre de parties dans le FQDN */
    i++;
  }
 
  /* Stockage de FQDN dans un char[] nommé domainNAME */
  strcpy(domainSubNAME, FQDN);
 
  pchMods = strtok(domainSubNAME, ".");
  while (pchMods != NULL) {
    strcpy(buffer, pchMods);
    if (j < (i-2)) {
      if (j > 0) {
        strcat(outputSubDomain, ".");
      }
      strcat(outputSubDomain, buffer);
    }
    pchMods = strtok(NULL, ".");
    j++;
  }
 
  return outputSubDomain;
 
}

Merci encore :king:

03/02/2008, 12h09
Emmanuel Delahaye
Citation:

Envoyé par Havran

J'ai testé ces fonctions en "stand alone", à savoir dans un programme de test qui faisait appel à ces deux fonctions, mais qui ne faisait que ça. J'ai pu constater que tout marchait.

Même en test unitaire (stand-alone, comme tu dis), ça ne fonctionne pas chez moi :
Code:

1 2 3 4 s = 'x☺=c.d' Press ENTER to continue.
avec
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 int main (void) { char *s = getDomain("a.b.c.d"); if (s!=NULL) { PRT_S (s); free(s), s = NULL; } return 0; }
Code manquant ici :

http://emmanuel-delahaye.developpez.com/clib.htm
Module PRT
- sizeof(char) vaut 1 par définition
- A quoi ça sert d'allouer une taille fixe ? Pour faire une copie, utilise strdup(), qui est POSIX.1 et donc très portable.
- malloc() peut échouer. Il faut toujours tester le retour avant de l'utiliser.
Le bug est là (comportement indéterminé) :
Citation:
Code:

1 2 3 4 sprintf (outputDomain, "%s.", outputDomain); } sprintf (outputDomain, "%s%s", outputDomain, buffer);
On a absolument pas le droit d'utiliser le même tableau en entrée et en sortie. Tu veux sans doute strcat()...

Sinon memmove() permet ça, mais je doute que tu en ais besoin ici.

Pour ma part je viens de retester ma fonction... et ça marche.
Voici mes fichiers :

temp.c :

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
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
 
#include <stdio.h>
#include <malloc.h>
#include <string.h>
 
char *getDomain(char *FQDN);
char *getSubDomain(char *FQDN);
 
int main(void) {
 
  char FQDN[2048]               = "a.b.c.d";
  char Domain[2048]             = "";
  char subDom[2048]             = "";
 
  sprintf(Domain, "%s", getDomain(FQDN));
  sprintf(subDom, "%s", getSubDomain(FQDN));
 
  printf("---------\n");
  printf("FQDN : %s\n", FQDN);
  printf("Dom  : %s\n", Domain);
  printf("Sub  : %s\n", subDom);
  printf("---------\n");
 
  return 0;
 
}
 
char *getSubDomain(char *FQDN) {
 
  char   domainSubNAME[2048]   = "";
  char   *outputSubDomain      = malloc(sizeof(char)*2048);
  char   buffer[2048]          = "";
  int    i                     = 0;
  int    j                     = 0;
  char * pchCount;
  char * pchMods;
 
  outputSubDomain[0] = '\0';
 
  if (outputSubDomain == NULL) {
    printf("Malloc Error");
    return NULL;
  }
 
  outputSubDomain[0] = '\0';
 
  /* Stockage de FQDN dans un char[] nommé domainNAME */
  strcpy(domainSubNAME, FQDN);
 
  pchCount = strtok(domainSubNAME, ".");
  while (pchCount != NULL) {
    pchCount = strtok(NULL, ".");
    /* Comptage du nombre de parties dans le FQDN */
    i++;
  }
 
  /* Stockage de FQDN dans un char[] nommé domainNAME */
  strcpy(domainSubNAME, FQDN);
 
  pchMods = strtok(domainSubNAME, ".");
  while (pchMods != NULL) {
    strcpy(buffer, pchMods);
    if (j < (i-2)) {
      if (j > 0) {
        strcat(outputSubDomain, ".");
      }
      strcat(outputSubDomain, buffer);
    }
    pchMods = strtok(NULL, ".");
    j++;
  }
 
  return outputSubDomain;
 
}
 
char *getDomain(char *FQDN) {
 
  char   domainNAME[2048]      = "";
  char   *outputDomain         = malloc(sizeof(char)*2048);
  char   buffer[2048]          = "";
  int    i                     = 0;
  int    j                     = 0;
  char * pchCount;
  char * pchMods;
 
  outputDomain[0] = '\0';
 
  if (outputDomain == NULL) {
    printf("Malloc Error");
    return NULL;
  }
 
  outputDomain[0] = '\0';
 
  /* Stockage de FQDN dans un char[] nommé domainNAME */
  strcpy(domainNAME, FQDN);
 
  pchCount = strtok(domainNAME, ".");
  while (pchCount != NULL) {
    pchCount = strtok(NULL, ".");
    /* Comptage du nombre de parties dans le FQDN */
    i++;
  }
 
  /* Stockage de FQDN dans un char[] nommé domainNAME */
  strcpy(domainNAME, FQDN);
 
  pchMods = strtok(domainNAME, ".");
  while (pchMods != NULL) {
    strcpy(buffer, pchMods);
    if (j >= (i-2)) {
      if (j > (i-2)) {
        strcat(outputDomain, ".");
      }
      strcat(outputDomain, buffer);
    }
    pchMods = strtok(NULL, ".");
    j++;
  }
 
  return outputDomain;
 
}

# gcc -o temp temp.c
# ./temp
---------
FQDN : a.b.c.d
Dom : c.d
Sub : a.b
---------

Citation:

Envoyé par Havran

Pour ma part je viens de retester ma fonction... et ça marche.

Après correction, on est bien d'accord ?

Attention, la mémoire n'est pas correctement libérée :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
Usage xxx[ /T][ /E][ /O][ <options application>]
FRMWRK.DBG_SYSALLOC=1
SYSALLOC Overload (1365 rec)
SYSALLOC Successful initialization: 1365 records available
---------
FQDN : a.b.c.d
Dom  : c.d
Sub  : a.b
---------
done in 0 s
SYSALLOC min=4294967295 max=4294967295 delta=0
SYSALLOC Err: Not-matched list:
SYSALLOC Bloc 003D4EC0 (2048 bytes) malloc'ed at line 79 of 'main.c' not freed
SYSALLOC Bloc 003D56C8 (2048 bytes) malloc'ed at line 30 of 'main.c' not freed
SYSALLOC Released Memory
FRMWRK.Execution terminated
 
Press ENTER to continue.

Ton code est terriblement compliqué. Il n'y a pas besoin de tous ces buffers...

<malloc.h> n'existe pas. C'est <stdlib.h>

Si la structure est <domain1.domain2.sub1,sub2>, ca doit se régler et quelques lignes :

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
70
71
72
 
#include <stdio.h>
#include <string.h>
 
int splitDomain (char const *FQDN, char **ppDomain, char **ppsubDom)
{
   /* par defaut, on est en defaut. */
   int ok = 0;
   /* faire une copie modifiable */
   char *dup = strdup (FQDN);
 
   /* recherche du premier '.' */
   char *p = strchr (dup, '.');
   if (p != NULL)
   {
      /* recherche du deuxieme '.' */
      p = strchr (p + 1, '.');
      if (p != NULL)
      {
         /* separation domain/subdomain */
         *p = 0;
 
         /* copie des chaines et memorisation des adresses */
         if (ppDomain != NULL)
         {
            *ppDomain = strdup (dup);
            if (ppDomain != NULL)
            {
               if (ppsubDom != NULL)
               {
                  *ppsubDom = strdup (p + 1);
                  if (ppsubDom != NULL)
                  {
                     /* toutes les conditions sont remplies, OK */
                     ok = 1;
                  }
                  else
                  {
                     free (*ppDomain), *ppDomain = NULL;
                  }
 
               }
            }
         }
      }
   }
   free (dup);
   return ok;
}
 
int main (void)
{
 
   char const FQDN[] = "a.b.c.d";
   char *Domain;
   char *subDom;
 
   int ok = splitDomain (FQDN, &Domain, &subDom);
 
   if (ok)
   {
      printf ("---------\n");
      printf ("FQDN : %s\n", FQDN);
      printf ("Dom  : %s\n", Domain);
      printf ("Sub  : %s\n", subDom);
      printf ("---------\n");
 
      free (Domain);
      free (subDom);
   }
   return 0;
}

On peut améliorer la sécurité en vérifiant qu'il y a bien un . dans le subdomain.

On peut clarifier le codage avec une structure :

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
70
71
72
73
74
 
#include <stdio.h>
#include <string.h>
struct dom
{
   char *Domain;
   char *subDom;
};
 
int splitDomain (char const *FQDN, struct dom *p_dom)
{
   /* par defaut, on est en defaut. */
   int ok = 0;
   /* faire une copie modifiable */
   char *dup = strdup (FQDN);
   if (dup != NULL)
   {
      /* recherche du premier '.' */
      char *p = strchr (dup, '.');
      if (p != NULL)
      {
         /* recherche du deuxieme '.' */
         p = strchr (p + 1, '.');
         if (p != NULL)
         {
            /* separation domain/subdomain */
            *p = 0;
 
            /* copie des chaines et memorisation des adresses */
            if (p_dom != NULL)
            {
               p_dom->Domain = strdup (dup);
               if (p_dom->Domain != NULL)
               {
                  p_dom->subDom = strdup (p + 1);
                  if (p_dom->subDom != NULL)
                  {
                     /* toutes les conditions sont remplies, OK */
                     ok = 1;
                  }
                  else
                  {
                     free (p_dom->Domain), p_dom->Domain = NULL;
                  }
               }
            }
         }
      }
      free (dup);
   }
   return ok;
}
 
int main (void)
{
 
   char const FQDN[] = "a.b.c.d";
   struct dom dom;
 
   int ok = splitDomain (FQDN, &dom);
 
   if (ok)
   {
      printf ("---------\n");
      printf ("FQDN : %s\n", FQDN);
      printf ("Dom  : %s\n", dom.Domain);
      printf ("Sub  : %s\n", dom.subDom);
      printf ("---------\n");
 
      free (dom.Domain);
      free (dom.subDom);
   }
   return 0;
}

03/02/2008, 13h42
Havran

Il me semblait avoir déposé la dernière version de ces deux fonctions sur le forum...

Une solution pour libérer la mémoire ?
03/02/2008, 13h46
Emmanuel Delahaye

Citation:

Envoyé par Havran

Il me semblait avoir déposé la dernière version de ces deux fonctions sur le forum...

Une solution pour libérer la mémoire ?

Sauvegarder le pointeur, free()...