"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 // ********************************************************************************************