server/allocate.c

   1 /*
   2  * allocate.c
   3  *
   4  * Copyright (C) 2006-2011  Marek Lindner <lindner_marek@yahoo.de>
   5  * Copyright (C) 2006-2011  Simon Wunderlich <dotslash@packetmixer.de>
   6  *
   7  * This file is part of s3d, a 3d network display server.
   8  * See http://s3d.berlios.de/ for more updates.
   9  *
  10  * s3d is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * s3d is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with s3d; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  23  */
  24
  25 /* this file is taken from the batman project (www.open-mesh.net/batman)
  26  * to find heap corruptions... */
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31
  32 #include "allocate.h"
  33
  34 #define DEBUG_MALLOC
  35
  36 #define MAGIC_NUMBER 0x12345678
  37
  38 #if defined DEBUG_MALLOC
  39
  40 static struct chunkHeader *chunkList = NULL;
  41
  42 struct chunkHeader {
  43         struct chunkHeader *next;
  44         unsigned int length;
  45         int tag;
  46         unsigned int magicNumber;
  47 };
  48
  49 struct chunkTrailer {
  50         unsigned int magicNumber;
  51 };
  52
  53 void checkIntegrity(void)
  54 {
  55         struct chunkHeader *walker;
  56         struct chunkTrailer *chunkTrailer;
  57         unsigned char *memory;
  58
  59         for (walker = chunkList; walker != NULL; walker = walker->next) {
  60                 if (walker->magicNumber != MAGIC_NUMBER) {
  61                         fprintf(stderr, "Invalid magic number in header: %08x, tag = %d\n", walker->magicNumber, walker->tag);
  62                         exit(1);
  63                 }
  64
  65                 memory = (unsigned char *)walker;
  66
  67                 chunkTrailer = (struct chunkTrailer *)(memory + sizeof(struct chunkHeader) + walker->length);
  68
  69                 if (chunkTrailer->magicNumber != MAGIC_NUMBER) {
  70                         fprintf(stderr, "Invalid magic number in header: %08x, tag = %d\n", chunkTrailer->magicNumber, walker->tag);
  71                         exit(1);
  72                 }
  73         }
  74 }
  75
  76 void checkLeak(void)
  77 {
  78         struct chunkHeader *walker;
  79
  80         for (walker = chunkList; walker != NULL; walker = walker->next)
  81                 fprintf(stderr, "Memory leak detected, tag = %d\n", walker->tag);
  82 }
  83
  84 void *debugMalloc(unsigned int length, int tag)
  85 {
  86         unsigned char *memory;
  87         struct chunkHeader *chunkHeader;
  88         struct chunkTrailer *chunkTrailer;
  89         unsigned char *chunk;
  90
  91         checkIntegrity();
  92
  93         memory = (unsigned char *)malloc(length + sizeof(struct chunkHeader) + sizeof(struct chunkTrailer));
  94
  95         if (memory == NULL) {
  96                 fprintf(stderr, "Cannot allocate %u bytes, tag = %d\n", (unsigned int)(length + sizeof(struct chunkHeader) + sizeof(struct chunkTrailer)), tag);
  97                 exit(1);
  98         }
  99
 100         chunkHeader = (struct chunkHeader *)memory;
 101         chunk = memory + sizeof(struct chunkHeader);
 102         chunkTrailer = (struct chunkTrailer *)(memory + sizeof(struct chunkHeader) + length);
 103
 104         chunkHeader->length = length;
 105         chunkHeader->tag = tag;
 106         chunkHeader->magicNumber = MAGIC_NUMBER;
 107
 108         chunkTrailer->magicNumber = MAGIC_NUMBER;
 109
 110         chunkHeader->next = chunkList;
 111         chunkList = chunkHeader;
 112
 113         return chunk;
 114 }
 115
 116 void *debugRealloc(void *memoryParameter, unsigned int length, int tag)
 117 {
 118         unsigned char *memory;
 119         struct chunkHeader *chunkHeader;
 120         struct chunkTrailer *chunkTrailer;
 121         unsigned char *result;
 122         unsigned int copyLength;
 123
 124         checkIntegrity();
 125
 126         if (memoryParameter) {  /* if memoryParameter==NULL, realloc() should work like malloc() !! */
 127                 memory = (unsigned char *)memoryParameter;
 128                 chunkHeader = (struct chunkHeader *)(memory - sizeof(struct chunkHeader));
 129
 130                 if (chunkHeader->magicNumber != MAGIC_NUMBER) {
 131                         fprintf(stderr, "Invalid magic number in header: %08x, tag = %d\n", chunkHeader->magicNumber, chunkHeader->tag);
 132                         exit(1);
 133                 }
 134
 135                 chunkTrailer = (struct chunkTrailer *)(memory + chunkHeader->length);
 136
 137                 if (chunkTrailer->magicNumber != MAGIC_NUMBER) {
 138                         fprintf(stderr, "Invalid magic number in header: %08x, tag = %d\n", chunkTrailer->magicNumber, chunkHeader->tag);
 139                         exit(1);
 140                 }
 141         }
 142
 143         result = (unsigned char *)debugMalloc(length, tag);
 144         if (memoryParameter) {
 145                 copyLength = length;
 146
 147                 if (copyLength > chunkHeader->length)
 148                         copyLength = chunkHeader->length;
 149
 150                 memcpy(result, memoryParameter, copyLength);
 151                 debugFree(memoryParameter);
 152         }
 153
 154         return result;
 155 }
 156
 157 void debugFree(void *memoryParameter)
 158 {
 159         unsigned char *memory;
 160         struct chunkHeader *chunkHeader;
 161         struct chunkTrailer *chunkTrailer;
 162         struct chunkHeader *walker;
 163         struct chunkHeader *previous;
 164
 165         checkIntegrity();
 166
 167         memory = (unsigned char *)memoryParameter;
 168         chunkHeader = (struct chunkHeader *)(memory - sizeof(struct chunkHeader));
 169
 170         if (chunkHeader->magicNumber != MAGIC_NUMBER) {
 171                 fprintf(stderr, "Invalid magic number in header: %08x, tag = %d\n", chunkHeader->magicNumber, chunkHeader->tag);
 172                 exit(1);
 173         }
 174
 175         previous = NULL;
 176
 177         for (walker = chunkList; walker != NULL; walker = walker->next) {
 178                 if (walker == chunkHeader)
 179                         break;
 180
 181                 previous = walker;
 182         }
 183
 184         if (walker == NULL) {
 185                 fprintf(stderr, "Double free detected, tag = %d\n", chunkHeader->tag);
 186                 exit(1);
 187         }
 188
 189         if (previous == NULL)
 190                 chunkList = walker->next;
 191
 192         else
 193                 previous->next = walker->next;
 194
 195         chunkTrailer = (struct chunkTrailer *)(memory + chunkHeader->length);
 196
 197         if (chunkTrailer->magicNumber != MAGIC_NUMBER) {
 198                 fprintf(stderr, "Invalid magic number in header: %08x, tag = %d\n", chunkTrailer->magicNumber, chunkHeader->tag);
 199                 exit(1);
 200         }
 201
 202         free(chunkHeader);
 203 }
 204
 205 #else
 206
 207 void checkIntegrity(void)
 208 {
 209 }
 210
 211 void checkLeak(void)
 212 {
 213 }
 214
 215 void *debugMalloc(unsigned int length, int tag)
 216 {
 217         void *result;
 218
 219         result = malloc(length);
 220
 221         if (result == NULL) {
 222                 fprintf(stderr, "Cannot allocate %u bytes, tag = %d\n", length, tag);
 223                 exit(1);
 224         }
 225
 226         return result;
 227 }
 228
 229 void *debugRealloc(void *memory, unsigned int length, int tag)
 230 {
 231         void *result;
 232
 233         result = realloc(memory, length);
 234
 235         if (result == NULL) {
 236                 fprintf(stderr, "Cannot re-allocate %u bytes, tag = %d\n", length, tag);
 237                 exit(1);
 238         }
 239
 240         return result;
 241 }
 242
 243 void debugFree(void *memory)
 244 {
 245         free(memory);
 246 }
 247
 248 #endif