1 mike  1.1 /*
  2           **==============================================================================
  3           **
  4           ** Open Management Infrastructure (OMI)
  5           **
  6           ** Copyright (c) Microsoft Corporation
  7           ** 
  8           ** Licensed under the Apache License, Version 2.0 (the "License"); you may not 
  9           ** use this file except in compliance with the License. You may obtain a copy 
 10           ** of the License at 
 11           **
 12           **     http://www.apache.org/licenses/LICENSE-2.0 
 13           **
 14           ** THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 15           ** KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED 
 16           ** WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, 
 17           ** MERCHANTABLITY OR NON-INFRINGEMENT. 
 18           **
 19           ** See the Apache 2 License for the specific language governing permissions 
 20           ** and limitations under the License.
 21           **
 22 mike  1.1 **==============================================================================
 23           */
 24           

 25 mike  1.2 #include <stdio.h>
 26           #include "heap.h"
 27           #include "types.h"
 28           
 29           #define MAGIC 0x41E25C10
 30           
 31           typedef struct _MOF_Block
 32           {
 33               unsigned int magic;
 34               unsigned int size;
 35               struct _MOF_Block* next;
 36               struct _MOF_Block* prev;
 37           }
 38           MOF_Block;
 39           
 40           void* MOF_Malloc(MOF_Heap* self, size_t size)
 41           {
 42               MOF_Block* p;
 43           
 44               if (!self)
 45                   return NULL;
 46 mike  1.2 
 47               p = (MOF_Block*)malloc(sizeof(MOF_Block) + size);
 48           
 49               if (!p)
 50                   return NULL;
 51           
 52               if (self->head)
 53               {
 54                   p->prev = NULL;
 55                   p->next = self->head;
 56                   self->head->prev = p;
 57                   self->head = p;
 58               }
 59               else
 60               {
 61                   p->prev = NULL;
 62                   p->next = NULL;
 63                   self->head = p;
 64               }
 65           
 66               p->magic = MAGIC;
 67 mike  1.2     p->size = (unsigned int)size;
 68           
 69               /* Fill memory with a non-zero character */
 70               memset(p + 1, 0xAA, size);
 71           
 72               return p + 1;
 73           }
 74           
 75           void* MOF_Calloc(MOF_Heap* self, size_t count, size_t size)
 76           {
 77               void* ptr;
 78           
 79               if (!self)
 80                   return NULL;
 81           
 82               ptr = MOF_Malloc(self, count * size);
 83           
 84               if (!ptr)
 85                   return NULL;
 86           
 87               memset(ptr, 0, count * size);
 88 mike  1.2     return ptr;
 89           }
 90           
 91           void* MOF_Realloc(MOF_Heap* self, void* ptr, size_t size)
 92           {
 93               MOF_Block* p;
 94           
 95               if (!self)
 96                   return NULL;
 97           
 98               if (!ptr)
 99                   return MOF_Malloc(self, size);
100           
101               p = (MOF_Block*)ptr - 1;
102               MOF_ASSERT(p->magic == MAGIC);
103           
104           #if 0
105               /* Fill released part with a non-zero pattern */
106               if (p->size > size)
107                   memset((char*)ptr + size, 0xDD, p->size - size);
108           #endif
109 mike  1.2 
110               p = (MOF_Block*)realloc(p, sizeof(MOF_Block) + size);
111           
112               if (!p)
113                   return NULL;
114           
115           #if 0
116               /* Fill with a non-zero pattern */
117               if (size > p->size)
118                   memset((char*)(p + 1) + p->size, 0xFF, size - p->size);
119           #endif
120           
121               if (p->prev)
122                   p->prev->next = p;
123               else
124                   self->head = p;
125           
126               if (p->next)
127                   p->next->prev = p;
128           
129               p->size = (unsigned int)size;
130 mike  1.2 
131               return p + 1;
132           }
133           
134           void MOF_Free(MOF_Heap* self, void* ptr)
135           {
136               MOF_Block* p;
137           
138               if (!self || !ptr)
139                   return;
140           
141               p = (MOF_Block*)ptr - 1;
142               MOF_ASSERT(p->magic == MAGIC);
143           
144               if (p->prev)
145                   p->prev->next = p->next;
146               else
147                   self->head = p->next;
148           
149               if (p->next)
150                   p->next->prev = p->prev;
151 mike  1.2 
152               /* Fill released memory with 0xDD characters */
153               memset(p, 0xDD, sizeof(MOF_Block) + p->size);
154           
155               free(p);
156           }
157           
158           void MOF_Release(MOF_Heap* self)
159           {
160               MOF_Block* p;
161           
162               if (!self)
163                   return;
164           
165               for (p = self->head; p; )
166               {
167                   MOF_Block* next = p->next;
168                   free(p);
169                   p = next;
170               }
171           
172 mike  1.2     self->head = NULL;
173           }
174           
175           char* MOF_Strdup(MOF_Heap* self, const char* str)
176           {
177               char* p;
178               size_t n;
179           
180               if (!self || !str)
181                   return  NULL;
182           
183               n = strlen(str);
184               p = (char*)MOF_Malloc(self, n + 1);
185           
186               if (!p)
187                   return NULL;
188           
189               memcpy(p, str, n + 1);
190           
191               return p;
192           }