C/C++ memset/ZeroMemory

Bonjour, dans ces exemples :

1
2
3
4
5

memset(&serv_addr, '0', sizeof(serv_addr));
memset(sendBuff, '0', sizeof(sendBuff));

ZeroMemory(&serv_addr, '0', sizeof(serv_addr));
ZeroMemory(sendBuff, '0', sizeof(sendBuff));

Ça revient à la même chose utiler memset ou ZeroMemory ?

Salut,

Juste pour préciser, la doc dit le contraire, la fonction ZeroMemory() ne les évite justement pas, c’est son équivalent SecureZeroMemory() qui est censée les éviter.

Concernant les optimisations indésirables, je suppose que c’est typiquement le cas où un tableau est mis à zéro avant d’être désalloué, le plus souvent pour effacer des données sensibles (comme des mots de passe). Dans un tel cas, voyant que le tableau n’est plus employé après sa mise à zéro, les compilateurs modernes ont la fâcheuse tendance à supprimer purement et simplement cette mise à zéro.

Pour contrer cela, on peut soit désactiver les optmisations (il vaut mieux un programme fiable et lent qu’un programme rapide dans certains cas) soit employer un tableau et une fonction dédiée qualifiés avec le mot-clé volatile.

1
2
3
4
5

static void mzero(unsigned char volatile *dest, size_t size)
{
        for (size_t i = 0; i < size; size++)
                dest[i] = 0;
}

Hello! Précision :

Si l’on se limite uniquement aux systèmes windows, ZeroMemory est supposé être standard et portable. Comme toutes les API Win32 dont on se sert, pour ainsi dire, de moins en moins.

Ce sont les APIs non documentées dont l’utilisation est à proscrire pour les développeurs, car leur interface est sujette à changement d’une version de Windows à une autre. Mais cela n’intéresse que les adeptes de la magie noire.

Pour le reste, rien à ajouter… memset est à privilégier si tu pars sur du code multi-plateformes, bien entendu !

Salut.

Vu qu’il y a C++ dans le titre (d’ailleurs « C/C++ » c’est moche), je vais donner le point de vue C++ par rapport à memset (rien à rajouter sur ZeroMemory, tout a déjà été dit.)

En C++ on n’utilise pas memset mais std::fill (documentation). Ça a beaucoup d’avantages, comme le fait d’être type safe et d’être plus général que memset, et ça n’a aucun inconvénient dans les cas d’utilisations similaires à memset, le compilateur pouvant implémenter std::fill en tant que memset dans ces cas là.

Plus de détails ici.

On se comprent. Par standard, je veux dire qui se retrouve dans la norme du langage. Et par portable, je veux dire multi-plateforme.

@Taurre, Je devais pas avoir les yeux en face des trous ! Merci,

Doc :

To avoid any undesired effects of optimizing compilers, use the SecureZeroMemory function.

J’ai lu que la première partie de la phrase biensûr. -_- #boulet

#distrait, plutôt.

Par exemple la : (Source)

 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

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>

int main(void)
{
  int listenfd = 0,connfd = 0;

  struct sockaddr_in serv_addr;

  char sendBuff[1025];  
  int numrv;  

  listenfd = socket(AF_INET, SOCK_STREAM, 0);
  printf("socket retrieve success\n");

  memset(&serv_addr, '0', sizeof(serv_addr));
  memset(sendBuff, '0', sizeof(sendBuff));

  serv_addr.sin_family = AF_INET;    
  serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); 
  serv_addr.sin_port = htons(5000);    

  bind(listenfd, (struct sockaddr*)&serv_addr,sizeof(serv_addr));

  if(listen(listenfd, 10) == -1){
      printf("Failed to listen\n");
      return -1;
  }     

  while(1)
    {      
      connfd = accept(listenfd, (struct sockaddr*)NULL ,NULL); // accept awaiting request

      strcpy(sendBuff, "Message from server");
      write(connfd, sendBuff, strlen(sendBuff));

      close(connfd);    
      sleep(1);
    } 

  return 0;
}

Ligne 23 et 22,

1
2

memset(&serv_addr, '0', sizeof(serv_addr));
memset(sendBuff, '0', sizeof(sendBuff));

A quoi sert ’memset()’ dans cet exemple ? Est-ce que je pourrais directement l’initialiser a 0 en faisant

1
2

struct sockaddr_in serv_addr = { 0 };
char sendBuff = { 0 }; 

?

WTF ?!

Nan c’est pas zéro mais 48. C’est à dire le caractère ’0’.

En gros, utilise l’initialisation, là c’est une erreur de prog d’utiliser memset. Et c’est encore plus une erreur d’utiliser ’0’ au lieu de 0.

Du coup, là c’est du C pas du C++. Donc :

1
2

struct sockaddr_in serv_addr = {};
char sendBuff[255] = ""; 

Attention que la norme C (qu’importe laquelle) oblige à ce que au moins une valeur soit spécifiée entre accolades lors de l’initialisation.