You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
286 lines
10 KiB
286 lines
10 KiB
diff --git a/third_party/lcms/src/cmserr.c b/third_party/lcms/src/cmserr.c
|
|
index 700152ee3..3c3848b2a 100644
|
|
--- a/third_party/lcms/src/cmserr.c
|
|
+++ b/third_party/lcms/src/cmserr.c
|
|
@@ -25,6 +25,8 @@
|
|
|
|
#include "lcms2_internal.h"
|
|
|
|
+#include "core/fxcrt/fx_memory.h"
|
|
+#include "core/fxcrt/fx_system.h"
|
|
|
|
// This function is here to help applications to prevent mixing lcms versions on header and shared objects.
|
|
int CMSEXPORT cmsGetEncodedCMMversion(void)
|
|
@@ -67,140 +67,75 @@ long int CMSEXPORT cmsfilelength(FILE* f)
|
|
return n;
|
|
}
|
|
|
|
-
|
|
-// Memory handling ------------------------------------------------------------------
|
|
-//
|
|
-// This is the interface to low-level memory management routines. By default a simple
|
|
-// wrapping to malloc/free/realloc is provided, although there is a limit on the max
|
|
-// amount of memoy that can be reclaimed. This is mostly as a safety feature to prevent
|
|
-// bogus or evil code to allocate huge blocks that otherwise lcms would never need.
|
|
-
|
|
-#define MAX_MEMORY_FOR_ALLOC ((cmsUInt32Number)(1024U*1024U*512U))
|
|
-
|
|
-// User may override this behaviour by using a memory plug-in, which basically replaces
|
|
-// the default memory management functions. In this case, no check is performed and it
|
|
-// is up to the plug-in writter to keep in the safe side. There are only three functions
|
|
-// required to be implemented: malloc, realloc and free, although the user may want to
|
|
-// replace the optional mallocZero, calloc and dup as well.
|
|
-
|
|
-cmsBool _cmsRegisterMemHandlerPlugin(cmsContext ContextID, cmsPluginBase* Plugin);
|
|
-
|
|
-// *********************************************************************************
|
|
-
|
|
-// This is the default memory allocation function. It does a very coarse
|
|
-// check of amount of memory, just to prevent exploits
|
|
-static
|
|
-void* _cmsMallocDefaultFn(cmsContext ContextID, cmsUInt32Number size)
|
|
+cmsBool _cmsRegisterMemHandlerPlugin(cmsContext ContextID, cmsPluginBase* Plugin)
|
|
{
|
|
- if (size > MAX_MEMORY_FOR_ALLOC) return NULL; // Never allow over maximum
|
|
-
|
|
- return (void*) malloc(size);
|
|
+ return TRUE;
|
|
+}
|
|
|
|
- cmsUNUSED_PARAMETER(ContextID);
|
|
+// Generic allocate
|
|
+void* CMSEXPORT _cmsMalloc(cmsContext ContextID, cmsUInt32Number size)
|
|
+{
|
|
+ return FXMEM_DefaultAlloc(size);
|
|
}
|
|
|
|
// Generic allocate & zero
|
|
-static
|
|
-void* _cmsMallocZeroDefaultFn(cmsContext ContextID, cmsUInt32Number size)
|
|
+void* CMSEXPORT _cmsMallocZero(cmsContext ContextID, cmsUInt32Number size)
|
|
{
|
|
- void *pt = _cmsMalloc(ContextID, size);
|
|
- if (pt == NULL) return NULL;
|
|
-
|
|
- memset(pt, 0, size);
|
|
- return pt;
|
|
+ void* p = FXMEM_DefaultAlloc(size);
|
|
+ if (p) memset(p, 0, size);
|
|
+ return p;
|
|
}
|
|
|
|
-
|
|
-// The default free function. The only check proformed is against NULL pointers
|
|
-static
|
|
-void _cmsFreeDefaultFn(cmsContext ContextID, void *Ptr)
|
|
+// Generic calloc
|
|
+void* CMSEXPORT _cmsCalloc(cmsContext ContextID, cmsUInt32Number num, cmsUInt32Number size)
|
|
{
|
|
- // free(NULL) is defined a no-op by C99, therefore it is safe to
|
|
- // avoid the check, but it is here just in case...
|
|
-
|
|
- if (Ptr) free(Ptr);
|
|
+ cmsUInt32Number total = num * size;
|
|
+ if (total == 0 || total / size != num || total >= 512 * 1024 * 1024)
|
|
+ return NULL;
|
|
|
|
- cmsUNUSED_PARAMETER(ContextID);
|
|
+ return _cmsMallocZero(ContextID, num * size);
|
|
}
|
|
|
|
-// The default realloc function. Again it checks for exploits. If Ptr is NULL,
|
|
-// realloc behaves the same way as malloc and allocates a new block of size bytes.
|
|
-static
|
|
-void* _cmsReallocDefaultFn(cmsContext ContextID, void* Ptr, cmsUInt32Number size)
|
|
+// Generic reallocate
|
|
+void* CMSEXPORT _cmsRealloc(cmsContext ContextID, void* Ptr, cmsUInt32Number size)
|
|
{
|
|
-
|
|
- if (size > MAX_MEMORY_FOR_ALLOC) return NULL; // Never realloc over 512Mb
|
|
-
|
|
- return realloc(Ptr, size);
|
|
-
|
|
- cmsUNUSED_PARAMETER(ContextID);
|
|
+ return FXMEM_DefaultRealloc(Ptr, size);
|
|
}
|
|
|
|
-
|
|
-// The default calloc function. Allocates an array of num elements, each one of size bytes
|
|
-// all memory is initialized to zero.
|
|
-static
|
|
-void* _cmsCallocDefaultFn(cmsContext ContextID, cmsUInt32Number num, cmsUInt32Number size)
|
|
+// Generic free memory
|
|
+void CMSEXPORT _cmsFree(cmsContext ContextID, void* Ptr)
|
|
{
|
|
- cmsUInt32Number Total = num * size;
|
|
-
|
|
- // Preserve calloc behaviour
|
|
- if (Total == 0) return NULL;
|
|
-
|
|
- // Safe check for overflow.
|
|
- if (num >= UINT_MAX / size) return NULL;
|
|
-
|
|
- // Check for overflow
|
|
- if (Total < num || Total < size) {
|
|
- return NULL;
|
|
- }
|
|
-
|
|
- if (Total > MAX_MEMORY_FOR_ALLOC) return NULL; // Never alloc over 512Mb
|
|
-
|
|
- return _cmsMallocZero(ContextID, Total);
|
|
+ if (Ptr != NULL) FXMEM_DefaultFree(Ptr);
|
|
}
|
|
|
|
// Generic block duplication
|
|
-static
|
|
-void* _cmsDupDefaultFn(cmsContext ContextID, const void* Org, cmsUInt32Number size)
|
|
+void* CMSEXPORT _cmsDupMem(cmsContext ContextID, const void* Org, cmsUInt32Number size)
|
|
{
|
|
- void* mem;
|
|
-
|
|
- if (size > MAX_MEMORY_FOR_ALLOC) return NULL; // Never dup over 512Mb
|
|
-
|
|
- mem = _cmsMalloc(ContextID, size);
|
|
-
|
|
- if (mem != NULL && Org != NULL)
|
|
- memmove(mem, Org, size);
|
|
-
|
|
- return mem;
|
|
+ void* p = FXMEM_DefaultAlloc(size);
|
|
+ memmove(p, Org, size);
|
|
+ return p;
|
|
}
|
|
|
|
-
|
|
-// Pointers to memory manager functions in Context0
|
|
-_cmsMemPluginChunkType _cmsMemPluginChunk = { _cmsMallocDefaultFn, _cmsMallocZeroDefaultFn, _cmsFreeDefaultFn,
|
|
- _cmsReallocDefaultFn, _cmsCallocDefaultFn, _cmsDupDefaultFn
|
|
+_cmsMemPluginChunkType _cmsMemPluginChunk = {_cmsMalloc, _cmsMallocZero, _cmsFree,
|
|
+ _cmsRealloc, _cmsCalloc, _cmsDupMem
|
|
};
|
|
|
|
-
|
|
-// Reset and duplicate memory manager
|
|
void _cmsAllocMemPluginChunk(struct _cmsContext_struct* ctx, const struct _cmsContext_struct* src)
|
|
{
|
|
_cmsAssert(ctx != NULL);
|
|
|
|
- if (src != NULL) {
|
|
+ if (src != NULL) {
|
|
|
|
// Duplicate
|
|
- ctx ->chunks[MemPlugin] = _cmsSubAllocDup(ctx ->MemPool, src ->chunks[MemPlugin], sizeof(_cmsMemPluginChunkType));
|
|
+ ctx ->chunks[MemPlugin] = _cmsSubAllocDup(ctx ->MemPool, src ->chunks[MemPlugin], sizeof(_cmsMemPluginChunkType));
|
|
}
|
|
else {
|
|
|
|
// To reset it, we use the default allocators, which cannot be overridden
|
|
ctx ->chunks[MemPlugin] = &ctx ->DefaultMemoryManager;
|
|
- }
|
|
+ }
|
|
}
|
|
|
|
-// Auxiliary to fill memory management functions from plugin (or context 0 defaults)
|
|
void _cmsInstallAllocFunctions(cmsPluginMemHandler* Plugin, _cmsMemPluginChunkType* ptr)
|
|
{
|
|
if (Plugin == NULL) {
|
|
@@ -214,94 +149,15 @@ void _cmsInstallAllocFunctions(cmsPluginMemHandler* Plugin, _cmsMemPluginChunkTy
|
|
ptr ->ReallocPtr = Plugin -> ReallocPtr;
|
|
|
|
// Make sure we revert to defaults
|
|
- ptr ->MallocZeroPtr= _cmsMallocZeroDefaultFn;
|
|
- ptr ->CallocPtr = _cmsCallocDefaultFn;
|
|
- ptr ->DupPtr = _cmsDupDefaultFn;
|
|
-
|
|
+ ptr ->MallocZeroPtr= _cmsMallocZero;
|
|
+ ptr ->CallocPtr = _cmsCalloc;
|
|
+ ptr ->DupPtr = _cmsDupMem;
|
|
+
|
|
if (Plugin ->MallocZeroPtr != NULL) ptr ->MallocZeroPtr = Plugin -> MallocZeroPtr;
|
|
if (Plugin ->CallocPtr != NULL) ptr ->CallocPtr = Plugin -> CallocPtr;
|
|
if (Plugin ->DupPtr != NULL) ptr ->DupPtr = Plugin -> DupPtr;
|
|
-
|
|
- }
|
|
-}
|
|
-
|
|
|
|
-// Plug-in replacement entry
|
|
-cmsBool _cmsRegisterMemHandlerPlugin(cmsContext ContextID, cmsPluginBase *Data)
|
|
-{
|
|
- cmsPluginMemHandler* Plugin = (cmsPluginMemHandler*) Data;
|
|
- _cmsMemPluginChunkType* ptr;
|
|
-
|
|
- // NULL forces to reset to defaults. In this special case, the defaults are stored in the context structure.
|
|
- // Remaining plug-ins does NOT have any copy in the context structure, but this is somehow special as the
|
|
- // context internal data should be malloce'd by using those functions.
|
|
- if (Data == NULL) {
|
|
-
|
|
- struct _cmsContext_struct* ctx = ( struct _cmsContext_struct*) ContextID;
|
|
-
|
|
- // Return to the default allocators
|
|
- if (ContextID != NULL) {
|
|
- ctx->chunks[MemPlugin] = (void*) &ctx->DefaultMemoryManager;
|
|
- }
|
|
- return TRUE;
|
|
}
|
|
-
|
|
- // Check for required callbacks
|
|
- if (Plugin -> MallocPtr == NULL ||
|
|
- Plugin -> FreePtr == NULL ||
|
|
- Plugin -> ReallocPtr == NULL) return FALSE;
|
|
-
|
|
- // Set replacement functions
|
|
- ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin);
|
|
- if (ptr == NULL)
|
|
- return FALSE;
|
|
-
|
|
- _cmsInstallAllocFunctions(Plugin, ptr);
|
|
- return TRUE;
|
|
-}
|
|
-
|
|
-// Generic allocate
|
|
-void* CMSEXPORT _cmsMalloc(cmsContext ContextID, cmsUInt32Number size)
|
|
-{
|
|
- _cmsMemPluginChunkType* ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin);
|
|
- return ptr ->MallocPtr(ContextID, size);
|
|
-}
|
|
-
|
|
-// Generic allocate & zero
|
|
-void* CMSEXPORT _cmsMallocZero(cmsContext ContextID, cmsUInt32Number size)
|
|
-{
|
|
- _cmsMemPluginChunkType* ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin);
|
|
- return ptr->MallocZeroPtr(ContextID, size);
|
|
-}
|
|
-
|
|
-// Generic calloc
|
|
-void* CMSEXPORT _cmsCalloc(cmsContext ContextID, cmsUInt32Number num, cmsUInt32Number size)
|
|
-{
|
|
- _cmsMemPluginChunkType* ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin);
|
|
- return ptr->CallocPtr(ContextID, num, size);
|
|
-}
|
|
-
|
|
-// Generic reallocate
|
|
-void* CMSEXPORT _cmsRealloc(cmsContext ContextID, void* Ptr, cmsUInt32Number size)
|
|
-{
|
|
- _cmsMemPluginChunkType* ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin);
|
|
- return ptr->ReallocPtr(ContextID, Ptr, size);
|
|
-}
|
|
-
|
|
-// Generic free memory
|
|
-void CMSEXPORT _cmsFree(cmsContext ContextID, void* Ptr)
|
|
-{
|
|
- if (Ptr != NULL) {
|
|
- _cmsMemPluginChunkType* ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin);
|
|
- ptr ->FreePtr(ContextID, Ptr);
|
|
- }
|
|
-}
|
|
-
|
|
-// Generic block duplication
|
|
-void* CMSEXPORT _cmsDupMem(cmsContext ContextID, const void* Org, cmsUInt32Number size)
|
|
-{
|
|
- _cmsMemPluginChunkType* ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin);
|
|
- return ptr ->DupPtr(ContextID, Org, size);
|
|
}
|
|
|
|
// ********************************************************************************************
|