1 /*
2 +----------------------------------------------------------------------+
3 | PHP version 7 |
4 +----------------------------------------------------------------------+
5 | Copyright (c) The PHP Group |
6 +----------------------------------------------------------------------+
7 | This source file is subject to version 3.01 of the PHP 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 | https://www.php.net/license/3_01.txt |
11 | If you did not receive a copy of the PHP license and are unable to |
12 | obtain it through the world-wide-web, please send a note to |
13 | license@php.net so we can mail you a copy immediately. |
14 +----------------------------------------------------------------------+
15 | Authors: Slava Poliakov <hackie@prohost.org> |
16 | Ilia Alshanetsky <ilia@prohost.org> |
17 +----------------------------------------------------------------------+
18 */
19
20 #ifdef HAVE_CONFIG_H
21 #include <config.h>
22 #endif
23
24 #include "php.h"
25 #include "php_shmop.h"
26 #include "Zend/zend_attributes.h"
27
28 #include "shmop_arginfo.h"
29
30 # ifndef PHP_WIN32
31 # include <sys/ipc.h>
32 # include <sys/shm.h>
33 #else
34 #include "tsrm_win32.h"
35 #endif
36
37
38 #ifdef HAVE_SHMOP
39
40 #include "ext/standard/info.h"
41
42 /* {{{ shmop_module_entry */
43 zend_module_entry shmop_module_entry = {
44 STANDARD_MODULE_HEADER,
45 "shmop",
46 ext_functions,
47 PHP_MINIT(shmop),
48 NULL,
49 NULL,
50 NULL,
51 PHP_MINFO(shmop),
52 PHP_SHMOP_VERSION,
53 STANDARD_MODULE_PROPERTIES
54 };
55 /* }}} */
56
57 #ifdef COMPILE_DL_SHMOP
58 ZEND_GET_MODULE(shmop)
59 #endif
60
61 typedef struct php_shmop
62 {
63 int shmid;
64 key_t key;
65 int shmflg;
66 int shmatflg;
67 char *addr;
68 zend_long size;
69 zend_object std;
70 } php_shmop;
71
72 zend_class_entry *shmop_ce;
73 static zend_object_handlers shmop_object_handlers;
74
shmop_from_obj(zend_object * obj)75 static inline php_shmop *shmop_from_obj(zend_object *obj)
76 {
77 return (php_shmop *)((char *)(obj) - XtOffsetOf(php_shmop, std));
78 }
79
80 #define Z_SHMOP_P(zv) shmop_from_obj(Z_OBJ_P(zv))
81
shmop_create_object(zend_class_entry * class_type)82 static zend_object *shmop_create_object(zend_class_entry *class_type)
83 {
84 php_shmop *intern = zend_object_alloc(sizeof(php_shmop), class_type);
85
86 zend_object_std_init(&intern->std, class_type);
87 object_properties_init(&intern->std, class_type);
88
89 return &intern->std;
90 }
91
shmop_get_constructor(zend_object * object)92 static zend_function *shmop_get_constructor(zend_object *object)
93 {
94 zend_throw_error(NULL, "Cannot directly construct Shmop, use shmop_open() instead");
95 return NULL;
96 }
97
shmop_free_obj(zend_object * object)98 static void shmop_free_obj(zend_object *object)
99 {
100 php_shmop *shmop = shmop_from_obj(object);
101
102 shmdt(shmop->addr);
103
104 zend_object_std_dtor(&shmop->std);
105 }
106
107 /* {{{ PHP_MINIT_FUNCTION */
PHP_MINIT_FUNCTION(shmop)108 PHP_MINIT_FUNCTION(shmop)
109 {
110 shmop_ce = register_class_Shmop();
111 shmop_ce->create_object = shmop_create_object;
112 shmop_ce->default_object_handlers = &shmop_object_handlers;
113
114 memcpy(&shmop_object_handlers, &std_object_handlers, sizeof(zend_object_handlers));
115 shmop_object_handlers.offset = XtOffsetOf(php_shmop, std);
116 shmop_object_handlers.free_obj = shmop_free_obj;
117 shmop_object_handlers.get_constructor = shmop_get_constructor;
118 shmop_object_handlers.clone_obj = NULL;
119 shmop_object_handlers.compare = zend_objects_not_comparable;
120
121 register_shmop_symbols(module_number);
122
123 return SUCCESS;
124 }
125 /* }}} */
126
127 /* {{{ PHP_MINFO_FUNCTION */
PHP_MINFO_FUNCTION(shmop)128 PHP_MINFO_FUNCTION(shmop)
129 {
130 php_info_print_table_start();
131 php_info_print_table_row(2, "shmop support", "enabled");
132 php_info_print_table_end();
133 }
134 /* }}} */
135
136 /* {{{ gets and attaches a shared memory segment */
PHP_FUNCTION(shmop_open)137 PHP_FUNCTION(shmop_open)
138 {
139 zend_long key, mode, size;
140 php_shmop *shmop;
141 struct shmid_ds shm;
142 char *flags;
143 size_t flags_len;
144
145 if (zend_parse_parameters(ZEND_NUM_ARGS(), "lsll", &key, &flags, &flags_len, &mode, &size) == FAILURE) {
146 RETURN_THROWS();
147 }
148
149 if (flags_len != 1) {
150 zend_argument_value_error(2, "must be a valid access mode");
151 RETURN_THROWS();
152 }
153
154 object_init_ex(return_value, shmop_ce);
155 shmop = Z_SHMOP_P(return_value);
156 shmop->key = key;
157 shmop->shmflg |= mode;
158
159 switch (flags[0])
160 {
161 case 'a':
162 shmop->shmatflg |= SHM_RDONLY;
163 break;
164 case 'c':
165 shmop->shmflg |= IPC_CREAT;
166 shmop->size = size;
167 break;
168 case 'n':
169 shmop->shmflg |= (IPC_CREAT | IPC_EXCL);
170 shmop->size = size;
171 break;
172 case 'w':
173 /* noop
174 shm segment is being opened for read & write
175 will fail if segment does not exist
176 */
177 break;
178 default:
179 zend_argument_value_error(2, "must be a valid access mode");
180 goto err;
181 }
182
183 if (shmop->shmflg & IPC_CREAT && shmop->size < 1) {
184 zend_argument_value_error(4, "must be greater than 0 for the \"c\" and \"n\" access modes");
185 goto err;
186 }
187
188 shmop->shmid = shmget(shmop->key, shmop->size, shmop->shmflg);
189 if (shmop->shmid == -1) {
190 php_error_docref(NULL, E_WARNING, "Unable to attach or create shared memory segment \"%s\"", strerror(errno));
191 goto err;
192 }
193
194 if (shmctl(shmop->shmid, IPC_STAT, &shm)) {
195 /* please do not add coverage here: the segment would be leaked and impossible to delete via php */
196 php_error_docref(NULL, E_WARNING, "Unable to get shared memory segment information \"%s\"", strerror(errno));
197 goto err;
198 }
199
200 if (shm.shm_segsz > ZEND_LONG_MAX) {
201 zend_argument_value_error(4, "is too large");
202 goto err;
203 }
204
205 shmop->addr = shmat(shmop->shmid, 0, shmop->shmatflg);
206 if (shmop->addr == (char*) -1) {
207 php_error_docref(NULL, E_WARNING, "Unable to attach to shared memory segment \"%s\"", strerror(errno));
208 goto err;
209 }
210
211 shmop->size = shm.shm_segsz;
212 return;
213
214 err:
215 zend_object_release(Z_OBJ_P(return_value));
216 RETURN_FALSE;
217 }
218 /* }}} */
219
220 /* {{{ reads from a shm segment */
PHP_FUNCTION(shmop_read)221 PHP_FUNCTION(shmop_read)
222 {
223 zval *shmid;
224 zend_long start, count;
225 php_shmop *shmop;
226 char *startaddr;
227 int bytes;
228 zend_string *return_string;
229
230 if (zend_parse_parameters(ZEND_NUM_ARGS(), "Oll", &shmid, shmop_ce, &start, &count) == FAILURE) {
231 RETURN_THROWS();
232 }
233
234 shmop = Z_SHMOP_P(shmid);
235
236 if (start < 0 || start > shmop->size) {
237 zend_argument_value_error(2, "must be between 0 and the segment size");
238 RETURN_THROWS();
239 }
240
241 if (count < 0 || start > (ZEND_LONG_MAX - count) || start + count > shmop->size) {
242 zend_argument_value_error(3, "is out of range");
243 RETURN_THROWS();
244 }
245
246 startaddr = shmop->addr + start;
247 bytes = count ? count : shmop->size - start;
248
249 return_string = zend_string_init(startaddr, bytes, 0);
250
251 RETURN_NEW_STR(return_string);
252 }
253 /* }}} */
254
255 /* {{{ used to close a shared memory segment; now a NOP */
PHP_FUNCTION(shmop_close)256 PHP_FUNCTION(shmop_close)
257 {
258 zval *shmid;
259
260 if (zend_parse_parameters(ZEND_NUM_ARGS(), "O", &shmid, shmop_ce) == FAILURE) {
261 RETURN_THROWS();
262 }
263 }
264 /* }}} */
265
266 /* {{{ returns the shm size */
PHP_FUNCTION(shmop_size)267 PHP_FUNCTION(shmop_size)
268 {
269 zval *shmid;
270 php_shmop *shmop;
271
272 if (zend_parse_parameters(ZEND_NUM_ARGS(), "O", &shmid, shmop_ce) == FAILURE) {
273 RETURN_THROWS();
274 }
275
276 shmop = Z_SHMOP_P(shmid);
277
278 RETURN_LONG(shmop->size);
279 }
280 /* }}} */
281
282 /* {{{ writes to a shared memory segment */
PHP_FUNCTION(shmop_write)283 PHP_FUNCTION(shmop_write)
284 {
285 php_shmop *shmop;
286 zend_long writesize;
287 zend_long offset;
288 zend_string *data;
289 zval *shmid;
290
291 if (zend_parse_parameters(ZEND_NUM_ARGS(), "OSl", &shmid, shmop_ce, &data, &offset) == FAILURE) {
292 RETURN_THROWS();
293 }
294
295 shmop = Z_SHMOP_P(shmid);
296
297 if ((shmop->shmatflg & SHM_RDONLY) == SHM_RDONLY) {
298 zend_throw_error(NULL, "Read-only segment cannot be written");
299 RETURN_THROWS();
300 }
301
302 if (offset < 0 || offset > shmop->size) {
303 zend_argument_value_error(3, "is out of range");
304 RETURN_THROWS();
305 }
306
307 writesize = ((zend_long)ZSTR_LEN(data) < shmop->size - offset) ? (zend_long)ZSTR_LEN(data) : shmop->size - offset;
308 memcpy(shmop->addr + offset, ZSTR_VAL(data), writesize);
309
310 RETURN_LONG(writesize);
311 }
312 /* }}} */
313
314 /* {{{ mark segment for deletion */
PHP_FUNCTION(shmop_delete)315 PHP_FUNCTION(shmop_delete)
316 {
317 zval *shmid;
318 php_shmop *shmop;
319
320 if (zend_parse_parameters(ZEND_NUM_ARGS(), "O", &shmid, shmop_ce) == FAILURE) {
321 RETURN_THROWS();
322 }
323
324 shmop = Z_SHMOP_P(shmid);
325
326 if (shmctl(shmop->shmid, IPC_RMID, NULL)) {
327 php_error_docref(NULL, E_WARNING, "Can't mark segment for deletion (are you the owner?)");
328 RETURN_FALSE;
329 }
330
331 RETURN_TRUE;
332 }
333 /* }}} */
334
335 #endif /* HAVE_SHMOP */
336
