1 /*
2 +----------------------------------------------------------------------+
3 | Copyright (c) The PHP Group |
4 +----------------------------------------------------------------------+
5 | This source file is subject to version 3.01 of the PHP license, |
6 | that is bundled with this package in the file LICENSE, and is |
7 | available through the world-wide-web at the following url: |
8 | https://www.php.net/license/3_01.txt |
9 | If you did not receive a copy of the PHP license and are unable to |
10 | obtain it through the world-wide-web, please send a note to |
11 | license@php.net so we can mail you a copy immediately. |
12 +----------------------------------------------------------------------+
13 | Author: Christian Cartus <cartus@atrior.de> |
14 +----------------------------------------------------------------------+
15 */
16
17 #ifdef HAVE_CONFIG_H
18 #include <config.h>
19 #endif
20
21 #include "php.h"
22
23 #ifdef HAVE_SYSVSHM
24
25 #include <errno.h>
26
27 #include "php_sysvshm.h"
28 #include "sysvshm_arginfo.h"
29 #include "ext/standard/info.h"
30 #include "ext/standard/php_var.h"
31 #include "zend_smart_str.h"
32
33 /* SysvSharedMemory class */
34
35 zend_class_entry *sysvshm_ce;
36 static zend_object_handlers sysvshm_object_handlers;
37
sysvshm_from_obj(zend_object * obj)38 static inline sysvshm_shm *sysvshm_from_obj(zend_object *obj) {
39 return (sysvshm_shm *)((char *)(obj) - XtOffsetOf(sysvshm_shm, std));
40 }
41
42 #define Z_SYSVSHM_P(zv) sysvshm_from_obj(Z_OBJ_P(zv))
43
sysvshm_create_object(zend_class_entry * class_type)44 static zend_object *sysvshm_create_object(zend_class_entry *class_type) {
45 sysvshm_shm *intern = zend_object_alloc(sizeof(sysvshm_shm), class_type);
46
47 zend_object_std_init(&intern->std, class_type);
48 object_properties_init(&intern->std, class_type);
49
50 return &intern->std;
51 }
52
sysvshm_get_constructor(zend_object * object)53 static zend_function *sysvshm_get_constructor(zend_object *object) {
54 zend_throw_error(NULL, "Cannot directly construct SysvSharedMemory, use shm_attach() instead");
55 return NULL;
56 }
57
sysvshm_free_obj(zend_object * object)58 static void sysvshm_free_obj(zend_object *object)
59 {
60 sysvshm_shm *sysvshm = sysvshm_from_obj(object);
61
62 if (sysvshm->ptr) {
63 shmdt((void *) sysvshm->ptr);
64 }
65
66 zend_object_std_dtor(&sysvshm->std);
67 }
68
69 /* {{{ sysvshm_module_entry */
70 zend_module_entry sysvshm_module_entry = {
71 STANDARD_MODULE_HEADER,
72 "sysvshm",
73 ext_functions,
74 PHP_MINIT(sysvshm),
75 NULL,
76 NULL,
77 NULL,
78 PHP_MINFO(sysvshm),
79 PHP_SYSVSHM_VERSION,
80 STANDARD_MODULE_PROPERTIES
81 };
82 /* }}} */
83
84 #ifdef COMPILE_DL_SYSVSHM
85 ZEND_GET_MODULE(sysvshm)
86 #endif
87
88 #undef shm_ptr /* undefine AIX-specific macro */
89
90 /* TODO: Make this thread-safe. */
91 sysvshm_module php_sysvshm;
92
93 static int php_put_shm_data(sysvshm_chunk_head *ptr, zend_long key, const char *data, zend_long len);
94 static zend_long php_check_shm_data(sysvshm_chunk_head *ptr, zend_long key);
95 static int php_remove_shm_data(sysvshm_chunk_head *ptr, zend_long shm_varpos);
96
97 /* {{{ PHP_MINIT_FUNCTION */
PHP_MINIT_FUNCTION(sysvshm)98 PHP_MINIT_FUNCTION(sysvshm)
99 {
100 sysvshm_ce = register_class_SysvSharedMemory();
101 sysvshm_ce->create_object = sysvshm_create_object;
102 sysvshm_ce->default_object_handlers = &sysvshm_object_handlers;
103
104 memcpy(&sysvshm_object_handlers, &std_object_handlers, sizeof(zend_object_handlers));
105 sysvshm_object_handlers.offset = XtOffsetOf(sysvshm_shm, std);
106 sysvshm_object_handlers.free_obj = sysvshm_free_obj;
107 sysvshm_object_handlers.get_constructor = sysvshm_get_constructor;
108 sysvshm_object_handlers.clone_obj = NULL;
109 sysvshm_object_handlers.compare = zend_objects_not_comparable;
110
111 if (cfg_get_long("sysvshm.init_mem", &php_sysvshm.init_mem) == FAILURE) {
112 php_sysvshm.init_mem=10000;
113 }
114 return SUCCESS;
115 }
116 /* }}} */
117
118 /* {{{ PHP_MINFO_FUNCTION */
PHP_MINFO_FUNCTION(sysvshm)119 PHP_MINFO_FUNCTION(sysvshm)
120 {
121 php_info_print_table_start();
122 php_info_print_table_row(2, "sysvshm support", "enabled");
123 php_info_print_table_end();
124 }
125 /* }}} */
126
127 /* {{{ Creates or open a shared memory segment */
PHP_FUNCTION(shm_attach)128 PHP_FUNCTION(shm_attach)
129 {
130 sysvshm_shm *shm_list_ptr;
131 char *shm_ptr;
132 sysvshm_chunk_head *chunk_ptr;
133 zend_long shm_key, shm_id, shm_size, shm_flag = 0666;
134 bool shm_size_is_null = 1;
135
136 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "l|l!l", &shm_key, &shm_size, &shm_size_is_null, &shm_flag)) {
137 RETURN_THROWS();
138 }
139
140 if (shm_size_is_null) {
141 shm_size = php_sysvshm.init_mem;
142 }
143
144 if (shm_size < 1) {
145 zend_argument_value_error(2, "must be greater than 0");
146 RETURN_THROWS();
147 }
148
149 /* get the id from a specified key or create new shared memory */
150 if ((shm_id = shmget(shm_key, 0, 0)) < 0) {
151 if (shm_size < (zend_long)sizeof(sysvshm_chunk_head)) {
152 php_error_docref(NULL, E_WARNING, "Failed for key 0x" ZEND_XLONG_FMT ": memorysize too small", shm_key);
153 RETURN_FALSE;
154 }
155 if ((shm_id = shmget(shm_key, shm_size, shm_flag | IPC_CREAT | IPC_EXCL)) < 0) {
156 php_error_docref(NULL, E_WARNING, "Failed for key 0x" ZEND_XLONG_FMT ": %s", shm_key, strerror(errno));
157 RETURN_FALSE;
158 }
159 }
160
161 if ((shm_ptr = shmat(shm_id, NULL, 0)) == (void *) -1) {
162 php_error_docref(NULL, E_WARNING, "Failed for key 0x" ZEND_XLONG_FMT ": %s", shm_key, strerror(errno));
163 RETURN_FALSE;
164 }
165
166 /* check if shm is already initialized */
167 chunk_ptr = (sysvshm_chunk_head *) shm_ptr;
168 if (strcmp((char*) &(chunk_ptr->magic), "PHP_SM") != 0) {
169 strcpy((char*) &(chunk_ptr->magic), "PHP_SM");
170 chunk_ptr->start = sizeof(sysvshm_chunk_head);
171 chunk_ptr->end = chunk_ptr->start;
172 chunk_ptr->total = shm_size;
173 chunk_ptr->free = shm_size-chunk_ptr->end;
174 }
175
176 object_init_ex(return_value, sysvshm_ce);
177
178 shm_list_ptr = Z_SYSVSHM_P(return_value);
179
180 shm_list_ptr->key = shm_key;
181 shm_list_ptr->id = shm_id;
182 shm_list_ptr->ptr = chunk_ptr;
183 }
184 /* }}} */
185
186 /* {{{ Disconnects from shared memory segment */
PHP_FUNCTION(shm_detach)187 PHP_FUNCTION(shm_detach)
188 {
189 zval *shm_id;
190 sysvshm_shm *shm_list_ptr;
191
192 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "O", &shm_id, sysvshm_ce)) {
193 RETURN_THROWS();
194 }
195
196 shm_list_ptr = Z_SYSVSHM_P(shm_id);
197 if (!shm_list_ptr->ptr) {
198 zend_throw_error(NULL, "Shared memory block has already been destroyed");
199 RETURN_THROWS();
200 }
201
202 shmdt((void *) shm_list_ptr->ptr);
203 shm_list_ptr->ptr = NULL;
204
205 RETURN_TRUE;
206 }
207 /* }}} */
208
209 /* {{{ Removes shared memory from Unix systems */
PHP_FUNCTION(shm_remove)210 PHP_FUNCTION(shm_remove)
211 {
212 zval *shm_id;
213 sysvshm_shm *shm_list_ptr;
214
215 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "O", &shm_id, sysvshm_ce)) {
216 RETURN_THROWS();
217 }
218
219 shm_list_ptr = Z_SYSVSHM_P(shm_id);
220 if (!shm_list_ptr->ptr) {
221 zend_throw_error(NULL, "Shared memory block has already been destroyed");
222 RETURN_THROWS();
223 }
224
225 if (shmctl(shm_list_ptr->id, IPC_RMID, NULL) < 0) {
226 php_error_docref(NULL, E_WARNING, "Failed for key 0x%x, id " ZEND_LONG_FMT ": %s", shm_list_ptr->key, Z_LVAL_P(shm_id), strerror(errno));
227 RETURN_FALSE;
228 }
229
230 RETURN_TRUE;
231 }
232 /* }}} */
233
234 /* {{{ Inserts or updates a variable in shared memory */
PHP_FUNCTION(shm_put_var)235 PHP_FUNCTION(shm_put_var)
236 {
237 zval *shm_id, *arg_var;
238 int ret;
239 zend_long shm_key;
240 sysvshm_shm *shm_list_ptr;
241 smart_str shm_var = {0};
242 php_serialize_data_t var_hash;
243
244 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "Olz", &shm_id, sysvshm_ce, &shm_key, &arg_var)) {
245 RETURN_THROWS();
246 }
247
248 shm_list_ptr = Z_SYSVSHM_P(shm_id);
249 if (!shm_list_ptr->ptr) {
250 zend_throw_error(NULL, "Shared memory block has already been destroyed");
251 RETURN_THROWS();
252 }
253
254 /* setup string-variable and serialize */
255 PHP_VAR_SERIALIZE_INIT(var_hash);
256 php_var_serialize(&shm_var, arg_var, &var_hash);
257 PHP_VAR_SERIALIZE_DESTROY(var_hash);
258
259 /* insert serialized variable into shared memory */
260 ret = php_put_shm_data(shm_list_ptr->ptr, shm_key, shm_var.s? ZSTR_VAL(shm_var.s) : NULL, shm_var.s? ZSTR_LEN(shm_var.s) : 0);
261
262 /* free string */
263 smart_str_free(&shm_var);
264
265 if (ret == -1) {
266 php_error_docref(NULL, E_WARNING, "Not enough shared memory left");
267 RETURN_FALSE;
268 }
269 RETURN_TRUE;
270 }
271 /* }}} */
272
273 /* {{{ Returns a variable from shared memory */
PHP_FUNCTION(shm_get_var)274 PHP_FUNCTION(shm_get_var)
275 {
276 zval *shm_id;
277 zend_long shm_key;
278 sysvshm_shm *shm_list_ptr;
279 char *shm_data;
280 zend_long shm_varpos;
281 sysvshm_chunk *shm_var;
282 php_unserialize_data_t var_hash;
283
284 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "Ol", &shm_id, sysvshm_ce, &shm_key)) {
285 RETURN_THROWS();
286 }
287
288 shm_list_ptr = Z_SYSVSHM_P(shm_id);
289 if (!shm_list_ptr->ptr) {
290 zend_throw_error(NULL, "Shared memory block has already been destroyed");
291 RETURN_THROWS();
292 }
293
294 /* setup string-variable and serialize */
295 /* get serialized variable from shared memory */
296 shm_varpos = php_check_shm_data(shm_list_ptr->ptr, shm_key);
297
298 if (shm_varpos < 0) {
299 php_error_docref(NULL, E_WARNING, "Variable key " ZEND_LONG_FMT " doesn't exist", shm_key);
300 RETURN_FALSE;
301 }
302 shm_var = (sysvshm_chunk*) ((char *)shm_list_ptr->ptr + shm_varpos);
303 shm_data = &shm_var->mem;
304
305 PHP_VAR_UNSERIALIZE_INIT(var_hash);
306 if (php_var_unserialize(return_value, (const unsigned char **) &shm_data, (unsigned char *) shm_data + shm_var->length, &var_hash) != 1) {
307 php_error_docref(NULL, E_WARNING, "Variable data in shared memory is corrupted");
308 RETVAL_FALSE;
309 }
310 PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
311 }
312 /* }}} */
313
314 /* {{{ Checks whether a specific entry exists */
PHP_FUNCTION(shm_has_var)315 PHP_FUNCTION(shm_has_var)
316 {
317 zval *shm_id;
318 zend_long shm_key;
319 sysvshm_shm *shm_list_ptr;
320
321 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "Ol", &shm_id, sysvshm_ce, &shm_key)) {
322 RETURN_THROWS();
323 }
324
325 shm_list_ptr = Z_SYSVSHM_P(shm_id);
326 if (!shm_list_ptr->ptr) {
327 zend_throw_error(NULL, "Shared memory block has already been destroyed");
328 RETURN_THROWS();
329 }
330
331 RETURN_BOOL(php_check_shm_data(shm_list_ptr->ptr, shm_key) >= 0);
332 }
333 /* }}} */
334
335 /* {{{ Removes variable from shared memory */
PHP_FUNCTION(shm_remove_var)336 PHP_FUNCTION(shm_remove_var)
337 {
338 zval *shm_id;
339 zend_long shm_key, shm_varpos;
340 sysvshm_shm *shm_list_ptr;
341
342 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "Ol", &shm_id, sysvshm_ce, &shm_key)) {
343 RETURN_THROWS();
344 }
345
346 shm_list_ptr = Z_SYSVSHM_P(shm_id);
347 if (!shm_list_ptr->ptr) {
348 zend_throw_error(NULL, "Shared memory block has already been destroyed");
349 RETURN_THROWS();
350 }
351
352 shm_varpos = php_check_shm_data(shm_list_ptr->ptr, shm_key);
353
354 if (shm_varpos < 0) {
355 php_error_docref(NULL, E_WARNING, "Variable key " ZEND_LONG_FMT " doesn't exist", shm_key);
356 RETURN_FALSE;
357 }
358 php_remove_shm_data((shm_list_ptr->ptr), shm_varpos);
359 RETURN_TRUE;
360 }
361 /* }}} */
362
363 /* {{{ php_put_shm_data
364 * inserts an ascii-string into shared memory */
php_put_shm_data(sysvshm_chunk_head * ptr,zend_long key,const char * data,zend_long len)365 static int php_put_shm_data(sysvshm_chunk_head *ptr, zend_long key, const char *data, zend_long len)
366 {
367 sysvshm_chunk *shm_var;
368 zend_long total_size;
369 zend_long shm_varpos;
370
371 total_size = ((zend_long) (len + sizeof(sysvshm_chunk) - 1) / sizeof(zend_long)) * sizeof(zend_long) + sizeof(zend_long); /* zend_long alligment */
372
373 if ((shm_varpos = php_check_shm_data(ptr, key)) > 0) {
374 php_remove_shm_data(ptr, shm_varpos);
375 }
376
377 if (ptr->free < total_size) {
378 return -1; /* not enough memory */
379 }
380
381 shm_var = (sysvshm_chunk *) ((char *) ptr + ptr->end);
382 shm_var->key = key;
383 shm_var->length = len;
384 shm_var->next = total_size;
385 memcpy(&(shm_var->mem), data, len);
386 ptr->end += total_size;
387 ptr->free -= total_size;
388 return 0;
389 }
390 /* }}} */
391
392 /* {{{ php_check_shm_data */
php_check_shm_data(sysvshm_chunk_head * ptr,zend_long key)393 static zend_long php_check_shm_data(sysvshm_chunk_head *ptr, zend_long key)
394 {
395 zend_long pos;
396 sysvshm_chunk *shm_var;
397
398 ZEND_ASSERT(ptr);
399
400 pos = ptr->start;
401
402 for (;;) {
403 if (pos >= ptr->end) {
404 return -1;
405 }
406 shm_var = (sysvshm_chunk*) ((char *) ptr + pos);
407 if (shm_var->key == key) {
408 return pos;
409 }
410 pos += shm_var->next;
411
412 if (shm_var->next <= 0 || pos < ptr->start) {
413 return -1;
414 }
415 }
416 return -1;
417 }
418 /* }}} */
419
420 /* {{{ php_remove_shm_data */
php_remove_shm_data(sysvshm_chunk_head * ptr,zend_long shm_varpos)421 static int php_remove_shm_data(sysvshm_chunk_head *ptr, zend_long shm_varpos)
422 {
423 sysvshm_chunk *chunk_ptr, *next_chunk_ptr;
424 zend_long memcpy_len;
425
426 ZEND_ASSERT(ptr);
427
428 chunk_ptr = (sysvshm_chunk *) ((char *) ptr + shm_varpos);
429 next_chunk_ptr = (sysvshm_chunk *) ((char *) ptr + shm_varpos + chunk_ptr->next);
430
431 memcpy_len = ptr->end-shm_varpos - chunk_ptr->next;
432 ptr->free += chunk_ptr->next;
433 ptr->end -= chunk_ptr->next;
434 if (memcpy_len > 0) {
435 memmove(chunk_ptr, next_chunk_ptr, memcpy_len);
436 }
437 return 0;
438 }
439 /* }}} */
440
441 #endif /* HAVE_SYSVSHM */
442
