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
zend_list_insert(void * ptr,int type)32 ZEND_API zval* ZEND_FASTCALL zend_list_insert(void *ptr, int type)
33 {
34 int index;
35 zval zv;
36
37 index = zend_hash_next_free_element(&EG(regular_list));
38 if (index == 0) {
39 index = 1;
40 } else if (index == INT_MAX) {
41 zend_error_noreturn(E_ERROR, "Resource ID space overflow");
42 }
43 ZVAL_NEW_RES(&zv, index, ptr, type);
44 return zend_hash_index_add_new(&EG(regular_list), index, &zv);
45 }
46
zend_list_delete(zend_resource * res)47 ZEND_API int ZEND_FASTCALL zend_list_delete(zend_resource *res)
48 {
49 if (GC_DELREF(res) <= 0) {
50 return zend_hash_index_del(&EG(regular_list), res->handle);
51 } else {
52 return SUCCESS;
53 }
54 }
55
zend_list_free(zend_resource * res)56 ZEND_API int ZEND_FASTCALL zend_list_free(zend_resource *res)
57 {
58 if (GC_REFCOUNT(res) <= 0) {
59 return zend_hash_index_del(&EG(regular_list), res->handle);
60 } else {
61 return SUCCESS;
62 }
63 }
64
zend_resource_dtor(zend_resource * res)65 static void zend_resource_dtor(zend_resource *res)
66 {
67 zend_rsrc_list_dtors_entry *ld;
68 zend_resource r = *res;
69
70 res->type = -1;
71 res->ptr = NULL;
72
73 ld = zend_hash_index_find_ptr(&list_destructors, r.type);
74 if (ld) {
75 if (ld->list_dtor_ex) {
76 ld->list_dtor_ex(&r);
77 }
78 } else {
79 zend_error(E_WARNING, "Unknown list entry type (%d)", r.type);
80 }
81 }
82
83
zend_list_close(zend_resource * res)84 ZEND_API int ZEND_FASTCALL zend_list_close(zend_resource *res)
85 {
86 if (GC_REFCOUNT(res) <= 0) {
87 return zend_list_free(res);
88 } else if (res->type >= 0) {
89 zend_resource_dtor(res);
90 }
91 return SUCCESS;
92 }
93
zend_register_resource(void * rsrc_pointer,int rsrc_type)94 ZEND_API zend_resource* zend_register_resource(void *rsrc_pointer, int rsrc_type)
95 {
96 zval *zv;
97
98 zv = zend_list_insert(rsrc_pointer, rsrc_type);
99
100 return Z_RES_P(zv);
101 }
102
zend_fetch_resource2(zend_resource * res,const char * resource_type_name,int resource_type1,int resource_type2)103 ZEND_API void *zend_fetch_resource2(zend_resource *res, const char *resource_type_name, int resource_type1, int resource_type2)
104 {
105 if (res) {
106 if (resource_type1 == res->type) {
107 return res->ptr;
108 }
109
110 if (resource_type2 == res->type) {
111 return res->ptr;
112 }
113 }
114
115 if (resource_type_name) {
116 const char *space;
117 const char *class_name = get_active_class_name(&space);
118 zend_error(E_WARNING, "%s%s%s(): supplied resource is not a valid %s resource", class_name, space, get_active_function_name(), resource_type_name);
119 }
120
121 return NULL;
122 }
123
zend_fetch_resource(zend_resource * res,const char * resource_type_name,int resource_type)124 ZEND_API void *zend_fetch_resource(zend_resource *res, const char *resource_type_name, int resource_type)
125 {
126 if (resource_type == res->type) {
127 return res->ptr;
128 }
129
130 if (resource_type_name) {
131 const char *space;
132 const char *class_name = get_active_class_name(&space);
133 zend_error(E_WARNING, "%s%s%s(): supplied resource is not a valid %s resource", class_name, space, get_active_function_name(), resource_type_name);
134 }
135
136 return NULL;
137 }
138
zend_fetch_resource_ex(zval * res,const char * resource_type_name,int resource_type)139 ZEND_API void *zend_fetch_resource_ex(zval *res, const char *resource_type_name, int resource_type)
140 {
141 const char *space, *class_name;
142 if (res == NULL) {
143 if (resource_type_name) {
144 class_name = get_active_class_name(&space);
145 zend_error(E_WARNING, "%s%s%s(): no %s resource supplied", class_name, space, get_active_function_name(), resource_type_name);
146 }
147 return NULL;
148 }
149 if (Z_TYPE_P(res) != IS_RESOURCE) {
150 if (resource_type_name) {
151 class_name = get_active_class_name(&space);
152 zend_error(E_WARNING, "%s%s%s(): supplied argument is not a valid %s resource", class_name, space, get_active_function_name(), resource_type_name);
153 }
154 return NULL;
155 }
156
157 return zend_fetch_resource(Z_RES_P(res), resource_type_name, resource_type);
158 }
159
zend_fetch_resource2_ex(zval * res,const char * resource_type_name,int resource_type1,int resource_type2)160 ZEND_API void *zend_fetch_resource2_ex(zval *res, const char *resource_type_name, int resource_type1, int resource_type2)
161 {
162 const char *space, *class_name;
163 if (res == NULL) {
164 if (resource_type_name) {
165 class_name = get_active_class_name(&space);
166 zend_error(E_WARNING, "%s%s%s(): no %s resource supplied", class_name, space, get_active_function_name(), resource_type_name);
167 }
168 return NULL;
169 }
170 if (Z_TYPE_P(res) != IS_RESOURCE) {
171 if (resource_type_name) {
172 class_name = get_active_class_name(&space);
173 zend_error(E_WARNING, "%s%s%s(): supplied argument is not a valid %s resource", class_name, space, get_active_function_name(), resource_type_name);
174 }
175 return NULL;
176 }
177
178 return zend_fetch_resource2(Z_RES_P(res), resource_type_name, resource_type1, resource_type2);
179 }
180
list_entry_destructor(zval * zv)181 void list_entry_destructor(zval *zv)
182 {
183 zend_resource *res = Z_RES_P(zv);
184
185 ZVAL_UNDEF(zv);
186 if (res->type >= 0) {
187 zend_resource_dtor(res);
188 }
189 efree_size(res, sizeof(zend_resource));
190 }
191
plist_entry_destructor(zval * zv)192 void plist_entry_destructor(zval *zv)
193 {
194 zend_resource *res = Z_RES_P(zv);
195
196 if (res->type >= 0) {
197 zend_rsrc_list_dtors_entry *ld;
198
199 ld = zend_hash_index_find_ptr(&list_destructors, res->type);
200 if (ld) {
201 if (ld->plist_dtor_ex) {
202 ld->plist_dtor_ex(res);
203 }
204 } else {
205 zend_error(E_WARNING,"Unknown list entry type (%d)", res->type);
206 }
207 }
208 free(res);
209 }
210
zend_init_rsrc_list(void)211 ZEND_API int zend_init_rsrc_list(void)
212 {
213 zend_hash_init(&EG(regular_list), 8, NULL, list_entry_destructor, 0);
214 return SUCCESS;
215 }
216
217
zend_init_rsrc_plist(void)218 int zend_init_rsrc_plist(void)
219 {
220 zend_hash_init_ex(&EG(persistent_list), 8, NULL, plist_entry_destructor, 1, 0);
221 return SUCCESS;
222 }
223
224
zend_close_rsrc_list(HashTable * ht)225 void zend_close_rsrc_list(HashTable *ht)
226 {
227 zend_resource *res;
228
229 ZEND_HASH_REVERSE_FOREACH_PTR(ht, res) {
230 if (res->type >= 0) {
231 zend_resource_dtor(res);
232 }
233 } ZEND_HASH_FOREACH_END();
234 }
235
236
zend_destroy_rsrc_list(HashTable * ht)237 void zend_destroy_rsrc_list(HashTable *ht)
238 {
239 zend_hash_graceful_reverse_destroy(ht);
240 }
241
clean_module_resource(zval * zv,void * arg)242 static int clean_module_resource(zval *zv, void *arg)
243 {
244 int resource_id = *(int *)arg;
245
246 return Z_RES_TYPE_P(zv) == resource_id;
247 }
248
249
zend_clean_module_rsrc_dtors_cb(zval * zv,void * arg)250 static int zend_clean_module_rsrc_dtors_cb(zval *zv, void *arg)
251 {
252 zend_rsrc_list_dtors_entry *ld = (zend_rsrc_list_dtors_entry *)Z_PTR_P(zv);
253 int module_number = *(int *)arg;
254 if (ld->module_number == module_number) {
255 zend_hash_apply_with_argument(&EG(persistent_list), clean_module_resource, (void *) &(ld->resource_id));
256 return 1;
257 } else {
258 return 0;
259 }
260 }
261
262
zend_clean_module_rsrc_dtors(int module_number)263 void zend_clean_module_rsrc_dtors(int module_number)
264 {
265 zend_hash_apply_with_argument(&list_destructors, zend_clean_module_rsrc_dtors_cb, (void *) &module_number);
266 }
267
268
zend_register_list_destructors_ex(rsrc_dtor_func_t ld,rsrc_dtor_func_t pld,const char * type_name,int module_number)269 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)
270 {
271 zend_rsrc_list_dtors_entry *lde;
272 zval zv;
273
274 lde = malloc(sizeof(zend_rsrc_list_dtors_entry));
275 lde->list_dtor_ex = ld;
276 lde->plist_dtor_ex = pld;
277 lde->module_number = module_number;
278 lde->resource_id = list_destructors.nNextFreeElement;
279 lde->type_name = type_name;
280 ZVAL_PTR(&zv, lde);
281
282 if (zend_hash_next_index_insert(&list_destructors, &zv) == NULL) {
283 return FAILURE;
284 }
285 return list_destructors.nNextFreeElement-1;
286 }
287
zend_fetch_list_dtor_id(const char * type_name)288 ZEND_API int zend_fetch_list_dtor_id(const char *type_name)
289 {
290 zend_rsrc_list_dtors_entry *lde;
291
292 ZEND_HASH_FOREACH_PTR(&list_destructors, lde) {
293 if (lde->type_name && (strcmp(type_name, lde->type_name) == 0)) {
294 return lde->resource_id;
295 }
296 } ZEND_HASH_FOREACH_END();
297
298 return 0;
299 }
300
list_destructors_dtor(zval * zv)301 static void list_destructors_dtor(zval *zv)
302 {
303 free(Z_PTR_P(zv));
304 }
305
zend_init_rsrc_list_dtors(void)306 int zend_init_rsrc_list_dtors(void)
307 {
308 zend_hash_init(&list_destructors, 64, NULL, list_destructors_dtor, 1);
309 list_destructors.nNextFreeElement=1; /* we don't want resource type 0 */
310 return SUCCESS;
311 }
312
313
zend_destroy_rsrc_list_dtors(void)314 void zend_destroy_rsrc_list_dtors(void)
315 {
316 zend_hash_destroy(&list_destructors);
317 }
318
319
zend_rsrc_list_get_rsrc_type(zend_resource * res)320 const char *zend_rsrc_list_get_rsrc_type(zend_resource *res)
321 {
322 zend_rsrc_list_dtors_entry *lde;
323
324 lde = zend_hash_index_find_ptr(&list_destructors, res->type);
325 if (lde) {
326 return lde->type_name;
327 } else {
328 return NULL;
329 }
330 }
331
zend_register_persistent_resource_ex(zend_string * key,void * rsrc_pointer,int rsrc_type)332 ZEND_API zend_resource* zend_register_persistent_resource_ex(zend_string *key, void *rsrc_pointer, int rsrc_type)
333 {
334 zval *zv;
335 zval tmp;
336
337 ZVAL_NEW_PERSISTENT_RES(&tmp, -1, rsrc_pointer, rsrc_type);
338 GC_MAKE_PERSISTENT_LOCAL(Z_COUNTED(tmp));
339 GC_MAKE_PERSISTENT_LOCAL(key);
340
341 zv = zend_hash_update(&EG(persistent_list), key, &tmp);
342
343 return Z_RES_P(zv);
344 }
345
zend_register_persistent_resource(const char * key,size_t key_len,void * rsrc_pointer,int rsrc_type)346 ZEND_API zend_resource* zend_register_persistent_resource(const char *key, size_t key_len, void *rsrc_pointer, int rsrc_type)
347 {
348 zend_string *str = zend_string_init(key, key_len, 1);
349 zend_resource *ret = zend_register_persistent_resource_ex(str, rsrc_pointer, rsrc_type);
350
351 zend_string_release_ex(str, 1);
352 return ret;
353 }
354