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

**Havran** · 28/01/2008, 19h53

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 :

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

**diogene** · 28/01/2008, 20h06

Code :

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

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

et bien d'autres du même genre.

La norme n1124 dit :

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

**Havran** · 28/01/2008, 21h02

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

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

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

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

Auriez vous une autre idée ?

gl · 28/01/2008, 21h20

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 ?

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

**Havran** · 28/01/2008, 22h18

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

**hegros** · 28/01/2008, 23h45

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

**Emmanuel Delahaye** · 03/02/2008, 12h09

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 :

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

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

avec

Code :

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

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é) :

Code :

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

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.

**Havran** · 03/02/2008, 12h23

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

temp.c :

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

**Emmanuel Delahaye** · 03/02/2008, 13h38

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 :

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

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
 
#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 :

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