Référence du fichier sma.h

Description détaillée

Auteur:: Nicolas JOSEPH

Version:: 1.0

Description

S.M.A. est une surcouche aux fonctions d'allocation de la bibliothèque standard du C.

Voici un aperçu de ces fonctionnalités :

Surcharge, via des macro, des fonctions malloc, calloc, realloc et free ou utilisation des fonctions native sma_*
Niveau d'affichage des informations configurable
Allocation de place suplémentaire avant et après la zone demandée afin de prévenir d'un comportement indéfini lors d'un dépassement de capacité
Détection des débordements de mémoire
Détection des fuites mémoire lorsque le programme se termine normalement
Gestion des allocations externes
Affichage du profil mémoire à tout instant.

L'utilisation est extrêmement simple puisqu'il suffit d'inclure le fichier sma.h en dernier et d'utiliser les fonctions préfixées sma_*. Si vous reprennez un projet volumineux afin de le débuguer, il n'ai pas utile de remplacer tous les appels, puisqu'il existe des macro afin de remplacer les appel à malloc et autres par les nouvelles fonctions.

Installation

...

Exemple

Voici un exemple complet d'utilisation :

#include <stdio.h>
#include <stdlib.h>

#include "sma.h"

int main (void)
{
  char *p[3] = { NULL };

  // Initialisation
  sma_init (SMA_INFO, NULL);

  // Allocation
  p[1] = sma_malloc (10 * sizeof (*p[1]));
  // Ecriture en dehors de la zone allouée
  p[1][10] = 1;
  p[1][-1] = 1;

  // Réallocation
  p[1] = sma_realloc (p[1], 20);

  // Enregistrement d'une allocation externe
  p[2] = strdup ("sma");
  sma_register (p[2]);

  // Affiche l'état du gestionnaire
  sma_profil ();

  // Fuite mémoire
  p[1]++;

  // Libération
  sma_free (p[1]);
  sma_free (p[2]);

  return 0;
}

Compilation :

gcc `pkg-config --cflags --libs sma` main.c

Et le résultat sur la sortie standard :

===== malloc (10) dans main.c:14 =====
        + 10 octects a 003E4EFC

===== realloc 20 dans main.c:20 =====
Warning : Underflow a 003E4EFC[-1]
Warning : Overflow a 003E4EFC[10]
        - 10 octects a 003E4EFC dans main.c:14
        + 20 octects dans 003E3EBC

===== Allocation externe dans main.c:24 =====
Enregistrement de 003E3EE0 dans main.c:24

|----------------------------------------------------------------|
|                        Profile memoire                         |
|                                                  main.c     27 |
|----------------------------------------------------------------|
|  Taille  |   Addr   |  Ligne |  Fichier                        |
|----------------------------------------------------------------|
|       20 | 003E3EBC |     20 |                          main.c |
|        x | 003E3EE0 |     24 |                          main.c |
|----------------------------------------------------------------|

===== free dans main.c:33 =====
Warning : Adresse inconnue 003E3EBD dans main.c:33

===== free dans main.c:34 =====
Liberation de 003E3EE0 dans main.c:34 enregistre dans main.c:24

===== Fuites memoire =====
|----------------------------------------------------------------|
|                        Profile memoire                         |
|                                                internal      0 |
|----------------------------------------------------------------|
|  Taille  |   Addr   |  Ligne |  Fichier                        |
|----------------------------------------------------------------|
|       20 | 003E3EBC |     20 |                          main.c |
|----------------------------------------------------------------|

===== free dans internal:0 =====
Liberation de 003E3EBC (20 octects) dans internal:0 alloues dans main.c:20
Warning : Underflow a 003E3EBC[-1]

Licence

SMA - Secure Memory Allocator
Copyright (C) 2006, 2007, 2008 Nicolas Joseph

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 3 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Library General Public License for more details.

You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the
Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.

À faire:

Rendre la surcharge des fonctions standard optionnelle

Si la surcharge est demandée, l'utilisateur doit définir une macro afin de vérifier qu'il est au courant de ce qu'il fait

Fichier .pc

Makefile

Macros

#define sma_init(log_level, file_name)

#define sma_malloc(size)

#define malloc(size)

#define sma_calloc(nmemb, size)

#define calloc(nmemb, size)

#define sma_realloc(ptr, size)

#define realloc(ptr, size)

#define sma_register(ptr)

#define sma_free(ptr)

#define free(ptr)

#define sma_profil()

#define sma_is_register(ptr)

#define SMA_FILE__

#define sma_end

Énumérations

enum debug_level_e { SMA_NONE, SMA_ERROR, SMA_WARNING, SMA_INFO }

Fonctions

void sma_set_malloc (void *(*foo)(size_t))

void sma_set_calloc (void *(*foo)(size_t, size_t))

void sma_set_realloc (void *(*foo)(void *, size_t))

void sma_set_free (void(*foo)(void *))

Documentation des macros

#define sma_init	(	log_level,
		file_name		)

Initialise le gestionnaire de mémoire.

Paramètres:

`[in]`	log_level	: niveau d'information souhaitée.
`[in]`	file_name	: chemin du fichier de log, ou NULL les informations seront alors écritent sur stdout.

#define sma_malloc ( size )

Alloue size octets, et renvoie un pointeur sur la mémoire allouée.

Paramètres:

[in] size : taille de la zone mémoire souhaitée

Renvoie:: L'adresse du bloque nouvellement alloué. Ne retourne jamais NULL.

#define malloc ( size )

Voir également:: sma_malloc

#define sma_calloc	(	nmemb,
		size		)

Alloue size octets, et renvoie un pointeur sur la mémoire allouée.

Paramètres:

`[in]`	nmemb	: nombre d'objets
`[in]`	size	: taille d'un objet

Renvoie:: L'adresse du bloque nouvellement alloué. Ne retourne jamais NULL.

#define calloc	(	nmemb,
		size		)

Voir également:: sma_calloc

#define sma_realloc	(	ptr,
		size		)

Modifie la taille du bloc de mémoire pointé par ptr pour l'amener à une taille de size octets.

Paramètres:

`[in]`	ptr	: pointeur sur la zone mémoire à modifier.
`[in]`	size	: nouvelle taille.

Renvoie:: un pointeur sur la mémoire nouvellement allouée.

#define realloc	(	ptr,
		size		)

Voir également:: sma_realloc

#define sma_register ( ptr )

Enregitre un pointeur sur une zone mémoire alloue en dehors du code, par exemple avec strdup.

Paramètres:

[in] ptr : le pointeur à enregistrer.

#define sma_free ( ptr )

Libère l'espace mémoire pointé par p, qui a été obtenu lors d'un appel antérieur à malloc, calloc ou realloc.

Paramètres:

[in] ptr : adresse de la zone mémoire à libérer.

#define free ( ptr )

Voir également:: sma_free

#define sma_profil ( )

Affiche l'état de la mémoire.

#define sma_is_register ( ptr )

Permet de savoir si une adresse est connue du gestionnaire.

Paramètres:

[in] ptr : adresse a tester.

Renvoie:: 1 si l'adresse est enregsitrée, 0 sinon.

#define SMA_FILE__

À usage interne uniquement.

#define sma_end

Termine le gestionnaire de mémoire en vérifiant les fuites mémoire.

Obsolète:: Cette fonction est maintenant appelée automatiquement à la fin du programme.

Documentation du type de l'énumération

enum debug_level_e

Niveau d'affichage des informations de débugage.

Valeurs énumérées:

SMA_NONE	Aucun affichage
SMA_ERROR	Affiche uniquement les erreurs critiques
SMA_WARNING	Affiche toutes les erreurs
SMA_INFO	Affiche toutes les informations (très verbeux)

Documentation des fonctions

void sma_set_malloc ( void *(*)(size_t) foo )

Modifie la fonction à utiliser pour allouer la mémoire. Par défaut il s'agit de malloc.

Paramètres:

[in] foo : fonction malloc like.

void sma_set_calloc ( void *(*)(size_t, size_t) foo )

Modifie la fonction à utiliser pour allouer la mémoire en remplissant la zone allouée à zéro. Par défaut il s'agit de calloc.

Paramètres:

[in] foo : fonction calloc like.

void sma_set_realloc ( void *(*)(void *, size_t) foo )

Modifie la fonction à utiliser pour réallouer la mémoire. Par défaut il s'agit de realloc.

Paramètres:

[in] foo : fonction realloc like.

void sma_set_free ( void(*)(void *) foo )

Modifie la fonction à utiliser pour libérer la mémoire. Par défaut il s'agit de free.

Paramètres:

[in] foo : fonction free like.

Généré le Fri Jan 4 15:46:05 2008 pour Secure Memory Allocator par

1.5.4


Macros
#define	sma_init(log_level, file_name)
#define	sma_malloc(size)
#define	malloc(size)
#define	sma_calloc(nmemb, size)
#define	calloc(nmemb, size)
#define	sma_realloc(ptr, size)
#define	realloc(ptr, size)
#define	sma_register(ptr)
#define	sma_free(ptr)
#define	free(ptr)
#define	sma_profil()
#define	sma_is_register(ptr)
#define	SMA_FILE__
#define	sma_end
Énumérations
enum	debug_level_e { SMA_NONE, SMA_ERROR, SMA_WARNING, SMA_INFO }
Fonctions
void	sma_set_malloc (void (foo)(size_t))
void	sma_set_calloc (void (foo)(size_t, size_t))
void	sma_set_realloc (void (foo)(void *, size_t))
void	sma_set_free (void(foo)(void ))

Référence du fichier sma.h

Description détaillée

Sommaire

Description

Installation

Exemple

Licence

Macros

Énumérations

Fonctions

Documentation des macros

Documentation du type de l'énumération

Documentation des fonctions