Coverage Report

Created: 2025-06-13 06:43

/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
}