"Fossies" - the Fresh Open Source Software Archive

Member "qt-everywhere-src-6.3.1/qtwebengine/src/3rdparty/chromium/third_party/pdfium/third_party/lcms/0000-cmserr-changes.patch" (8 Jun 2022, 10354 Bytes) of package /linux/misc/qt-everywhere-src-6.3.1.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) Diff source code syntax highlighting (style: standard) with prefixed line numbers. Alternatively you can here view or download the uninterpreted source code file.

    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 @@ -67,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 amount 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 overridden
  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 @@ -214,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  // ********************************************************************************************