intl/icu/source/common/cmemory.c@129ffea94266
intl/icu/source/common/cmemory.c
Sat, 03 Jan 2015 20:18:00 +0100
- author
- Michael Schloh von Bennewitz <michael@schloh.com>
- date
- Sat, 03 Jan 2015 20:18:00 +0100
- branch
- TOR_BUG_3246
- changeset 7
- 129ffea94266
- permissions
- -rw-r--r--
Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.
1 /*
2 ******************************************************************************
3 *
4 * Copyright (C) 2002-2012, International Business Machines
5 * Corporation and others. All Rights Reserved.
6 *
7 ******************************************************************************
8 *
9 * File cmemory.c ICU Heap allocation.
10 * All ICU heap allocation, both for C and C++ new of ICU
11 * class types, comes through these functions.
12 *
13 * If you have a need to replace ICU allocation, this is the
14 * place to do it.
15 *
16 * Note that uprv_malloc(0) returns a non-NULL pointer, and
17 * that a subsequent free of that pointer value is a NOP.
18 *
19 ******************************************************************************
20 */
21 #include "unicode/uclean.h"
22 #include "cmemory.h"
23 #include "putilimp.h"
24 #include "uassert.h"
25 #include <stdlib.h>
27 /* uprv_malloc(0) returns a pointer to this read-only data. */
28 static const int32_t zeroMem[] = {0, 0, 0, 0, 0, 0};
30 /* Function Pointers for user-supplied heap functions */
31 static const void *pContext;
32 static UMemAllocFn *pAlloc;
33 static UMemReallocFn *pRealloc;
34 static UMemFreeFn *pFree;
36 /* Flag indicating whether any heap allocations have happened.
37 * Used to prevent changing out the heap functions after allocations have been made */
38 static UBool gHeapInUse;
40 #if U_DEBUG && defined(UPRV_MALLOC_COUNT)
41 #include <stdio.h>
42 static int n=0;
43 static long b=0;
44 #endif
46 #if U_DEBUG
48 static char gValidMemorySink = 0;
50 U_CAPI void uprv_checkValidMemory(const void *p, size_t n) {
51 /*
52 * Access the memory to ensure that it's all valid.
53 * Load and save a computed value to try to ensure that the compiler
54 * does not throw away the whole loop.
55 * A thread analyzer might complain about un-mutexed access to gValidMemorySink
56 * which is true but harmless because no one ever uses the value in gValidMemorySink.
57 */
58 const char *s = (const char *)p;
59 char c = gValidMemorySink;
60 size_t i;
61 U_ASSERT(p != NULL);
62 for(i = 0; i < n; ++i) {
63 c ^= s[i];
64 }
65 gValidMemorySink = c;
66 }
68 #endif /* U_DEBUG */
70 U_CAPI void * U_EXPORT2
71 uprv_malloc(size_t s) {
72 #if U_DEBUG && defined(UPRV_MALLOC_COUNT)
73 #if 1
74 putchar('>');
75 fflush(stdout);
76 #else
77 fprintf(stderr,"MALLOC\t#%d\t%ul bytes\t%ul total\n", ++n,s,(b+=s)); fflush(stderr);
78 #endif
79 #endif
80 if (s > 0) {
81 gHeapInUse = TRUE;
82 if (pAlloc) {
83 return (*pAlloc)(pContext, s);
84 } else {
85 return uprv_default_malloc(s);
86 }
87 } else {
88 return (void *)zeroMem;
89 }
90 }
92 U_CAPI void * U_EXPORT2
93 uprv_realloc(void * buffer, size_t size) {
94 #if U_DEBUG && defined(UPRV_MALLOC_COUNT)
95 putchar('~');
96 fflush(stdout);
97 #endif
98 if (buffer == zeroMem) {
99 return uprv_malloc(size);
100 } else if (size == 0) {
101 if (pFree) {
102 (*pFree)(pContext, buffer);
103 } else {
104 uprv_default_free(buffer);
105 }
106 return (void *)zeroMem;
107 } else {
108 gHeapInUse = TRUE;
109 if (pRealloc) {
110 return (*pRealloc)(pContext, buffer, size);
111 } else {
112 return uprv_default_realloc(buffer, size);
113 }
114 }
115 }
117 U_CAPI void U_EXPORT2
118 uprv_free(void *buffer) {
119 #if U_DEBUG && defined(UPRV_MALLOC_COUNT)
120 putchar('<');
121 fflush(stdout);
122 #endif
123 if (buffer != zeroMem) {
124 if (pFree) {
125 (*pFree)(pContext, buffer);
126 } else {
127 uprv_default_free(buffer);
128 }
129 }
130 }
132 U_CAPI void * U_EXPORT2
133 uprv_calloc(size_t num, size_t size) {
134 void *mem = NULL;
135 size *= num;
136 mem = uprv_malloc(size);
137 if (mem) {
138 uprv_memset(mem, 0, size);
139 }
140 return mem;
141 }
143 U_CAPI void U_EXPORT2
144 u_setMemoryFunctions(const void *context, UMemAllocFn *a, UMemReallocFn *r, UMemFreeFn *f, UErrorCode *status)
145 {
146 if (U_FAILURE(*status)) {
147 return;
148 }
149 if (a==NULL || r==NULL || f==NULL) {
150 *status = U_ILLEGAL_ARGUMENT_ERROR;
151 return;
152 }
153 if (gHeapInUse) {
154 *status = U_INVALID_STATE_ERROR;
155 return;
156 }
157 pContext = context;
158 pAlloc = a;
159 pRealloc = r;
160 pFree = f;
161 }
164 U_CFUNC UBool cmemory_cleanup(void) {
165 pContext = NULL;
166 pAlloc = NULL;
167 pRealloc = NULL;
168 pFree = NULL;
169 gHeapInUse = FALSE;
170 return TRUE;
171 }
174 /*
175 * gHeapInUse
176 * Return True if ICU has allocated any memory.
177 * Used by u_SetMutexFunctions() and similar to verify that ICU has not
178 * been used, that it is in a pristine initial state.
179 */
180 U_CFUNC UBool cmemory_inUse() {
181 return gHeapInUse;
182 }
