1 diff --git a/third_party/lcms/src/cmserr.c b/third_party/lcms/src/cmserr.c 2 index 700152ee3..3c3848b2a 100644 3 --- a/third_party/lcms/src/cmserr.c 4 +++ b/third_party/lcms/src/cmserr.c 5 @@ -25,6 +25,8 @@ 6 7 #include "lcms2_internal.h" 8 9 +#include "core/fxcrt/fx_memory.h" 10 +#include "core/fxcrt/fx_system.h" 11 12 // This function is here to help applications to prevent mixing lcms versions on header and shared objects. 13 int CMSEXPORT cmsGetEncodedCMMversion(void) 14 @@ -65,140 +67,75 @@ long int CMSEXPORT cmsfilelength(FILE* f) 15 return n; 16 } 17 18 - 19 -// Memory handling ------------------------------------------------------------------ 20 -// 21 -// This is the interface to low-level memory management routines. By default a simple 22 -// wrapping to malloc/free/realloc is provided, although there is a limit on the max 23 -// amount of memoy that can be reclaimed. This is mostly as a safety feature to prevent 24 -// bogus or evil code to allocate huge blocks that otherwise lcms would never need. 25 - 26 -#define MAX_MEMORY_FOR_ALLOC ((cmsUInt32Number)(1024U*1024U*512U)) 27 - 28 -// User may override this behaviour by using a memory plug-in, which basically replaces 29 -// the default memory management functions. In this case, no check is performed and it 30 -// is up to the plug-in writter to keep in the safe side. There are only three functions 31 -// required to be implemented: malloc, realloc and free, although the user may want to 32 -// replace the optional mallocZero, calloc and dup as well. 33 - 34 -cmsBool _cmsRegisterMemHandlerPlugin(cmsContext ContextID, cmsPluginBase* Plugin); 35 - 36 -// ********************************************************************************* 37 - 38 -// This is the default memory allocation function. It does a very coarse 39 -// check of amout of memory, just to prevent exploits 40 -static 41 -void* _cmsMallocDefaultFn(cmsContext ContextID, cmsUInt32Number size) 42 +cmsBool _cmsRegisterMemHandlerPlugin(cmsContext ContextID, cmsPluginBase* Plugin) 43 { 44 - if (size > MAX_MEMORY_FOR_ALLOC) return NULL; // Never allow over maximum 45 - 46 - return (void*) malloc(size); 47 + return TRUE; 48 +} 49 50 - cmsUNUSED_PARAMETER(ContextID); 51 +// Generic allocate 52 +void* CMSEXPORT _cmsMalloc(cmsContext ContextID, cmsUInt32Number size) 53 +{ 54 + return FXMEM_DefaultAlloc(size); 55 } 56 57 // Generic allocate & zero 58 -static 59 -void* _cmsMallocZeroDefaultFn(cmsContext ContextID, cmsUInt32Number size) 60 +void* CMSEXPORT _cmsMallocZero(cmsContext ContextID, cmsUInt32Number size) 61 { 62 - void *pt = _cmsMalloc(ContextID, size); 63 - if (pt == NULL) return NULL; 64 - 65 - memset(pt, 0, size); 66 - return pt; 67 + void* p = FXMEM_DefaultAlloc(size); 68 + if (p) memset(p, 0, size); 69 + return p; 70 } 71 72 - 73 -// The default free function. The only check proformed is against NULL pointers 74 -static 75 -void _cmsFreeDefaultFn(cmsContext ContextID, void *Ptr) 76 +// Generic calloc 77 +void* CMSEXPORT _cmsCalloc(cmsContext ContextID, cmsUInt32Number num, cmsUInt32Number size) 78 { 79 - // free(NULL) is defined a no-op by C99, therefore it is safe to 80 - // avoid the check, but it is here just in case... 81 - 82 - if (Ptr) free(Ptr); 83 + cmsUInt32Number total = num * size; 84 + if (total == 0 || total / size != num || total >= 512 * 1024 * 1024) 85 + return NULL; 86 87 - cmsUNUSED_PARAMETER(ContextID); 88 + return _cmsMallocZero(ContextID, num * size); 89 } 90 91 -// The default realloc function. Again it checks for exploits. If Ptr is NULL, 92 -// realloc behaves the same way as malloc and allocates a new block of size bytes. 93 -static 94 -void* _cmsReallocDefaultFn(cmsContext ContextID, void* Ptr, cmsUInt32Number size) 95 +// Generic reallocate 96 +void* CMSEXPORT _cmsRealloc(cmsContext ContextID, void* Ptr, cmsUInt32Number size) 97 { 98 - 99 - if (size > MAX_MEMORY_FOR_ALLOC) return NULL; // Never realloc over 512Mb 100 - 101 - return realloc(Ptr, size); 102 - 103 - cmsUNUSED_PARAMETER(ContextID); 104 + return FXMEM_DefaultRealloc(Ptr, size); 105 } 106 107 - 108 -// The default calloc function. Allocates an array of num elements, each one of size bytes 109 -// all memory is initialized to zero. 110 -static 111 -void* _cmsCallocDefaultFn(cmsContext ContextID, cmsUInt32Number num, cmsUInt32Number size) 112 +// Generic free memory 113 +void CMSEXPORT _cmsFree(cmsContext ContextID, void* Ptr) 114 { 115 - cmsUInt32Number Total = num * size; 116 - 117 - // Preserve calloc behaviour 118 - if (Total == 0) return NULL; 119 - 120 - // Safe check for overflow. 121 - if (num >= UINT_MAX / size) return NULL; 122 - 123 - // Check for overflow 124 - if (Total < num || Total < size) { 125 - return NULL; 126 - } 127 - 128 - if (Total > MAX_MEMORY_FOR_ALLOC) return NULL; // Never alloc over 512Mb 129 - 130 - return _cmsMallocZero(ContextID, Total); 131 + if (Ptr != NULL) FXMEM_DefaultFree(Ptr); 132 } 133 134 // Generic block duplication 135 -static 136 -void* _cmsDupDefaultFn(cmsContext ContextID, const void* Org, cmsUInt32Number size) 137 +void* CMSEXPORT _cmsDupMem(cmsContext ContextID, const void* Org, cmsUInt32Number size) 138 { 139 - void* mem; 140 - 141 - if (size > MAX_MEMORY_FOR_ALLOC) return NULL; // Never dup over 512Mb 142 - 143 - mem = _cmsMalloc(ContextID, size); 144 - 145 - if (mem != NULL && Org != NULL) 146 - memmove(mem, Org, size); 147 - 148 - return mem; 149 + void* p = FXMEM_DefaultAlloc(size); 150 + memmove(p, Org, size); 151 + return p; 152 } 153 154 - 155 -// Pointers to memory manager functions in Context0 156 -_cmsMemPluginChunkType _cmsMemPluginChunk = { _cmsMallocDefaultFn, _cmsMallocZeroDefaultFn, _cmsFreeDefaultFn, 157 - _cmsReallocDefaultFn, _cmsCallocDefaultFn, _cmsDupDefaultFn 158 +_cmsMemPluginChunkType _cmsMemPluginChunk = {_cmsMalloc, _cmsMallocZero, _cmsFree, 159 + _cmsRealloc, _cmsCalloc, _cmsDupMem 160 }; 161 162 - 163 -// Reset and duplicate memory manager 164 void _cmsAllocMemPluginChunk(struct _cmsContext_struct* ctx, const struct _cmsContext_struct* src) 165 { 166 _cmsAssert(ctx != NULL); 167 168 - if (src != NULL) { 169 + if (src != NULL) { 170 171 // Duplicate 172 - ctx ->chunks[MemPlugin] = _cmsSubAllocDup(ctx ->MemPool, src ->chunks[MemPlugin], sizeof(_cmsMemPluginChunkType)); 173 + ctx ->chunks[MemPlugin] = _cmsSubAllocDup(ctx ->MemPool, src ->chunks[MemPlugin], sizeof(_cmsMemPluginChunkType)); 174 } 175 else { 176 177 // To reset it, we use the default allocators, which cannot be overriden 178 ctx ->chunks[MemPlugin] = &ctx ->DefaultMemoryManager; 179 - } 180 + } 181 } 182 183 -// Auxiliary to fill memory management functions from plugin (or context 0 defaults) 184 void _cmsInstallAllocFunctions(cmsPluginMemHandler* Plugin, _cmsMemPluginChunkType* ptr) 185 { 186 if (Plugin == NULL) { 187 @@ -212,94 +149,15 @@ void _cmsInstallAllocFunctions(cmsPluginMemHandler* Plugin, _cmsMemPluginChunkTy 188 ptr ->ReallocPtr = Plugin -> ReallocPtr; 189 190 // Make sure we revert to defaults 191 - ptr ->MallocZeroPtr= _cmsMallocZeroDefaultFn; 192 - ptr ->CallocPtr = _cmsCallocDefaultFn; 193 - ptr ->DupPtr = _cmsDupDefaultFn; 194 - 195 + ptr ->MallocZeroPtr= _cmsMallocZero; 196 + ptr ->CallocPtr = _cmsCalloc; 197 + ptr ->DupPtr = _cmsDupMem; 198 + 199 if (Plugin ->MallocZeroPtr != NULL) ptr ->MallocZeroPtr = Plugin -> MallocZeroPtr; 200 if (Plugin ->CallocPtr != NULL) ptr ->CallocPtr = Plugin -> CallocPtr; 201 if (Plugin ->DupPtr != NULL) ptr ->DupPtr = Plugin -> DupPtr; 202 - 203 - } 204 -} 205 - 206 207 -// Plug-in replacement entry 208 -cmsBool _cmsRegisterMemHandlerPlugin(cmsContext ContextID, cmsPluginBase *Data) 209 -{ 210 - cmsPluginMemHandler* Plugin = (cmsPluginMemHandler*) Data; 211 - _cmsMemPluginChunkType* ptr; 212 - 213 - // NULL forces to reset to defaults. In this special case, the defaults are stored in the context structure. 214 - // Remaining plug-ins does NOT have any copy in the context structure, but this is somehow special as the 215 - // context internal data should be malloce'd by using those functions. 216 - if (Data == NULL) { 217 - 218 - struct _cmsContext_struct* ctx = ( struct _cmsContext_struct*) ContextID; 219 - 220 - // Return to the default allocators 221 - if (ContextID != NULL) { 222 - ctx->chunks[MemPlugin] = (void*) &ctx->DefaultMemoryManager; 223 - } 224 - return TRUE; 225 } 226 - 227 - // Check for required callbacks 228 - if (Plugin -> MallocPtr == NULL || 229 - Plugin -> FreePtr == NULL || 230 - Plugin -> ReallocPtr == NULL) return FALSE; 231 - 232 - // Set replacement functions 233 - ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin); 234 - if (ptr == NULL) 235 - return FALSE; 236 - 237 - _cmsInstallAllocFunctions(Plugin, ptr); 238 - return TRUE; 239 -} 240 - 241 -// Generic allocate 242 -void* CMSEXPORT _cmsMalloc(cmsContext ContextID, cmsUInt32Number size) 243 -{ 244 - _cmsMemPluginChunkType* ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin); 245 - return ptr ->MallocPtr(ContextID, size); 246 -} 247 - 248 -// Generic allocate & zero 249 -void* CMSEXPORT _cmsMallocZero(cmsContext ContextID, cmsUInt32Number size) 250 -{ 251 - _cmsMemPluginChunkType* ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin); 252 - return ptr->MallocZeroPtr(ContextID, size); 253 -} 254 - 255 -// Generic calloc 256 -void* CMSEXPORT _cmsCalloc(cmsContext ContextID, cmsUInt32Number num, cmsUInt32Number size) 257 -{ 258 - _cmsMemPluginChunkType* ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin); 259 - return ptr->CallocPtr(ContextID, num, size); 260 -} 261 - 262 -// Generic reallocate 263 -void* CMSEXPORT _cmsRealloc(cmsContext ContextID, void* Ptr, cmsUInt32Number size) 264 -{ 265 - _cmsMemPluginChunkType* ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin); 266 - return ptr->ReallocPtr(ContextID, Ptr, size); 267 -} 268 - 269 -// Generic free memory 270 -void CMSEXPORT _cmsFree(cmsContext ContextID, void* Ptr) 271 -{ 272 - if (Ptr != NULL) { 273 - _cmsMemPluginChunkType* ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin); 274 - ptr ->FreePtr(ContextID, Ptr); 275 - } 276 -} 277 - 278 -// Generic block duplication 279 -void* CMSEXPORT _cmsDupMem(cmsContext ContextID, const void* Org, cmsUInt32Number size) 280 -{ 281 - _cmsMemPluginChunkType* ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin); 282 - return ptr ->DupPtr(ContextID, Org, size); 283 } 284 285 // ******************************************************************************************** 286
