/src/php-src/Zend/zend_list.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | +----------------------------------------------------------------------+ |
3 | | | Zend Engine | |
4 | | +----------------------------------------------------------------------+ |
5 | | | Copyright (c) Zend Technologies Ltd. (http://www.zend.com) | |
6 | | +----------------------------------------------------------------------+ |
7 | | | This source file is subject to version 2.00 of the Zend license, | |
8 | | | that is bundled with this package in the file LICENSE, and is | |
9 | | | available through the world-wide-web at the following url: | |
10 | | | http://www.zend.com/license/2_00.txt. | |
11 | | | If you did not receive a copy of the Zend license and are unable to | |
12 | | | obtain it through the world-wide-web, please send a note to | |
13 | | | license@zend.com so we can mail you a copy immediately. | |
14 | | +----------------------------------------------------------------------+ |
15 | | | Authors: Andi Gutmans <andi@php.net> | |
16 | | | Zeev Suraski <zeev@php.net> | |
17 | | +----------------------------------------------------------------------+ |
18 | | */ |
19 | | |
20 | | /* resource lists */ |
21 | | |
22 | | #include "zend.h" |
23 | | #include "zend_list.h" |
24 | | #include "zend_API.h" |
25 | | #include "zend_globals.h" |
26 | | |
27 | | ZEND_API int le_index_ptr; |
28 | | |
29 | | /* true global */ |
30 | | static HashTable list_destructors; |
31 | | |
32 | | ZEND_API zval* ZEND_FASTCALL zend_list_insert(void *ptr, int type) |
33 | 6.47k | { |
34 | 6.47k | zval zv; |
35 | | |
36 | 6.47k | zend_long index = zend_hash_next_free_element(&EG(regular_list)); |
37 | 6.47k | if (index == 0) { |
38 | 6.27k | index = 1; |
39 | 6.27k | } else if (index == ZEND_LONG_MAX) { |
40 | 0 | zend_error_noreturn(E_ERROR, "Resource ID space overflow"); |
41 | 0 | } |
42 | 6.47k | ZVAL_NEW_RES(&zv, index, ptr, type); |
43 | 6.47k | return zend_hash_index_add_new(&EG(regular_list), index, &zv); |
44 | 6.47k | } |
45 | | |
46 | | ZEND_API zend_result ZEND_FASTCALL zend_list_delete(zend_resource *res) |
47 | 307 | { |
48 | 307 | if (GC_DELREF(res) <= 0) { |
49 | 145 | return zend_hash_index_del(&EG(regular_list), res->handle); |
50 | 162 | } else { |
51 | 162 | return SUCCESS; |
52 | 162 | } |
53 | 307 | } |
54 | | |
55 | | ZEND_API void ZEND_FASTCALL zend_list_free(zend_resource *res) |
56 | 6.20k | { |
57 | 6.20k | ZEND_ASSERT(GC_REFCOUNT(res) == 0); |
58 | 6.20k | zend_hash_index_del(&EG(regular_list), res->handle); |
59 | 6.20k | } |
60 | | |
61 | | static void zend_resource_dtor(zend_resource *res) |
62 | 6.47k | { |
63 | 6.47k | zend_rsrc_list_dtors_entry *ld; |
64 | 6.47k | zend_resource r = *res; |
65 | | |
66 | 6.47k | res->type = -1; |
67 | 6.47k | res->ptr = NULL; |
68 | | |
69 | 6.47k | ld = zend_hash_index_find_ptr(&list_destructors, r.type); |
70 | 6.47k | ZEND_ASSERT(ld && "Unknown list entry type"); |
71 | | |
72 | 6.47k | if (ld->list_dtor_ex) { |
73 | 6.44k | ld->list_dtor_ex(&r); |
74 | 6.44k | } |
75 | 6.47k | } |
76 | | |
77 | | |
78 | | ZEND_API void ZEND_FASTCALL zend_list_close(zend_resource *res) |
79 | 138 | { |
80 | 138 | if (GC_REFCOUNT(res) <= 0) { |
81 | 0 | zend_list_free(res); |
82 | 138 | } else if (res->type >= 0) { |
83 | 138 | zend_resource_dtor(res); |
84 | 138 | } |
85 | 138 | } |
86 | | |
87 | | ZEND_API zend_resource* zend_register_resource(void *rsrc_pointer, int rsrc_type) |
88 | 6.47k | { |
89 | 6.47k | zval *zv; |
90 | | |
91 | 6.47k | zv = zend_list_insert(rsrc_pointer, rsrc_type); |
92 | | |
93 | 6.47k | return Z_RES_P(zv); |
94 | 6.47k | } |
95 | | |
96 | | ZEND_API void *zend_fetch_resource2(zend_resource *res, const char *resource_type_name, int resource_type1, int resource_type2) |
97 | 6.11k | { |
98 | 6.11k | if (res) { |
99 | 6.11k | if (resource_type1 == res->type) { |
100 | 6.11k | return res->ptr; |
101 | 6.11k | } |
102 | | |
103 | 0 | if (resource_type2 == res->type) { |
104 | 0 | return res->ptr; |
105 | 0 | } |
106 | 0 | } |
107 | | |
108 | 0 | if (resource_type_name) { |
109 | 0 | const char *space; |
110 | 0 | const char *class_name = get_active_class_name(&space); |
111 | 0 | zend_type_error("%s%s%s(): supplied resource is not a valid %s resource", class_name, space, get_active_function_name(), resource_type_name); |
112 | 0 | } |
113 | |
|
114 | 0 | return NULL; |
115 | 6.11k | } |
116 | | |
117 | | ZEND_API void *zend_fetch_resource(zend_resource *res, const char *resource_type_name, int resource_type) |
118 | 21 | { |
119 | 21 | if (resource_type == res->type) { |
120 | 21 | return res->ptr; |
121 | 21 | } |
122 | | |
123 | 0 | if (resource_type_name) { |
124 | 0 | const char *space; |
125 | 0 | const char *class_name = get_active_class_name(&space); |
126 | 0 | zend_type_error("%s%s%s(): supplied resource is not a valid %s resource", class_name, space, get_active_function_name(), resource_type_name); |
127 | 0 | } |
128 | |
|
129 | 0 | return NULL; |
130 | 21 | } |
131 | | |
132 | | ZEND_API void *zend_fetch_resource_ex(zval *res, const char *resource_type_name, int resource_type) |
133 | 5 | { |
134 | 5 | const char *space, *class_name; |
135 | 5 | if (res == NULL) { |
136 | 0 | if (resource_type_name) { |
137 | 0 | class_name = get_active_class_name(&space); |
138 | 0 | zend_type_error("%s%s%s(): no %s resource supplied", class_name, space, get_active_function_name(), resource_type_name); |
139 | 0 | } |
140 | 0 | return NULL; |
141 | 0 | } |
142 | 5 | if (Z_TYPE_P(res) != IS_RESOURCE) { |
143 | 0 | if (resource_type_name) { |
144 | 0 | class_name = get_active_class_name(&space); |
145 | 0 | zend_type_error("%s%s%s(): supplied argument is not a valid %s resource", class_name, space, get_active_function_name(), resource_type_name); |
146 | 0 | } |
147 | 0 | return NULL; |
148 | 0 | } |
149 | | |
150 | 5 | return zend_fetch_resource(Z_RES_P(res), resource_type_name, resource_type); |
151 | 5 | } |
152 | | |
153 | | ZEND_API void *zend_fetch_resource2_ex(zval *res, const char *resource_type_name, int resource_type1, int resource_type2) |
154 | 0 | { |
155 | 0 | const char *space, *class_name; |
156 | 0 | if (res == NULL) { |
157 | 0 | if (resource_type_name) { |
158 | 0 | class_name = get_active_class_name(&space); |
159 | 0 | zend_type_error("%s%s%s(): no %s resource supplied", class_name, space, get_active_function_name(), resource_type_name); |
160 | 0 | } |
161 | 0 | return NULL; |
162 | 0 | } |
163 | 0 | if (Z_TYPE_P(res) != IS_RESOURCE) { |
164 | 0 | if (resource_type_name) { |
165 | 0 | class_name = get_active_class_name(&space); |
166 | 0 | zend_type_error("%s%s%s(): supplied argument is not a valid %s resource", class_name, space, get_active_function_name(), resource_type_name); |
167 | 0 | } |
168 | 0 | return NULL; |
169 | 0 | } |
170 | | |
171 | 0 | return zend_fetch_resource2(Z_RES_P(res), resource_type_name, resource_type1, resource_type2); |
172 | 0 | } |
173 | | |
174 | | void list_entry_destructor(zval *zv) |
175 | 6.47k | { |
176 | 6.47k | zend_resource *res = Z_RES_P(zv); |
177 | | |
178 | 6.47k | ZVAL_UNDEF(zv); |
179 | 6.47k | if (res->type >= 0) { |
180 | 6.21k | zend_resource_dtor(res); |
181 | 6.21k | } |
182 | 6.47k | efree_size(res, sizeof(zend_resource)); |
183 | 6.47k | } |
184 | | |
185 | | void plist_entry_destructor(zval *zv) |
186 | 0 | { |
187 | 0 | zend_resource *res = Z_RES_P(zv); |
188 | |
|
189 | 0 | if (res->type >= 0) { |
190 | 0 | zend_rsrc_list_dtors_entry *ld; |
191 | |
|
192 | 0 | ld = zend_hash_index_find_ptr(&list_destructors, res->type); |
193 | 0 | ZEND_ASSERT(ld && "Unknown list entry type"); |
194 | | |
195 | 0 | if (ld->plist_dtor_ex) { |
196 | 0 | ld->plist_dtor_ex(res); |
197 | 0 | } |
198 | 0 | } |
199 | 0 | free(res); |
200 | 0 | } |
201 | | |
202 | | ZEND_API void zend_init_rsrc_list(void) |
203 | 300k | { |
204 | 300k | zend_hash_init(&EG(regular_list), 8, NULL, list_entry_destructor, 0); |
205 | 300k | EG(regular_list).nNextFreeElement = 0; |
206 | 300k | } |
207 | | |
208 | | |
209 | | void zend_init_rsrc_plist(void) |
210 | 16 | { |
211 | 16 | zend_hash_init(&EG(persistent_list), 8, NULL, plist_entry_destructor, 1); |
212 | 16 | } |
213 | | |
214 | | |
215 | | void zend_close_rsrc_list(HashTable *ht) |
216 | 300k | { |
217 | | /* Reload ht->arData on each iteration, as it may be reallocated. */ |
218 | 300k | uint32_t i = ht->nNumUsed; |
219 | | |
220 | 300k | while (i-- > 0) { |
221 | 236 | zval *p = ZEND_HASH_ELEMENT(ht, i); |
222 | 236 | if (Z_TYPE_P(p) != IS_UNDEF) { |
223 | 122 | zend_resource *res = Z_PTR_P(p); |
224 | 122 | if (res->type >= 0) { |
225 | 122 | zend_resource_dtor(res); |
226 | 122 | } |
227 | 122 | } |
228 | 236 | } |
229 | 300k | } |
230 | | |
231 | | |
232 | | void zend_destroy_rsrc_list(HashTable *ht) |
233 | 300k | { |
234 | 300k | zend_hash_graceful_reverse_destroy(ht); |
235 | 300k | } |
236 | | |
237 | | /* int return due to HashTable API */ |
238 | | static int clean_module_resource(zval *zv, void *arg) |
239 | 0 | { |
240 | 0 | int resource_id = *(int *)arg; |
241 | |
|
242 | 0 | return Z_RES_TYPE_P(zv) == resource_id; |
243 | 0 | } |
244 | | |
245 | | /* int return due to HashTable API */ |
246 | | static int zend_clean_module_rsrc_dtors_cb(zval *zv, void *arg) |
247 | 0 | { |
248 | 0 | zend_rsrc_list_dtors_entry *ld = (zend_rsrc_list_dtors_entry *)Z_PTR_P(zv); |
249 | 0 | int module_number = *(int *)arg; |
250 | 0 | if (ld->module_number == module_number) { |
251 | 0 | zend_hash_apply_with_argument(&EG(persistent_list), clean_module_resource, (void *) &(ld->resource_id)); |
252 | 0 | return 1; |
253 | 0 | } else { |
254 | 0 | return 0; |
255 | 0 | } |
256 | 0 | } |
257 | | |
258 | | |
259 | | void zend_clean_module_rsrc_dtors(int module_number) |
260 | 0 | { |
261 | 0 | zend_hash_apply_with_argument(&list_destructors, zend_clean_module_rsrc_dtors_cb, (void *) &module_number); |
262 | 0 | } |
263 | | |
264 | | |
265 | | ZEND_API int zend_register_list_destructors_ex(rsrc_dtor_func_t ld, rsrc_dtor_func_t pld, const char *type_name, int module_number) |
266 | 144 | { |
267 | 144 | zend_rsrc_list_dtors_entry *lde; |
268 | 144 | zval zv; |
269 | | |
270 | 144 | lde = malloc(sizeof(zend_rsrc_list_dtors_entry)); |
271 | 144 | lde->list_dtor_ex = ld; |
272 | 144 | lde->plist_dtor_ex = pld; |
273 | 144 | lde->module_number = module_number; |
274 | 144 | lde->resource_id = list_destructors.nNextFreeElement; |
275 | 144 | lde->type_name = type_name; |
276 | 144 | ZVAL_PTR(&zv, lde); |
277 | | |
278 | 144 | if (zend_hash_next_index_insert(&list_destructors, &zv) == NULL) { |
279 | 0 | free(lde); |
280 | 0 | return FAILURE; |
281 | 0 | } |
282 | 144 | return list_destructors.nNextFreeElement-1; |
283 | 144 | } |
284 | | |
285 | | ZEND_API int zend_fetch_list_dtor_id(const char *type_name) |
286 | 0 | { |
287 | 0 | zend_rsrc_list_dtors_entry *lde; |
288 | |
|
289 | 0 | ZEND_HASH_PACKED_FOREACH_PTR(&list_destructors, lde) { |
290 | 0 | if (lde->type_name && (strcmp(type_name, lde->type_name) == 0)) { |
291 | 0 | return lde->resource_id; |
292 | 0 | } |
293 | 0 | } ZEND_HASH_FOREACH_END(); |
294 | | |
295 | 0 | return 0; |
296 | 0 | } |
297 | | |
298 | | static void list_destructors_dtor(zval *zv) |
299 | 0 | { |
300 | 0 | free(Z_PTR_P(zv)); |
301 | 0 | } |
302 | | |
303 | | void zend_init_rsrc_list_dtors(void) |
304 | 16 | { |
305 | 16 | zend_hash_init(&list_destructors, 64, NULL, list_destructors_dtor, 1); |
306 | 16 | list_destructors.nNextFreeElement=1; /* we don't want resource type 0 */ |
307 | 16 | } |
308 | | |
309 | | |
310 | | void zend_destroy_rsrc_list_dtors(void) |
311 | 0 | { |
312 | 0 | zend_hash_destroy(&list_destructors); |
313 | 0 | } |
314 | | |
315 | | |
316 | | const char *zend_rsrc_list_get_rsrc_type(zend_resource *res) |
317 | 0 | { |
318 | 0 | zend_rsrc_list_dtors_entry *lde; |
319 | |
|
320 | 0 | lde = zend_hash_index_find_ptr(&list_destructors, res->type); |
321 | 0 | if (lde) { |
322 | 0 | return lde->type_name; |
323 | 0 | } else { |
324 | 0 | return NULL; |
325 | 0 | } |
326 | 0 | } |
327 | | |
328 | | ZEND_API zend_resource* zend_register_persistent_resource_ex(zend_string *key, void *rsrc_pointer, int rsrc_type) |
329 | 0 | { |
330 | 0 | zval *zv; |
331 | 0 | zval tmp; |
332 | |
|
333 | 0 | ZVAL_NEW_PERSISTENT_RES(&tmp, -1, rsrc_pointer, rsrc_type); |
334 | 0 | GC_MAKE_PERSISTENT_LOCAL(Z_COUNTED(tmp)); |
335 | 0 | GC_MAKE_PERSISTENT_LOCAL(key); |
336 | |
|
337 | 0 | zv = zend_hash_update(&EG(persistent_list), key, &tmp); |
338 | |
|
339 | 0 | return Z_RES_P(zv); |
340 | 0 | } |
341 | | |
342 | | ZEND_API zend_resource* zend_register_persistent_resource(const char *key, size_t key_len, void *rsrc_pointer, int rsrc_type) |
343 | 0 | { |
344 | 0 | zend_string *str = zend_string_init(key, key_len, 1); |
345 | 0 | zend_resource *ret = zend_register_persistent_resource_ex(str, rsrc_pointer, rsrc_type); |
346 | |
|
347 | 0 | zend_string_release_ex(str, 1); |
348 | 0 | return ret; |
349 | 0 | } |