Imported from /home/lorry/working-area/delta_php2/php-5.4.13.tar.bz2.HEADphp-5.4.13master

1 files changed, 477 insertions, 0 deletions

diff --git a/ext/sysvmsg/sysvmsg.c b/ext/sysvmsg/sysvmsg.c
new file mode 100644
index 0000000..ebc4427
--- /dev/null
+++ b/ext/sysvmsg/sysvmsg.c
@@ -0,0 +1,477 @@
+/*
+  +----------------------------------------------------------------------+
+  | PHP Version 5                                                        |
+  +----------------------------------------------------------------------+
+  | Copyright (c) 1997-2013 The PHP Group                                |
+  +----------------------------------------------------------------------+
+  | This source file is subject to version 3.01 of the PHP license,      |
+  | that is bundled with this package in the file LICENSE, and is        |
+  | available through the world-wide-web at the following url:           |
+  | http://www.php.net/license/3_01.txt                                  |
+  | If you did not receive a copy of the PHP license and are unable to   |
+  | obtain it through the world-wide-web, please send a note to          |
+  | license@php.net so we can mail you a copy immediately.               |
+  +----------------------------------------------------------------------+
+  | Author: Wez Furlong <wez@thebrainroom.com>                           |
+  +----------------------------------------------------------------------+
+*/
+
+/* $Id: e268047b695fe9a43cdf415c429729252347becd $ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "php.h"
+#include "php_globals.h"
+#include "ext/standard/info.h"
+#include "php_sysvmsg.h"
+#include "ext/standard/php_var.h"
+#include "ext/standard/php_smart_str.h"
+
+/* In order to detect MSG_EXCEPT use at run time; we have no way
+ * of knowing what the bit definitions are, so we can't just define
+ * out own MSG_EXCEPT value. */
+#define PHP_MSG_IPC_NOWAIT	1
+#define PHP_MSG_NOERROR		2
+#define PHP_MSG_EXCEPT		4
+
+/* True global resources - no need for thread safety here */
+static int le_sysvmsg;
+
+/* {{{ arginfo */
+ZEND_BEGIN_ARG_INFO_EX(arginfo_msg_get_queue, 0, 0, 1)
+	ZEND_ARG_INFO(0, key)
+	ZEND_ARG_INFO(0, perms)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_msg_send, 0, 0, 3)
+	ZEND_ARG_INFO(0, queue)
+	ZEND_ARG_INFO(0, msgtype)
+	ZEND_ARG_INFO(0, message)
+	ZEND_ARG_INFO(0, serialize)
+	ZEND_ARG_INFO(0, blocking)
+	ZEND_ARG_INFO(1, errorcode)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_msg_receive, 0, 0, 5)
+	ZEND_ARG_INFO(0, queue)
+	ZEND_ARG_INFO(0, desiredmsgtype)
+	ZEND_ARG_INFO(1, msgtype)
+	ZEND_ARG_INFO(0, maxsize)
+	ZEND_ARG_INFO(1, message)
+	ZEND_ARG_INFO(0, unserialize)
+	ZEND_ARG_INFO(0, flags)
+	ZEND_ARG_INFO(1, errorcode)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_msg_remove_queue, 0, 0, 1)
+	ZEND_ARG_INFO(0, queue)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_msg_stat_queue, 0, 0, 1)
+	ZEND_ARG_INFO(0, queue)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_msg_set_queue, 0, 0, 2)
+	ZEND_ARG_INFO(0, queue)
+	ZEND_ARG_INFO(0, data)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_msg_queue_exists, 0, 0, 1)
+	ZEND_ARG_INFO(0, key)
+ZEND_END_ARG_INFO()
+/* }}} */
+
+/* {{{ sysvmsg_functions[]
+ *
+ * Every user visible function must have an entry in sysvmsg_functions[].
+ */
+const zend_function_entry sysvmsg_functions[] = {
+	PHP_FE(msg_get_queue,				arginfo_msg_get_queue)
+	PHP_FE(msg_send,					arginfo_msg_send)
+	PHP_FE(msg_receive,					arginfo_msg_receive)
+	PHP_FE(msg_remove_queue,			arginfo_msg_remove_queue)
+	PHP_FE(msg_stat_queue,				arginfo_msg_stat_queue)
+	PHP_FE(msg_set_queue,				arginfo_msg_set_queue)
+	PHP_FE(msg_queue_exists,			arginfo_msg_queue_exists)
+	PHP_FE_END
+};
+/* }}} */
+
+/* {{{ sysvmsg_module_entry
+ */
+zend_module_entry sysvmsg_module_entry = {
+	STANDARD_MODULE_HEADER,
+	"sysvmsg",
+	sysvmsg_functions,
+	PHP_MINIT(sysvmsg),
+	NULL,
+	NULL,
+	NULL,
+	PHP_MINFO(sysvmsg),
+	NO_VERSION_YET,
+	STANDARD_MODULE_PROPERTIES
+};
+/* }}} */
+
+#ifdef COMPILE_DL_SYSVMSG
+ZEND_GET_MODULE(sysvmsg)
+#endif
+
+static void sysvmsg_release(zend_rsrc_list_entry *rsrc TSRMLS_DC)
+{
+	sysvmsg_queue_t * mq = (sysvmsg_queue_t *) rsrc->ptr;
+	efree(mq);
+}
+
+/* {{{ PHP_MINIT_FUNCTION
+ */
+PHP_MINIT_FUNCTION(sysvmsg)
+{
+	le_sysvmsg = zend_register_list_destructors_ex(sysvmsg_release, NULL, "sysvmsg queue", module_number);
+	REGISTER_LONG_CONSTANT("MSG_IPC_NOWAIT", PHP_MSG_IPC_NOWAIT, CONST_PERSISTENT|CONST_CS);
+	REGISTER_LONG_CONSTANT("MSG_EAGAIN",	 EAGAIN, 	     CONST_PERSISTENT|CONST_CS);
+	REGISTER_LONG_CONSTANT("MSG_ENOMSG",	 ENOMSG, 	     CONST_PERSISTENT|CONST_CS);
+	REGISTER_LONG_CONSTANT("MSG_NOERROR",    PHP_MSG_NOERROR,    CONST_PERSISTENT|CONST_CS);
+	REGISTER_LONG_CONSTANT("MSG_EXCEPT",     PHP_MSG_EXCEPT,     CONST_PERSISTENT|CONST_CS);
+	return SUCCESS;
+}
+/* }}} */
+
+/* {{{ PHP_MINFO_FUNCTION
+ */
+PHP_MINFO_FUNCTION(sysvmsg)
+{
+	php_info_print_table_start();
+	php_info_print_table_row(2, "sysvmsg support", "enabled");
+	php_info_print_table_row(2, "Revision", "$Id: e268047b695fe9a43cdf415c429729252347becd $");
+	php_info_print_table_end();
+}
+/* }}} */
+
+/* {{{ proto bool msg_set_queue(resource queue, array data)
+   Set information for a message queue */
+PHP_FUNCTION(msg_set_queue)
+{
+	zval *queue, *data;
+	sysvmsg_queue_t *mq = NULL;
+	struct msqid_ds stat;
+
+	RETVAL_FALSE;
+
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ra", &queue, &data) == FAILURE) {
+		return;
+	}
+
+	ZEND_FETCH_RESOURCE(mq, sysvmsg_queue_t *, &queue, -1, "sysvmsg queue", le_sysvmsg);
+
+	if (msgctl(mq->id, IPC_STAT, &stat) == 0) {
+		zval **item;
+
+		/* now pull out members of data and set them in the stat buffer */
+		if (zend_hash_find(Z_ARRVAL_P(data), "msg_perm.uid", sizeof("msg_perm.uid"), (void **) &item) == SUCCESS) {
+			convert_to_long_ex(item);
+			stat.msg_perm.uid = Z_LVAL_PP(item);
+		}
+		if (zend_hash_find(Z_ARRVAL_P(data), "msg_perm.gid", sizeof("msg_perm.gid"), (void **) &item) == SUCCESS) {
+			convert_to_long_ex(item);
+			stat.msg_perm.gid = Z_LVAL_PP(item);
+		}
+		if (zend_hash_find(Z_ARRVAL_P(data), "msg_perm.mode", sizeof("msg_perm.mode"), (void **) &item) == SUCCESS) {
+			convert_to_long_ex(item);
+			stat.msg_perm.mode = Z_LVAL_PP(item);
+		}
+		if (zend_hash_find(Z_ARRVAL_P(data), "msg_qbytes", sizeof("msg_qbytes"), (void **) &item) == SUCCESS) {
+			convert_to_long_ex(item);
+			stat.msg_qbytes = Z_LVAL_PP(item);
+		}
+		if (msgctl(mq->id, IPC_SET, &stat) == 0) {
+			RETVAL_TRUE;
+		}
+	}
+}
+/* }}} */
+
+/* {{{ proto array msg_stat_queue(resource queue)
+   Returns information about a message queue */
+PHP_FUNCTION(msg_stat_queue)
+{
+	zval *queue;
+	sysvmsg_queue_t *mq = NULL;
+	struct msqid_ds stat;
+
+	RETVAL_FALSE;
+
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &queue) == FAILURE) {
+		return;
+	}
+
+	ZEND_FETCH_RESOURCE(mq, sysvmsg_queue_t *, &queue, -1, "sysvmsg queue", le_sysvmsg);
+
+	if (msgctl(mq->id, IPC_STAT, &stat) == 0) {
+		array_init(return_value);
+
+		add_assoc_long(return_value, "msg_perm.uid", stat.msg_perm.uid);
+		add_assoc_long(return_value, "msg_perm.gid", stat.msg_perm.gid);
+		add_assoc_long(return_value, "msg_perm.mode", stat.msg_perm.mode);
+		add_assoc_long(return_value, "msg_stime",  stat.msg_stime);
+		add_assoc_long(return_value, "msg_rtime",  stat.msg_rtime);
+		add_assoc_long(return_value, "msg_ctime",  stat.msg_ctime);
+		add_assoc_long(return_value, "msg_qnum",   stat.msg_qnum);
+		add_assoc_long(return_value, "msg_qbytes", stat.msg_qbytes);
+		add_assoc_long(return_value, "msg_lspid",  stat.msg_lspid);
+		add_assoc_long(return_value, "msg_lrpid",  stat.msg_lrpid);
+	}
+}
+/* }}} */
+
+
+/* {{{ proto bool msg_queue_exists(int key)
+   Check wether a message queue exists */
+PHP_FUNCTION(msg_queue_exists)
+{
+	long key;
+
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &key) == FAILURE)	{
+		return;
+	}
+
+	if (msgget(key, 0) < 0) {
+		RETURN_FALSE;
+	}
+
+	RETURN_TRUE;
+}
+/* }}} */
+
+
+/* {{{ proto resource msg_get_queue(int key [, int perms])
+   Attach to a message queue */
+PHP_FUNCTION(msg_get_queue)
+{
+	long key;
+	long perms = 0666;
+	sysvmsg_queue_t *mq;
+
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|l", &key, &perms) == FAILURE)	{
+		return;
+	}
+
+	mq = (sysvmsg_queue_t *) emalloc(sizeof(sysvmsg_queue_t));
+
+	mq->key = key;
+	mq->id = msgget(key, 0);
+	if (mq->id < 0)	{
+		/* doesn't already exist; create it */
+		mq->id = msgget(key, IPC_CREAT | IPC_EXCL | perms);
+		if (mq->id < 0)	{
+			php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed for key 0x%lx: %s", key, strerror(errno));
+			efree(mq);
+			RETURN_FALSE;
+		}
+	}
+	RETVAL_RESOURCE(zend_list_insert(mq, le_sysvmsg TSRMLS_CC));
+}
+/* }}} */
+
+/* {{{ proto bool msg_remove_queue(resource queue)
+   Destroy the queue */
+PHP_FUNCTION(msg_remove_queue)
+{
+	zval *queue;
+	sysvmsg_queue_t *mq = NULL;
+
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &queue) == FAILURE) {
+		return;
+	}
+
+	ZEND_FETCH_RESOURCE(mq, sysvmsg_queue_t *, &queue, -1, "sysvmsg queue", le_sysvmsg);
+
+	if (msgctl(mq->id, IPC_RMID, NULL) == 0) {
+		RETVAL_TRUE;
+	} else {
+		RETVAL_FALSE;
+	}
+}
+/* }}} */
+
+/* {{{ proto mixed msg_receive(resource queue, int desiredmsgtype, int &msgtype, int maxsize, mixed message [, bool unserialize=true [, int flags=0 [, int errorcode]]])
+   Send a message of type msgtype (must be > 0) to a message queue */
+PHP_FUNCTION(msg_receive)
+{
+	zval *out_message, *queue, *out_msgtype, *zerrcode = NULL;
+	long desiredmsgtype, maxsize, flags = 0;
+	long realflags = 0;
+	zend_bool do_unserialize = 1;
+	sysvmsg_queue_t *mq = NULL;
+	struct php_msgbuf *messagebuffer = NULL; /* buffer to transmit */
+	int result;
+
+	RETVAL_FALSE;
+
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlzlz|blz",
+				&queue, &desiredmsgtype, &out_msgtype, &maxsize,
+				&out_message, &do_unserialize, &flags, &zerrcode) == FAILURE) {
+		return;
+	}
+
+	if (maxsize <= 0) {
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "maximum size of the message has to be greater than zero");
+		return;
+	}
+
+	if (flags != 0) {
+		if (flags & PHP_MSG_EXCEPT) {
+#ifndef MSG_EXCEPT
+			php_error_docref(NULL TSRMLS_CC, E_WARNING, "MSG_EXCEPT is not supported on your system");
+			RETURN_FALSE;
+#else
+			realflags |= MSG_EXCEPT;
+#endif
+		}
+		if (flags & PHP_MSG_NOERROR) {
+			realflags |= MSG_NOERROR;
+		}
+		if (flags & PHP_MSG_IPC_NOWAIT) {
+			realflags |= IPC_NOWAIT;
+		}
+	}
+
+	ZEND_FETCH_RESOURCE(mq, sysvmsg_queue_t *, &queue, -1, "sysvmsg queue", le_sysvmsg);
+
+	messagebuffer = (struct php_msgbuf *) safe_emalloc(maxsize, 1, sizeof(struct php_msgbuf));
+
+	result = msgrcv(mq->id, messagebuffer, maxsize, desiredmsgtype, realflags);
+
+	zval_dtor(out_msgtype);
+	zval_dtor(out_message);
+	ZVAL_LONG(out_msgtype, 0);
+	ZVAL_FALSE(out_message);
+
+	if (zerrcode) {
+		zval_dtor(zerrcode);
+		ZVAL_LONG(zerrcode, 0);
+	}
+
+	if (result >= 0) {
+		/* got it! */
+		ZVAL_LONG(out_msgtype, messagebuffer->mtype);
+
+		RETVAL_TRUE;
+		if (do_unserialize)	{
+			php_unserialize_data_t var_hash;
+			zval *tmp = NULL;
+			const unsigned char *p = (const unsigned char *) messagebuffer->mtext;
+
+			MAKE_STD_ZVAL(tmp);
+			PHP_VAR_UNSERIALIZE_INIT(var_hash);
+			if (!php_var_unserialize(&tmp, &p, p + result, &var_hash TSRMLS_CC)) {
+				php_error_docref(NULL TSRMLS_CC, E_WARNING, "message corrupted");
+				RETVAL_FALSE;
+			} else {
+				REPLACE_ZVAL_VALUE(&out_message, tmp, 0);
+			}
+			FREE_ZVAL(tmp);
+			PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
+		} else {
+			ZVAL_STRINGL(out_message, messagebuffer->mtext, result, 1);
+		}
+	} else if (zerrcode) {
+		ZVAL_LONG(zerrcode, errno);
+	}
+	efree(messagebuffer);
+}
+/* }}} */
+
+/* {{{ proto bool msg_send(resource queue, int msgtype, mixed message [, bool serialize=true [, bool blocking=true [, int errorcode]]])
+   Send a message of type msgtype (must be > 0) to a message queue */
+PHP_FUNCTION(msg_send)
+{
+	zval *message, *queue, *zerror=NULL;
+	long msgtype;
+	zend_bool do_serialize = 1, blocking = 1;
+	sysvmsg_queue_t * mq = NULL;
+	struct php_msgbuf * messagebuffer = NULL; /* buffer to transmit */
+	int result;
+	int message_len = 0;
+
+	RETVAL_FALSE;
+
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlz|bbz",
+				&queue, &msgtype, &message, &do_serialize, &blocking, &zerror) == FAILURE) {
+		return;
+	}
+
+	ZEND_FETCH_RESOURCE(mq, sysvmsg_queue_t*, &queue, -1, "sysvmsg queue", le_sysvmsg);
+
+	if (do_serialize) {
+		smart_str msg_var = {0};
+		php_serialize_data_t var_hash;
+
+		PHP_VAR_SERIALIZE_INIT(var_hash);
+		php_var_serialize(&msg_var, &message, &var_hash TSRMLS_CC);
+		PHP_VAR_SERIALIZE_DESTROY(var_hash);
+
+		/* NB: php_msgbuf is 1 char bigger than a long, so there is no need to
+		 * allocate the extra byte. */
+		messagebuffer = safe_emalloc(msg_var.len, 1, sizeof(struct php_msgbuf));
+		memcpy(messagebuffer->mtext, msg_var.c, msg_var.len + 1);
+		message_len = msg_var.len;
+		smart_str_free(&msg_var);
+	} else {
+		char *p;
+		switch (Z_TYPE_P(message)) {
+			case IS_STRING:
+				p = Z_STRVAL_P(message);
+				message_len = Z_STRLEN_P(message);
+				break;
+
+			case IS_LONG:
+			case IS_BOOL:
+				message_len = spprintf(&p, 0, "%ld", Z_LVAL_P(message));
+				break;
+
+			case IS_DOUBLE:
+				message_len = spprintf(&p, 0, "%F", Z_DVAL_P(message));
+				break;
+
+			default:
+				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Message parameter must be either a string or a number.");
+				RETURN_FALSE;
+		}
+
+		messagebuffer = safe_emalloc(message_len, 1, sizeof(struct php_msgbuf));
+		memcpy(messagebuffer->mtext, p, message_len + 1);
+
+		if (Z_TYPE_P(message) != IS_STRING) {
+			efree(p);
+		}
+	}
+
+	/* set the message type */
+	messagebuffer->mtype = msgtype;
+
+	result = msgsnd(mq->id, messagebuffer, message_len, blocking ? 0 : IPC_NOWAIT);
+
+	efree(messagebuffer);
+
+	if (result == -1) {
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "msgsnd failed: %s", strerror(errno));
+		if (zerror) {
+			ZVAL_LONG(zerror, errno);
+		}
+	} else {
+		RETVAL_TRUE;
+	}
+}
+/* }}} */
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim600: noet sw=4 ts=4 tw=78 fdm=marker
+ * vim<600: noet sw=4 ts=4 tw=78
+ */