This source file includes following definitions.
- zend_list_insert
- zend_list_delete
- zend_list_free
- zend_resource_dtor
- zend_list_close
- zend_register_resource
- zend_fetch_resource2
- zend_fetch_resource
- zend_fetch_resource_ex
- zend_fetch_resource2_ex
- list_entry_destructor
- plist_entry_destructor
- zend_init_rsrc_list
- zend_init_rsrc_plist
- zend_close_rsrc
- zend_close_rsrc_list
- zend_destroy_rsrc_list
- clean_module_resource
- zend_clean_module_rsrc_dtors_cb
- zend_clean_module_rsrc_dtors
- zend_register_list_destructors_ex
- zend_fetch_list_dtor_id
- list_destructors_dtor
- zend_init_rsrc_list_dtors
- zend_destroy_rsrc_list_dtors
- zend_rsrc_list_get_rsrc_type
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 #include "zend.h"
25 #include "zend_list.h"
26 #include "zend_API.h"
27 #include "zend_globals.h"
28
29 ZEND_API int le_index_ptr;
30
31
32 static HashTable list_destructors;
33
34 ZEND_API zval *zend_list_insert(void *ptr, int type)
35 {
36 int index;
37 zval zv;
38
39 index = zend_hash_next_free_element(&EG(regular_list));
40 if (index == 0) {
41 index = 1;
42 }
43 ZVAL_NEW_RES(&zv, index, ptr, type);
44 return zend_hash_index_add_new(&EG(regular_list), index, &zv);
45 }
46
47 ZEND_API int zend_list_delete(zend_resource *res)
48 {
49 if (--GC_REFCOUNT(res) <= 0) {
50 return zend_hash_index_del(&EG(regular_list), res->handle);
51 } else {
52 return SUCCESS;
53 }
54 }
55
56 ZEND_API int 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
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
84 ZEND_API int 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
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
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
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
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
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
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
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
211 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
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
225 static int zend_close_rsrc(zval *zv)
226 {
227 zend_resource *res = Z_PTR_P(zv);
228
229 if (res->type >= 0) {
230 zend_resource_dtor(res);
231 }
232 return ZEND_HASH_APPLY_KEEP;
233 }
234
235
236 void zend_close_rsrc_list(HashTable *ht)
237 {
238 zend_hash_reverse_apply(ht, zend_close_rsrc);
239 }
240
241
242 void zend_destroy_rsrc_list(HashTable *ht)
243 {
244 zend_hash_graceful_reverse_destroy(ht);
245 }
246
247 static int clean_module_resource(zval *zv, void *arg)
248 {
249 int resource_id = *(int *)arg;
250 if (Z_RES_TYPE_P(zv) == resource_id) {
251 return 1;
252 } else {
253 return 0;
254 }
255 }
256
257
258 static int zend_clean_module_rsrc_dtors_cb(zval *zv, void *arg)
259 {
260 zend_rsrc_list_dtors_entry *ld = (zend_rsrc_list_dtors_entry *)Z_PTR_P(zv);
261 int module_number = *(int *)arg;
262 if (ld->module_number == module_number) {
263 zend_hash_apply_with_argument(&EG(persistent_list), clean_module_resource, (void *) &(ld->resource_id));
264 return 1;
265 } else {
266 return 0;
267 }
268 }
269
270
271 void zend_clean_module_rsrc_dtors(int module_number)
272 {
273 zend_hash_apply_with_argument(&list_destructors, zend_clean_module_rsrc_dtors_cb, (void *) &module_number);
274 }
275
276
277 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)
278 {
279 zend_rsrc_list_dtors_entry *lde;
280 zval zv;
281
282 lde = malloc(sizeof(zend_rsrc_list_dtors_entry));
283 lde->list_dtor_ex = ld;
284 lde->plist_dtor_ex = pld;
285 lde->module_number = module_number;
286 lde->resource_id = list_destructors.nNextFreeElement;
287 lde->type_name = type_name;
288 ZVAL_PTR(&zv, lde);
289
290 if (zend_hash_next_index_insert(&list_destructors, &zv) == NULL) {
291 return FAILURE;
292 }
293 return list_destructors.nNextFreeElement-1;
294 }
295
296 ZEND_API int zend_fetch_list_dtor_id(const char *type_name)
297 {
298 zend_rsrc_list_dtors_entry *lde;
299
300 ZEND_HASH_FOREACH_PTR(&list_destructors, lde) {
301 if (lde->type_name && (strcmp(type_name, lde->type_name) == 0)) {
302 return lde->resource_id;
303 }
304 } ZEND_HASH_FOREACH_END();
305
306 return 0;
307 }
308
309 static void list_destructors_dtor(zval *zv)
310 {
311 free(Z_PTR_P(zv));
312 }
313
314 int zend_init_rsrc_list_dtors(void)
315 {
316 zend_hash_init(&list_destructors, 64, NULL, list_destructors_dtor, 1);
317 list_destructors.nNextFreeElement=1;
318 return SUCCESS;
319 }
320
321
322 void zend_destroy_rsrc_list_dtors(void)
323 {
324 zend_hash_destroy(&list_destructors);
325 }
326
327
328 const char *zend_rsrc_list_get_rsrc_type(zend_resource *res)
329 {
330 zend_rsrc_list_dtors_entry *lde;
331
332 lde = zend_hash_index_find_ptr(&list_destructors, res->type);
333 if (lde) {
334 return lde->type_name;
335 } else {
336 return NULL;
337 }
338 }
339
340
341
342
343
344
345
346