[prev in list] [next in list] [prev in thread] [next in thread]
List: pecl-cvs
Subject: [PECL-CVS] cvs: pecl /mqseries README config.m4 mqseries.c mqseries_init_const.h mqseries_reason_tex
From: "Philippe Tjon - A - Hen" <philippe () php ! net>
Date: 2006-04-22 18:59:58
Message-ID: cvsphilippe1145732398 () cvsserver
[Download RAW message or body]
philippe Sat Apr 22 18:59:58 2006 UTC
Added files:
/pecl/mqseries README
Modified files:
/pecl/mqseries config.m4 mqseries.c mqseries_init_const.h
mqseries_reason_texts.h package.xml php_mqseries.h
Log:
CVS update with latest package release
["philippe-20060422185958.txt" (text/plain)]
http://cvs.php.net/viewcvs.cgi/pecl/mqseries/config.m4?r1=1.1&r2=1.2&diff_format=u
Index: pecl/mqseries/config.m4
diff -u pecl/mqseries/config.m4:1.1 pecl/mqseries/config.m4:1.2
--- pecl/mqseries/config.m4:1.1 Sat May 17 19:29:28 2003
+++ pecl/mqseries/config.m4 Sat Apr 22 18:59:58 2006
@@ -1,4 +1,4 @@
-dnl $Id: config.m4,v 1.1 2003/05/17 19:29:28 mbretter Exp $
+dnl $Id: config.m4,v 1.2 2006/04/22 18:59:58 philippe Exp $
dnl config.m4 for extension mqseries
PHP_ARG_WITH(mqseries, for mqseries support,
@@ -8,9 +8,9 @@
dnl Write more examples of tests here...
dnl # --with-mqseries -> check with-path
- SEARCH_PATH="/usr/local /usr /opt /opt/mqm" # you might want to change this
- SEARCH_FOR="/inc/cmqcfc.h" # you most likely want to change this
- if test -r $PHP_MQSERIES/; then # path given as parameter
+ SEARCH_PATH="/usr/local /usr /opt /opt/mqm" # you might want to change this
+ SEARCH_FOR="/inc/cmqcfc.h" # you most likely want to change this
+ if test -r $PHP_MQSERIES/; then # path given as parameter
MQSERIES_DIR=$PHP_MQSERIES
else # search default path list
AC_MSG_CHECKING([for mqseries files in default path])
@@ -31,7 +31,9 @@
PHP_ADD_INCLUDE($MQSERIES_DIR/inc)
dnl # --with-mqseries -> chech for lib and symbol presence
- LIBNAME=mqic # you may want to change this
+ # when using server only
+ #LIBNAME=mqm
+ LIBNAME=mqic # you may want to change this
LIBSYMBOL=MQCONN # you most likely want to change this
PHP_CHECK_LIBRARY($LIBNAME,$LIBSYMBOL,
@@ -43,6 +45,7 @@
],[
-L$MQSERIES_DIR/lib
])
+
PHP_SUBST(MQSERIES_SHARED_LIBADD)
PHP_NEW_EXTENSION(mqseries, mqseries.c, $ext_shared)
http://cvs.php.net/viewcvs.cgi/pecl/mqseries/mqseries.c?r1=1.3&r2=1.4&diff_format=u
Index: pecl/mqseries/mqseries.c
diff -u pecl/mqseries/mqseries.c:1.3 pecl/mqseries/mqseries.c:1.4
--- pecl/mqseries/mqseries.c:1.3 Mon May 19 19:25:37 2003
+++ pecl/mqseries/mqseries.c Sat Apr 22 18:59:58 2006
@@ -28,9 +28,11 @@
This code cannot simply be copied and put under the GNU Public License or
any other GPL-like (LGPL, GPL2) License.
- $Id: mqseries.c,v 1.3 2003/05/19 19:25:37 mbretter Exp $
+ $Id: mqseries.c,v 1.4 2006/04/22 18:59:58 philippe Exp $
Author: Michael Bretterklieber <mbretter@jawa.at>
+ Philippe Tjon A Hen <tjonahen@zonnet.nl>
+
*/
#ifdef HAVE_CONFIG_H
@@ -43,10 +45,39 @@
#include "ext/standard/info.h"
#include "php_mqseries.h"
+/* {{{ helper methods
+ */
static void _mqseries_disc(zend_rsrc_list_entry *rsrc TSRMLS_DC);
static void _mqseries_close(zend_rsrc_list_entry *rsrc TSRMLS_DC);
+static void _mqseries_bytes(zend_rsrc_list_entry *rsrc TSRMLS_DC);
+
+/* Are whe parsing message descriptor for an MQGet or MQPut */
+#define MQMD_GET 0
+#define MQMD_PUT 1
+
+static void set_msg_desc_from_array(zval *array, PMQMD msg_desc, int put_get);
+static void set_array_from_msg_desc(zval *return_value, PMQMD msg_desc);
+
+static void set_obj_desc_from_array(zval *array, PMQOD obj_desc);
+static void set_array_from_obj_desc(zval *array, PMQOD obj_desc);
+
+static void set_put_msg_opts_from_array(zval *array, PMQPMO put_msg_opts);
+static void set_array_from_put_msg_opts(zval *array, PMQPMO put_msg_opts);
+
+static void set_get_msg_opts_from_array(zval *array, PMQGMO get_msg_opts);
+static void set_array_from_get_msg_opts(zval *array, PMQGMO get_msg_opts);
+
-static void set_msg_desc_from_array(zval *array, MQMD *msg_desc);
+static void set_connect_opts_from_array(zval *array,
+ PMQCNO connect_opts,
+ PMQCD channel_definition,
+ PMQSCO ssl_configuration,
+ PMQAIR auth_inf_record,
+ PMQCHAR LDAPUserName);
+
+static int is_compcode_reason_ref(zval *z_comp_code, zval *z_reason);
+static int is_called_by_ref(zval *param, char *param_name);
+/* }}} */
/* If you declare any globals in php_mqseries.h uncomment this:
ZEND_DECLARE_MODULE_GLOBALS(mqseries)
@@ -55,6 +86,8 @@
/* True global resources - no need for thread safety here */
static int le_mqseries_conn;
static int le_mqseries_obj;
+static int le_mqseries_bytes;
+
static zval *z_reason_texts;
/* {{{ mqseries_functions[]
@@ -62,16 +95,19 @@
* Every user visible function must have an entry in mqseries_functions[].
*/
function_entry mqseries_functions[] = {
+ PHP_FE(mqseries_back, NULL)
+ PHP_FE(mqseries_begin, NULL)
+ PHP_FE(mqseries_close, NULL)
+ PHP_FE(mqseries_cmit, NULL)
PHP_FE(mqseries_conn, NULL)
+ PHP_FE(mqseries_connx, NULL)
PHP_FE(mqseries_disc, NULL)
- PHP_FE(mqseries_open, NULL)
PHP_FE(mqseries_get, NULL)
+ PHP_FE(mqseries_inq, NULL)
+ PHP_FE(mqseries_open, NULL)
PHP_FE(mqseries_put, NULL)
- PHP_FE(mqseries_begin, NULL)
- PHP_FE(mqseries_cmit, NULL)
- PHP_FE(mqseries_back, NULL)
- PHP_FE(mqseries_close, NULL)
- PHP_FE(mqseries_error, NULL)
+ PHP_FE(mqseries_put1, NULL)
+ PHP_FE(mqseries_set, NULL)
PHP_FE(mqseries_strerror, NULL)
{NULL, NULL, NULL} /* Must be the last line in mqseries_functions[] */
};
@@ -91,7 +127,7 @@
NULL,
PHP_MINFO(mqseries),
#if ZEND_MODULE_API_NO >= 20010901
- "0.7", /* Replace with version number for your extension */
+ "0.8", /* Replace with version number for your extension */
#endif
STANDARD_MODULE_PROPERTIES
};
@@ -107,7 +143,10 @@
{
/* don't change the order of these, objects must be freed before connections */
le_mqseries_obj = zend_register_list_destructors_ex(_mqseries_close, NULL, \
"mqseries_obj", module_number); +
le_mqseries_conn = zend_register_list_destructors_ex(_mqseries_disc, NULL, \
"mqseries_conn", module_number); +
+ le_mqseries_bytes = zend_register_list_destructors_ex(_mqseries_bytes, NULL, \
"mqseries_bytes", module_number);
#include "mqseries_init_const.h"
@@ -133,244 +172,445 @@
{
php_info_print_table_start();
php_info_print_table_row(2, "mqseries support", "enabled");
- php_info_print_table_row(2, "Revision", "$Revision: 1.3 $");
+ php_info_print_table_row(2, "Revision", "$Revision: 1.4 $");
php_info_print_table_end();
}
/* }}} */
-/* {{{ proto ressource mqseries_conn(string name)
- Connect to the Queue-Manager with the given Name. You need either the Channel-Table \
(usualy in /var/mqm) or set the environment var \
MQSERVER=<channel>/<proto>/<host>[(port)] MQSERVER=example/TCP/mqs.example.com +/* \
{{{ proto mqseries_conn(string name, resourceref connection, resourceref \
completion_code, resourceref reason ) + Connect to the Queue-Manager with the given \
Name. +
+ You need either the Channel-Table (usualy in /var/mqm)
+ or set the environment var MQSERVER=<channel>/<proto>/<host>[(port)] \
MQSERVER=example/TCP/mqs.example.com +
+PHP sample:
+
+ mqseries_conn('QM_donald', &$conn, &$compcode, &$reason);
+
+ if ($compcode !== MQSERIES_MQCC_OK) {
+ printf("CompCode:%d Reason:%d Text:%s\n", $compcode, $reason, \
mqseries_strerror($reason)); +
+ }
+
+MQ call:
+ MQCONN ( QMgrName -- input : QManager name
+ , Hconn -- output : Connection Handle
+ , CompCode -- output : completion code
+ , Reason) -- output : reason code
*/
PHP_FUNCTION(mqseries_conn)
{
char *name;
int name_len;
+ zval *z_conn, *z_comp_code, *z_reason;
+
mqseries_descriptor *mqdesc;
- MQLONG comp_code; /* Completion code */
- MQLONG reason; /* Qualifying reason */
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_len)
+ MQCHAR48 qManagerName;
+ MQLONG comp_code;
+ MQLONG reason;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szzz", &name, &name_len,
+ &z_conn, &z_comp_code, &z_reason)
== FAILURE) {
return;
}
+ if (!is_called_by_ref(z_conn, "conn")) return ;
+ if (!is_compcode_reason_ref(z_comp_code, z_reason)) return;
+
+ strncpy(qManagerName, name, sizeof(MQCHAR48));
mqdesc = emalloc(sizeof(mqseries_descriptor));
- MQCONN(name, &mqdesc->conn, &comp_code, &reason);
+ MQCONN(qManagerName, &mqdesc->conn, &comp_code, &reason);
- if ((comp_code != MQCC_OK) || (reason != MQRC_NONE)) {
- array_init(return_value);
- add_assoc_long(return_value, "comp_code", comp_code);
- add_assoc_long(return_value, "reason", reason);
+ ZVAL_LONG(z_comp_code, comp_code);
+ ZVAL_LONG(z_reason, reason);
+
+ if (comp_code == MQCC_OK) {
+ ZEND_REGISTER_RESOURCE(z_conn, mqdesc, le_mqseries_conn);
+ mqdesc->id = Z_LVAL_P(z_conn);
+ } else {
+ efree(mqdesc);
+ }
+}
+/* }}} */
+/* {{{ proto mqseries_connx(string name, array connx_opts, resourceref conn, \
resourceref comp_code, resourceref reason ) + The mqseries_connx call is similar to \
the mqseries_conn call, except that mqseries_connx allows options to be specified to \
control the way that the call works. +
+PHP sample:
+ $mqcno = array(
+ 'StrucId' => MQSERIES_MQCNO_STRUC_ID,
+ 'Version' => MQSERIES_MQCNO_VERSION_2,
+ 'Options' => MQSERIES_MQCNO_STANDARD_BINDING,
+ 'MQCD' => array('ChannelName' => 'D800MQ.CLIENT'
+ ,'ConnectionName' => 'localhost'
+ ,'TransportType' => MQSERIES_MQXPT_TCP
+-- SSL configuration with one Authorisation Information Record is also \
posible +-- ,'MQSCO' => array('MQAIR' => array() )
+ )
+ );
+
+ mqseries_connx('D800MQ',
+ &$mqcno,
+ &$conn,
+ &$comp_code,
+ &$reason
+ );
+ if ($comp_code !== MQSERIES_MQCC_OK) {
+ printf("CompCode:%d Reason:%d Text:%s<br>\n", $comp_code, $reason, \
mqseries_strerror($reason)); + exit;
+ }
+
+MQ call:
+ The MQCONNX call is similar to the MQCONN call, except that MQCONNX allows
+ options to be specified to control the way that the call works.
+ MQCONNX ( QMgrName -- input : QManager name
+ , ConnectOpts -- input/output : Connction options
+ , Hconn -- output : Connection Handle
+ , CompCode -- output : completion code
+ , Reason) -- output : reason code
+*/
+PHP_FUNCTION(mqseries_connx)
+{
+ char *name;
+ int name_len;
+ mqseries_descriptor *mqdesc;
+ zval *z_connect_opts, *z_conn, *z_comp_code, *z_reason;
+
+ MQLONG comp_code;
+ MQLONG reason;
+ MQCNO connect_opts = {MQCNO_DEFAULT};
+ MQCD channel_definition = {MQCD_CLIENT_CONN_DEFAULT};
+ MQSCO ssl_configuration = {MQSCO_DEFAULT};
+ MQAIR authentication_information_record = {MQAIR_DEFAULT} ; /* Only 1 (one) record \
is supported for now. */ + MQCHAR LDAPUserName[MQ_DISTINGUISHED_NAME_LENGTH];
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sazzz", &name, &name_len,
+ &z_connect_opts, &z_conn, &z_comp_code, &z_reason)
+ == FAILURE) {
+ return ;
+ }
+
+ if (!is_called_by_ref(z_conn, "conn")) return ;
+ if (!is_compcode_reason_ref(z_comp_code, z_reason)) return;
+
+ set_connect_opts_from_array(z_connect_opts, &connect_opts, &channel_definition, \
&ssl_configuration, &authentication_information_record, LDAPUserName); +
+ mqdesc = emalloc(sizeof(mqseries_descriptor));
+
+ MQCONNX(name, &connect_opts, &mqdesc->conn, &comp_code, &reason);
+
+/*
+ * TODO: what fields can be output for the connect opts?
+ */
+
+ ZVAL_LONG(z_comp_code, comp_code);
+ ZVAL_LONG(z_reason, reason);
+
+ if (comp_code == MQCC_OK) {
+ ZEND_REGISTER_RESOURCE(z_conn, mqdesc, le_mqseries_conn);
+ mqdesc->id = Z_LVAL_P(z_conn);
} else {
- ZEND_REGISTER_RESOURCE(return_value, mqdesc, le_mqseries_conn);
- mqdesc->id = Z_LVAL_P(return_value);
+ efree(mqdesc);
}
}
/* }}} */
-/* {{{ proto ressource mqseries_open(resource mqdesc, array obj_desc, int \
open_options)
- Open a Queue. */
+/* {{{ proto mqseries_open(resource mqdesc, array obj_desc, int open_options, \
resourceref object, resourceref compcode, resourceref reason) + Open a Queue.
+
+
+PHP sample
+ mqseries_open(
+ $conn,
+ array('ObjectName' => 'TESTQ', 'ObjectQMgrName' => 'D800MQ'),
+ MQSERIES_MQOO_INPUT_AS_Q_DEF | MQSERIES_MQOO_FAIL_IF_QUIESCING | \
MQSERIES_MQOO_OUTPUT, + &$obj,
+ &$comp_code,
+ &$reason);
+ if ($comp_code !== MQSERIES_MQCC_OK) {
+ printf("CompCode:%d Reason:%d Text:%s<br>\n", $comp_code, $reason, \
mqseries_strerror($reason)); + exit;
+ }
+
+MQ call:
+ MQOPEN (Hconn, -- input : connection handle
+ ObjDesc, -- input/output : object description
+ Options, -- input : open options
+ Hobj, -- output : object handle
+ CompCode, -- output : completion code
+ Reason) -- output : reason code
+*/
PHP_FUNCTION(mqseries_open)
{
mqseries_descriptor *mqdesc;
mqseries_obj *mqobj;
- zval *z_mqdesc, *z_array, **option_val;
- char *string_key;
- uint string_key_len;
- ulong num_key;
- HashPosition pos;
+ zval *z_mqdesc, *z_obj_desc, *z_obj, *z_comp_code, *z_reason;
- MQOD obj_desc = {MQOD_DEFAULT}; /* Object descriptor */
- MQLONG open_options; /* Options control MQOPEN */
+ MQOD obj_desc = {MQOD_DEFAULT};
+ MQLONG open_options;
+ MQLONG comp_code;
+ MQLONG reason;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ral", &z_mqdesc,
- &z_array, &open_options) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rzlzzz", &z_mqdesc,
+ &z_obj_desc, &open_options, &z_obj, &z_comp_code, &z_reason)
+ == FAILURE) {
return;
}
- ZEND_FETCH_RESOURCE(mqdesc, mqseries_descriptor *, &z_mqdesc, -1, "mqseries_conn", \
le_mqseries_conn);
-
- zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(z_array), &pos);
- while (zend_hash_get_current_data_ex(Z_ARRVAL_P(z_array), (void **)&option_val, \
&pos) == SUCCESS) {
-
- /* Set up the key */
- if (zend_hash_get_current_key_ex(Z_ARRVAL_P(z_array), &string_key, \
&string_key_len, &num_key, 0, &pos) == HASH_KEY_IS_STRING) {
- if (!strcmp(string_key, "ObjectQMgrName")) {
- strncpy(obj_desc.ObjectQMgrName, Z_STRVAL_PP(option_val), MQ_Q_NAME_LENGTH);
- } else if (!strcmp(string_key, "ObjectName")) {
- strncpy(obj_desc.ObjectName, Z_STRVAL_PP(option_val), MQ_Q_NAME_LENGTH);
- } else if (!strcmp(string_key, "DynamicQName")) {
- strncpy(obj_desc.DynamicQName, Z_STRVAL_PP(option_val), MQ_Q_NAME_LENGTH);
- }
- }
+ if (!is_called_by_ref(z_obj, "obj")) return ;
+ if (!is_compcode_reason_ref(z_comp_code, z_reason)) return;
- zend_hash_move_forward_ex(Z_ARRVAL_P(z_array), &pos);
- }
+ ZEND_FETCH_RESOURCE(mqdesc, mqseries_descriptor *, &z_mqdesc, -1, "mqseries_conn", \
le_mqseries_conn); +
+ set_obj_desc_from_array(z_obj_desc, &obj_desc);
mqobj = emalloc(sizeof(mqseries_obj));
- MQOPEN(
- mqdesc->conn,
- &obj_desc,
- open_options,
- &mqobj->obj,
- &mqdesc->comp_code,
- &mqdesc->reason);
+
+ MQOPEN( mqdesc->conn, &obj_desc, open_options, &mqobj->obj, &comp_code, &reason);
- if (mqdesc->comp_code == MQCC_OK) {
+ ZVAL_LONG(z_comp_code, comp_code);
+ ZVAL_LONG(z_reason, reason);
+ if (PZVAL_IS_REF(z_obj_desc)) {
+ set_array_from_obj_desc(z_obj_desc, &obj_desc);
+ }
+ if (comp_code == MQCC_OK) {
mqobj->conn = &mqdesc->conn;
- ZEND_REGISTER_RESOURCE(return_value, mqobj, le_mqseries_obj);
- mqobj->id = Z_LVAL_P(return_value);
+ ZEND_REGISTER_RESOURCE(z_obj, mqobj, le_mqseries_obj);
+ mqobj->id = Z_LVAL_P(z_obj);
} else {
- RETURN_FALSE;
+ /* So we don't register the ref. But we already allocated some memory lets free \
that */ + efree(mqobj);
}
}
/* }}} */
-/* {{{ proto ressource mqseries_get(resource mqdesc, resource mqobj, array msg_desc, \
array get_msg_opts, int buf_len)
- Read data from an opened queue. */
+/* {{{ proto mqseries_get(resource mqdesc, resource mqobj,resourceref msg_desc, \
resourceref get_msg_opts, int buf_len, resourceref buffer, resourceref data_length, \
resourceref comp_code, resourceref reason) + Read data from an opened queue.
+
+
+PHP sample
+
+-- Make default message description the get method will fill this in with defaults.
+$mqmd = array();
+
+$mqgmo = array('Options' => MQSERIES_MQGMO_FAIL_IF_QUIESCING | MQSERIES_MQGMO_WAIT,
+ 'WaitInterval' => MQSERIES_MQWI_UNLIMITED);
+mqseries_get(
+ $conn,
+ $obj,
+ &$mqmd,
+ &$mqmo,
+ 10,
+ &$msg,
+ &$data_length,
+ &$comp_code,
+ &$reason);
+
+if ($comp_code !== MQSERIES_MQCC_OK) {
+ printf("CompCode:%d Reason:%d Text:%s<br>", $comp_code, $reason, \
mqseries_strerror($reason)); +}
+
+
+MQ call:
+ MQGET ( Hconn, -- input
+ Hobj, -- input
+ MsgDesc, -- input/output
+ GetMsgOpts, -- input/output
+ BufferLength, -- input
+ Buffer, -- output
+ DataLength -- output
+ , CompCode -- output : completion code
+ , Reason) -- output : reason code
+
+Note: MQMD - Message Descriptor fields are first set to MQMD_DEFAULT. Before the
+ values of the array are taken.
+*/
PHP_FUNCTION(mqseries_get)
{
mqseries_descriptor *mqdesc;
mqseries_obj *mqobj;
- zval *z_mqdesc, *z_mqobj, *z_msg_desc, *z_get_msg_opts, **option_val;
- char *string_key;
- uint string_key_len;
- ulong num_key;
- HashPosition pos;
-
- MQLONG buf_len, msg_len;
- MQCHAR *buf;
- MQMD msg_desc = { MQMD_DEFAULT }; /* Message descriptor */
+ zval *z_mqdesc, *z_mqobj, *z_msg_desc, *z_get_msg_opts, *z_comp_code, *z_reason, \
*z_data_length, *z_buffer; + MQLONG comp_code;
+ MQLONG reason;
+
+ MQLONG buf_len = 0L, data_length = 0L;
+ MQBYTE *buf, *data;
+ MQMD msg_desc = { MQMD_DEFAULT }; /* Message descriptor */
MQGMO get_msg_opts = { MQGMO_DEFAULT }; /* Options which control the MQGET call */
+ MQRFH rfh = {MQRFH_DEFAULT};
+ MQRFH2 rfh2 = {MQRFH2_DEFAULT};
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rraal", &z_mqdesc, &z_mqobj,
- &z_msg_desc, &z_get_msg_opts, &buf_len)
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrzzlzzzz",&z_mqdesc, \
&z_mqobj, + &z_msg_desc, &z_get_msg_opts, &buf_len, &z_buffer, \
&z_data_length,&z_comp_code, &z_reason) == FAILURE) {
return;
}
+
+ if (!is_called_by_ref(z_data_length, "datalength")) return ;
+ if (!is_called_by_ref(z_buffer, "buffer")) return ;
+ if (!is_compcode_reason_ref(z_comp_code, z_reason)) return;
+
ZEND_FETCH_RESOURCE(mqdesc, mqseries_descriptor *, &z_mqdesc, -1, "mqseries_conn", \
le_mqseries_conn); ZEND_FETCH_RESOURCE(mqobj, mqseries_obj *, &z_mqobj, -1, \
"mqseries_obj", le_mqseries_obj);
- set_msg_desc_from_array(z_msg_desc, &msg_desc);
+ set_msg_desc_from_array(z_msg_desc, &msg_desc, MQMD_GET);
+ set_get_msg_opts_from_array(z_get_msg_opts, &get_msg_opts);
- zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(z_get_msg_opts), &pos);
- while (zend_hash_get_current_data_ex(Z_ARRVAL_P(z_get_msg_opts), (void \
**)&option_val, &pos) == SUCCESS) { + data = buf = (MQBYTE \
*)emalloc(sizeof(MQBYTE)*buf_len); + MQGET(mqdesc->conn, mqobj->obj, &msg_desc, \
&get_msg_opts, buf_len, buf, &data_length, &comp_code, &reason);
- if (zend_hash_get_current_key_ex(Z_ARRVAL_P(z_get_msg_opts), &string_key, \
&string_key_len, &num_key, 0, &pos) == HASH_KEY_IS_STRING) {
- if (!strcmp(string_key, "Options")) {
- get_msg_opts.Options = Z_LVAL_PP(option_val);
- } else if (!strcmp(string_key, "WaitInterval") > 0) {
- get_msg_opts.WaitInterval = Z_LVAL_PP(option_val);
- }
- }
+/*
+ * TODO: add these Rules and formatting header as an resource to the PHP environment
+ * There is no other way I can think of to get this to the user.
+ * TODO: Other formatting headers, if there are any
+ */
+ if (!strncmp(msg_desc.Format, MQFMT_RF_HEADER, sizeof(msg_desc.Format))) {
+ memcpy(&rfh, buf, MQRFH_STRUC_LENGTH_FIXED);
+ data = buf + rfh.StrucLength;
+ } else if (!strncmp(msg_desc.Format, MQFMT_RF_HEADER_2, sizeof(msg_desc.Format))) {
+ memcpy(&rfh2, buf, MQRFH_STRUC_LENGTH_FIXED_2);
+ data = buf + rfh2.StrucLength;
+ }
+
+ ZVAL_LONG(z_comp_code, comp_code);
+ ZVAL_LONG(z_reason, reason);
+ ZVAL_LONG(z_data_length, data_length);
+ ZVAL_STRINGL(z_buffer, data, data_length, 1);
+ efree(buf);
- zend_hash_move_forward_ex(Z_ARRVAL_P(z_get_msg_opts), &pos);
+ if (PZVAL_IS_REF(z_msg_desc)) {
+ set_array_from_msg_desc(z_msg_desc, &msg_desc);
}
-
- buf = (MQCHAR *)emalloc(buf_len);
- MQGET(
- mqdesc->conn,
- mqobj->obj,
- &msg_desc,
- &get_msg_opts,
- buf_len,
- buf,
- &msg_len,
- &mqdesc->comp_code,
- &mqdesc->reason);
-
- if (mqdesc->comp_code == MQCC_OK) {
- RETVAL_STRINGL(buf, msg_len, 1);
- efree(buf);
- } else {
- efree(buf);
- RETURN_FALSE;
+ if (PZVAL_IS_REF(z_get_msg_opts)) {
+ set_array_from_get_msg_opts(z_get_msg_opts, &get_msg_opts);
}
+
}
/* }}} */
-/* {{{ proto ressource mqseries_put(resource mqdesc, resource mqobj, array msg_desc, \
array put_msg_opts, string msg)
- Write message into the queue. */
+/* {{{ proto mqseries_put(resource mqdesc, resource mqobj, array msg_desc, array \
put_msg_opts, string msg) + The MQPUT call puts a message on a queue or distribution \
list. The queue or distribution list must already be open. +
+
+PHP sample:
+$md = array(
+ 'StrucId' => MQSERIES_MQMD_STRUC_ID,
+ 'Version' => MQSERIES_MQMD_VERSION_1,
+ 'Expiry' => MQSERIES_MQEI_UNLIMITED,
+ 'Report' => MQSERIES_MQRO_NONE,
+ 'MsgType' => MQSERIES_MQMT_DATAGRAM,
+ 'Format' => MQSERIES_MQFMT_STRING,
+ 'Priority' => 1,
+ 'Persistence' => MQSERIES_MQPER_PERSISTENT,
+ 'ReplyToQ' => 'RCVQ');
+mqseries_put($conn,
+ $obj_snd,
+ &$md,
+ array('Options' => MQSERIES_MQPMO_NEW_MSG_ID),
+ 'Ping',
+ &$comp_code,
+ &$reason);
+
+if ($comp_code !== MQSERIES_MQCC_OK) {
+ printf("CompCode:%d Reason:%d Text:%s<br>\n", $comp_code, $reason, \
mqseries_strerror($reason)); +}
+
+
+MQ call:
+
+ MQPUT (
+ Hconn,
+ Hobj,
+ MsgDesc,
+ PutMsgOpts,
+ BufferLength,
+ Buffer
+ , CompCode -- output : completion code
+ , Reason) -- output : reason code
+
+Note: MQMD - Message Descriptor fields are first set to MQMD_DEFAULT. Before the
+ values of the array are taken.
+
+*/
PHP_FUNCTION(mqseries_put)
{
mqseries_descriptor *mqdesc;
mqseries_obj *mqobj;
- zval *z_mqdesc, *z_mqobj, *z_msg_desc, *z_put_msg_opts, **option_val;
- char *string_key, *msg;
- uint string_key_len;
- ulong num_key;
- HashPosition pos;
-
+ zval *z_mqdesc, *z_mqobj, *z_msg_desc, *z_put_msg_opts, *z_comp_code, *z_reason;
+ char *msg;
MQLONG msg_len;
- MQMD msg_desc; /* Message descriptor */
- MQPMO put_msg_opts; /* Options which control the MQPUT call */
+ MQMD msg_desc = {MQMD_DEFAULT}; /* Message descriptor */
+ MQPMO put_msg_opts = {MQPMO_DEFAULT}; /* Options which control the MQPUT call */
+ MQLONG comp_code;
+ MQLONG reason;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rraas", &z_mqdesc, &z_mqobj,
- &z_msg_desc, &z_put_msg_opts, &msg, &msg_len)
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrzzszz", &z_mqdesc, \
&z_mqobj, + &z_msg_desc, &z_put_msg_opts, &msg, &msg_len, &z_comp_code, &z_reason)
== FAILURE) {
return;
}
+ if (!is_compcode_reason_ref(z_comp_code, z_reason)) return;
+
ZEND_FETCH_RESOURCE(mqdesc, mqseries_descriptor *, &z_mqdesc, -1, "mqseries_conn", \
le_mqseries_conn); ZEND_FETCH_RESOURCE(mqobj, mqseries_obj *, &z_mqobj, -1, \
"mqseries_obj", le_mqseries_obj);
- memset(&msg_desc, '\0', sizeof(msg_desc));
- set_msg_desc_from_array(z_msg_desc, &msg_desc);
-
- memset(&put_msg_opts, '\0', sizeof(put_msg_opts));
- zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(z_put_msg_opts), &pos);
- while (zend_hash_get_current_data_ex(Z_ARRVAL_P(z_put_msg_opts), (void \
**)&option_val, &pos) == SUCCESS) {
-
- if (zend_hash_get_current_key_ex(Z_ARRVAL_P(z_put_msg_opts), &string_key, \
&string_key_len, &num_key, 0, &pos) == HASH_KEY_IS_STRING) {
- if (!strcmp(string_key, "Options")) {
- put_msg_opts.Options = Z_LVAL_PP(option_val);
- } else if (!strcmp(string_key, "Version")) {
- put_msg_opts.Version = Z_LVAL_PP(option_val);
- } else if (!strcmp(string_key, "StrucId")) {
- strncpy(put_msg_opts.StrucId, Z_STRVAL_PP(option_val), \
sizeof(put_msg_opts.StrucId));
- }
- }
+ set_msg_desc_from_array(z_msg_desc, &msg_desc,MQMD_PUT );
+ set_put_msg_opts_from_array(z_put_msg_opts, &put_msg_opts);
- zend_hash_move_forward_ex(Z_ARRVAL_P(z_put_msg_opts), &pos);
- }
+ MQPUT(mqdesc->conn, mqobj->obj, &msg_desc, &put_msg_opts, msg_len, msg, \
&comp_code, &reason);
- MQPUT(
- mqdesc->conn,
- mqobj->obj,
- &msg_desc,
- &put_msg_opts,
- msg_len,
- msg,
- &mqdesc->comp_code,
- &mqdesc->reason);
+ ZVAL_LONG(z_comp_code, comp_code);
+ ZVAL_LONG(z_reason, reason);
+ if (PZVAL_IS_REF(z_msg_desc)) {
+ set_array_from_msg_desc(z_msg_desc, &msg_desc);
+ }
+ if (PZVAL_IS_REF(z_put_msg_opts)) {
+ set_array_from_put_msg_opts(z_put_msg_opts, &put_msg_opts);
+ }
- if (mqdesc->comp_code == MQCC_OK) {
- RETURN_TRUE;
- } else {
- RETURN_FALSE;
- }
}
/* }}} */
-/* {{{ proto ressource mqseries_begin(resource mqdesc, array begin_opts)
- Begin a transaction. */
+/* {{{ proto mqseries_begin(resource mqdesc, array begin_opts)
+ The MQBEGIN call begins a unit of work that is coordinated by the queue manager, \
and that may involve external resource managers. +
+
+PHP sample:
+
+ mqseries_begin($conn,
+ array("Options" -> MQSERIES_MQBO_NONE),
+ &$comp_code,
+ &$reason)
+
+MQ call:
+ MQBEGIN (Hconn -- input : Connection handle
+ , BeginOptions -- input : MQBO begin options
+ , CompCode -- output : completion code
+ , Reason) -- output : reason code
+*/
PHP_FUNCTION(mqseries_begin)
{
mqseries_descriptor *mqdesc;
- zval *z_mqdesc, *z_array, **option_val, *key;
+ zval *z_mqdesc, *z_array, **option_val, *key, *z_comp_code, *z_reason;
char *string_key;
uint string_key_len;
ulong num_key;
HashPosition pos;
+ MQLONG comp_code;
+ MQLONG reason;
MQBO begin_opts = {MQBO_DEFAULT};
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ra", &z_mqdesc,
- &z_array) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "razz", &z_mqdesc,
+ &z_array, &z_comp_code, &z_reason) == FAILURE) {
return;
}
+
+ if (!is_compcode_reason_ref(z_comp_code, z_reason)) return;
ZEND_FETCH_RESOURCE(mqdesc, mqseries_descriptor *, &z_mqdesc, -1, "mqseries_conn", \
le_mqseries_conn);
@@ -379,11 +619,9 @@
MAKE_STD_ZVAL(key);
if (zend_hash_get_current_key_ex(Z_ARRVAL_P(z_array), &string_key, \
&string_key_len, &num_key, 0, &pos) == HASH_KEY_IS_STRING) {
- if (strcmp(string_key, "StrucId") > 0) {
- strncpy(begin_opts.StrucId, Z_STRVAL_PP(option_val), \
sizeof(begin_opts.StrucId));
- } else if (strcmp(string_key, "Version") > 0) {
+ if (!strcmp(string_key, "Version")) {
begin_opts.Version = Z_LVAL_PP(option_val);
- } else if (strcmp(string_key, "Options") > 0) {
+ } else if (!strcmp(string_key, "Options")) {
begin_opts.Options = Z_LVAL_PP(option_val);
}
}
@@ -392,129 +630,269 @@
zend_hash_move_forward_ex(Z_ARRVAL_P(z_array), &pos);
}
- MQBEGIN(
- mqdesc->conn,
- &begin_opts,
- &mqdesc->comp_code,
- &mqdesc->reason);
-
- if (mqdesc->comp_code == MQCC_OK) {
- RETURN_TRUE;
- } else {
- RETURN_FALSE;
- }
+ MQBEGIN(mqdesc->conn, &begin_opts, &comp_code, &reason);
+
+ ZVAL_LONG(z_comp_code, comp_code);
+ ZVAL_LONG(z_reason, reason);
}
/* }}} */
-/* {{{ proto ressource mqseries_cmit(resource mqdesc)
- Commit the transaction. */
+/* {{{ proto mqseries_cmit(resource mqdesc)
+ The MQCMIT call indicates to the queue manager that the application has reached
+ a syncpoint, and that all of the message gets and puts that have occurred
+ since the last syncpoint are to be made permanent. Messages put as part of
+ a unit of work are made available to other applications; messages retrieved
+ as part of a unit of work are deleted.
+
+PHP sample:
+ mqseries_cmit($conn,
+ &$comp_code,
+ &$reason);
+
+MQ call:
+
+ MQCMIT (Hconn -- input : Connection handle
+ , CompCode -- output : completion code
+ , Reason) -- output : reason code
+
+*/
PHP_FUNCTION(mqseries_cmit)
{
+ MQLONG comp_code;
+ MQLONG reason;
+
mqseries_descriptor *mqdesc;
- zval *z_mqdesc;
+ zval *z_mqdesc, *z_comp_code, *z_reason;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_mqdesc)
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rzz", &z_mqdesc, \
&z_comp_code, &z_reason) == FAILURE) {
return;
}
+ if (!is_compcode_reason_ref(z_comp_code, z_reason)) return;
+
ZEND_FETCH_RESOURCE(mqdesc, mqseries_descriptor *, &z_mqdesc, -1, "mqseries_conn", \
le_mqseries_conn);
- MQCMIT(
- mqdesc->conn,
- &mqdesc->comp_code,
- &mqdesc->reason);
+ MQCMIT(mqdesc->conn, &comp_code, &reason);
+
+ ZVAL_LONG(z_comp_code, comp_code);
+ ZVAL_LONG(z_reason, reason);
- if (mqdesc->comp_code == MQCC_OK) {
- RETURN_TRUE;
- } else {
- RETURN_FALSE;
- }
}
/* }}} */
-/* {{{ proto ressource mqseries_back(resource mqdesc)
- Rollback the transaction. */
+/* {{{ proto mqseries_back(resource mqdesc)
+ The MQBACK call indicates to the queue manager that all the message gets and
+ puts that have occurred since the last syncpoint are to be backed out.
+ Messages put as part of a unit of work are deleted; messages retrieved as
+ part of a unit of work are reinstated on the queue.
+
+PHP sample:
+
+MQ call:
+
+ MQBACK (Hconn -- input : Connection handle
+ , CompCode -- output : completion code
+ , Reason) -- output : reason code
+*/
PHP_FUNCTION(mqseries_back)
{
+ MQLONG comp_code;
+ MQLONG reason;
+
mqseries_descriptor *mqdesc;
- zval *z_mqdesc;
+ zval *z_mqdesc, *z_comp_code, *z_reason;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_mqdesc)
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rzz", &z_mqdesc, \
&z_comp_code, &z_reason) == FAILURE) {
return;
}
+ if (!is_compcode_reason_ref(z_comp_code, z_reason)) return;
+
ZEND_FETCH_RESOURCE(mqdesc, mqseries_descriptor *, &z_mqdesc, -1, "mqseries_conn", \
le_mqseries_conn);
- MQBACK(
- mqdesc->conn,
- &mqdesc->comp_code,
- &mqdesc->reason);
+ MQBACK(mqdesc->conn, &comp_code, &reason);
+
+ ZVAL_LONG(z_comp_code, comp_code);
+ ZVAL_LONG(z_reason, reason);
- if (mqdesc->comp_code == MQCC_OK) {
- RETVAL_TRUE;
- } else {
- RETURN_FALSE;
- }
}
/* }}} */
-/* {{{ proto bool mqseries_close(mqobj)
- Close a queue. */
+/* {{{ proto mqseries_close(resoure mqobj, resource compcode, resource reason)
+ The MQCLOSE call relinquishes access to an object,
+ and is the inverse of the MQOPEN call.
+
+Note the way it now works is that an internal delete of the resources is done
+this will dan trigger the php delete mechanism
+
+PHP sample:
+ mqseries_clode($obj);
+
+MQ call:
+ MQCLOSE (Hconn,
+ Hobj,
+ Options,
+ , CompCode -- output : completion code
+ , Reason) -- output : reason code
+
+*/
PHP_FUNCTION(mqseries_close)
{
+ MQLONG comp_code;
+ MQLONG reason;
+ MQLONG close_options;
+
mqseries_obj *mqobj;
- zval *z_mqobj;
+ mqseries_descriptor *mqdesc;
+ zval *z_mqdesc, *z_mqobj, *z_comp_code, *z_reason;
+
+ zend_output_debug_string(1, "%s", "MQClose - start");
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_mqobj) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrlzz", &z_mqdesc, &z_mqobj, \
&close_options, &z_comp_code, &z_reason) == FAILURE) { + zend_output_debug_string(1, \
"%s", "MQClose - parse error"); + return;
+ }
+ if (!is_compcode_reason_ref(z_comp_code, z_reason)) {
+ zend_output_debug_string(1, "%s", "MQClose - call by ref error");
return;
}
+ ZEND_FETCH_RESOURCE(mqdesc, mqseries_descriptor *, &z_mqdesc, -1, "mqseries_conn", \
le_mqseries_conn); ZEND_FETCH_RESOURCE(mqobj, mqseries_obj *, &z_mqobj, -1, \
"mqseries_obj", le_mqseries_obj); +
+ MQCLOSE(mqdesc->conn,
+ &mqobj->obj,
+ close_options,
+ &comp_code,
+ &reason);
+
+
+ ZVAL_LONG(z_comp_code, comp_code);
+ ZVAL_LONG(z_reason, reason);
+
zend_list_delete(mqobj->id);
- RETURN_TRUE;
+ zend_output_debug_string(1, "%s", "MQClose - end");
+
}
/* }}} */
-/* {{{ proto bool mqseries_disc(mqdesc)
- Disconnect from the queue manager. */
+/* {{{ proto static void _mqseries_close() */
+static void _mqseries_close(zend_rsrc_list_entry *rsrc TSRMLS_DC)
+{
+ MQLONG comp_code; /* Completion code */
+ MQLONG reason; /* Qualifying reason */
+ mqseries_obj *mqobj = (mqseries_obj *)rsrc->ptr;
+
+ if (mqobj->obj != MQHO_UNUSABLE_HOBJ) { /* Already closed */
+ if (*mqobj->conn != MQHC_UNUSABLE_HCONN) { /* Already disconeccted */
+ /* Should not be posible but just in case */
+ MQCLOSE(*mqobj->conn,
+ &mqobj->obj,
+ MQCO_NONE,
+ &comp_code,
+ &reason);
+
+ if ((comp_code != MQCC_OK) || (reason != MQRC_NONE && reason)) {
+ switch(reason) {
+ case MQRC_CONNECTION_BROKEN:
+ case MQRC_HCONN_ERROR:
+ break;
+
+ default:
+ zend_error(E_WARNING, "_mqseries_close Error %d %d\n", comp_code, reason);
+ }
+ }
+ }
+ }
+
+ efree(mqobj);
+}
+/* }}} */
+
+/* {{{ proto mqseries_disc(resource mqdesc, resource comp_code , resource reason)
+ The MQDISC call breaks the connection between the queue manager and the
+ application program, and is the inverse of the MQCONN or MQCONNX call.
+
+PHP sample:
+
+mqseries_disc($conn, &$comp_code, &$reason);
+if ($comp_code !== MQSERIES_MQCC_OK) {
+ printf("CompCode:%d Reason:%d Text:%s<br>\n", $comp_code, $reason, \
mqseries_strerror($reason)); +}
+
+MQ call:
+ MQDISC (Hconn
+ , CompCode -- output : completion code
+ , Reason) -- output : reason code
+
+*/
PHP_FUNCTION(mqseries_disc)
{
+ MQLONG comp_code; /* Completion code */
+ MQLONG reason; /* Qualifying reason */
+ zend_output_debug_string(1, "%s", "MQDisc - start");
+
mqseries_descriptor *mqdesc;
- zval *z_mqdesc;
+ zval *z_mqdesc, *z_comp_code, *z_reason;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_mqdesc) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rzz", &z_mqdesc, \
&z_comp_code, &z_reason) == FAILURE) { return;
}
+ if (!is_compcode_reason_ref(z_comp_code, z_reason)) return;
ZEND_FETCH_RESOURCE(mqdesc, mqseries_descriptor *, &z_mqdesc, -1, "mqseries_conn", \
le_mqseries_conn); +
+ MQDISC(
+ &mqdesc->conn,
+ &comp_code,
+ &reason);
+
+
+ ZVAL_LONG(z_comp_code, comp_code);
+ ZVAL_LONG(z_reason, reason);
+
zend_list_delete(mqdesc->id);
- RETURN_TRUE;
+ zend_output_debug_string(1, "%s", "MQDisc - end");
+
}
/* }}} */
-/* {{{ proto bool mqseries_error(mqdesc)
- Return the completion-code and the reason from the last call. */
-PHP_FUNCTION(mqseries_error)
+/* {{{ proto static void _mqseries_disc() */
+static void _mqseries_disc(zend_rsrc_list_entry *rsrc TSRMLS_DC)
{
- mqseries_descriptor *mqdesc;
- zval *z_mqdesc;
+ MQLONG comp_code; /* Completion code */
+ MQLONG reason; /* Qualifying reason */
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_mqdesc) == FAILURE) {
- return;
- }
+ mqseries_descriptor *mqdesc = (mqseries_descriptor *)rsrc->ptr;
- ZEND_FETCH_RESOURCE(mqdesc, mqseries_descriptor *, &z_mqdesc, -1, "mqseries_conn", \
le_mqseries_conn); + if (mqdesc->conn != MQHC_UNUSABLE_HCONN) {
+ MQDISC(
+ &mqdesc->conn,
+ &comp_code,
+ &reason);
+
+ if ((comp_code != MQCC_OK) || (reason != MQRC_NONE)) {
+ switch(reason) {
+ case MQRC_CONNECTION_BROKEN:
+ case MQRC_HCONN_ERROR:
+ break;
+
+ default:
+ zend_error(E_WARNING, "_mqseries_disc Error %d %d\n", comp_code, reason);
+ }
+ }
+ }
- array_init(return_value);
- add_assoc_long(return_value, "comp_code", mqdesc->comp_code);
- add_assoc_long(return_value, "reason", mqdesc->reason);
+ efree(mqdesc);
}
/* }}} */
/* {{{ proto bool mqseries_strerror(reason_code)
- Return the detailed error text for the given reason_code. */
+ Return the detailed error text for the given reason_code.
+
+ */
PHP_FUNCTION(mqseries_strerror)
{
zval **text;
@@ -535,27 +913,636 @@
}
/* }}} */
-/* {{{ proto static void set_msg_desc_from_array()
- Put options from the given array into the MQMD structure. */
-static void set_msg_desc_from_array(zval *array, MQMD *msg_desc)
+/* {{{ proto mqseries_put1(resource mqdesc, array obj_desc, array msg_desc, array \
put_msg_opts, string msg) + The MQPUT1 call puts one message on a queue. The queue \
need not be open. +
+MQ call:
+ MQPUT1 (
+ Hconn,
+ ObjDesc,
+ MsgDesc,
+ PutMsgOpts,
+ BufferLength,
+ Buffer,
+ CompCode,
+ Reason)
+
+Note: MQMD - Message Descriptor fields are first set to MQMD_DEFAULT. Before the
+ values of the array are taken.
+
+*/
+PHP_FUNCTION(mqseries_put1)
+{
+ mqseries_descriptor *mqdesc;
+ zval *z_mqdesc, *z_msg_desc, *z_put_msg_opts, *z_obj_desc, *z_comp_code, *z_reason;
+ char *msg;
+ MQLONG msg_len;
+ MQMD msg_desc = {MQMD_DEFAULT}; /* Message descriptor */
+ MQOD obj_desc = {MQOD_DEFAULT}; /* Object descriptor */
+ MQPMO put_msg_opts = {MQPMO_DEFAULT}; /* Options which control the MQPUT call */
+ MQLONG comp_code;
+ MQLONG reason;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rzzzszz",
+ &z_mqdesc, &z_obj_desc, &z_msg_desc, &z_put_msg_opts, &msg, &msg_len, \
&z_comp_code, &z_reason) + == FAILURE) {
+ return;
+ }
+
+ if (!is_compcode_reason_ref(z_comp_code, z_reason)) return;
+
+ ZEND_FETCH_RESOURCE(mqdesc, mqseries_descriptor *, &z_mqdesc, -1, "mqseries_conn", \
le_mqseries_conn); +
+ set_obj_desc_from_array(z_obj_desc, &obj_desc);
+ set_msg_desc_from_array(z_msg_desc, &msg_desc, MQMD_PUT);
+ set_put_msg_opts_from_array(z_put_msg_opts, &put_msg_opts);
+
+ MQPUT1(mqdesc->conn, &obj_desc, &msg_desc, &put_msg_opts, msg_len, msg, &comp_code, \
&reason); +
+ ZVAL_LONG(z_comp_code, comp_code);
+ ZVAL_LONG(z_reason, reason);
+
+ if (PZVAL_IS_REF(z_obj_desc)) {
+ set_array_from_obj_desc(z_obj_desc, &obj_desc);
+ }
+ if (PZVAL_IS_REF(z_msg_desc)) {
+ set_array_from_msg_desc(z_msg_desc, &msg_desc);
+ }
+ if (PZVAL_IS_REF(z_put_msg_opts)) {
+ set_array_from_put_msg_opts(z_put_msg_opts, &put_msg_opts);
+ }
+
+
+}
+/* }}} */
+
+/* {{{ proto mqseries_inq(resource mqdesc, resource mqobj, int selectorCount, array \
selectors, int intAttrCount, int charAttrLength) + The MQINQ call returns an array of \
integers and a set of character strings containing the attributes of an object. +
+ The following types of object are valid:
+ - Queue
+ - Namelist
+ - Process definition
+ - Queue manager
+ MQINQ (Hconn, Hobj, SelectorCount, Selectors, IntAttrCount, IntAttrs, \
CharAttrLength, CharAttrs, CompCode, Reason) +*/
+PHP_FUNCTION(mqseries_inq)
+{
+ mqseries_descriptor *mqdesc;
+ mqseries_obj *mqobj;
+ zval *z_mqdesc, *z_mqobj, *z_selectors, **option_val, *z_intAttrs, *z_charAttrs, \
*z_comp_code, *z_reason; + HashPosition pos;
+ MQLONG current=0, selectorCount, *selectors, intAttrLength, i, charAttrLength;
+ MQCHAR *charAttrs = NULL;
+ MQLONG *intAttrs = NULL;
+ MQLONG comp_code;
+ MQLONG reason;
+
+
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrlalzlzzz",
+ &z_mqdesc,
+ &z_mqobj,
+ &selectorCount,
+ &z_selectors,
+ &intAttrLength,
+ &z_intAttrs,
+ &charAttrLength,
+ &z_charAttrs,
+ &z_comp_code,
+ &z_reason) == FAILURE) {
+ return;
+ }
+
+ if (!is_compcode_reason_ref(z_comp_code, z_reason)) return;
+ if (!is_called_by_ref(z_intAttrs, "intAttrs")) return;
+ if (!is_called_by_ref(z_charAttrs, "charAttrs")) return;
+
+ ZEND_FETCH_RESOURCE(mqdesc, mqseries_descriptor *, &z_mqdesc, -1, "mqseries_conn", \
le_mqseries_conn); + ZEND_FETCH_RESOURCE(mqobj, mqseries_obj *, &z_mqobj, -1, \
"mqseries_obj", le_mqseries_obj); +
+ selectors = (MQLONG *)emalloc(selectorCount * sizeof(MQLONG));
+
+ zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(z_selectors), &pos);
+ while (zend_hash_get_current_data_ex(Z_ARRVAL_P(z_selectors), (void **)&option_val, \
&pos) == SUCCESS) { + if (current < selectorCount) {
+ selectors[current++] = Z_LVAL_PP(option_val);
+ }
+ zend_hash_move_forward_ex(Z_ARRVAL_P(z_selectors), &pos);
+ }
+
+
+ if (charAttrLength > 0) { /* Are charAttr requested */
+ charAttrs = (MQCHAR *)emalloc(charAttrLength+1);
+ }
+ if (intAttrLength > 0) { /* Are intAttr requested */
+ intAttrs = (MQLONG *)emalloc(intAttrLength+sizeof(MQLONG));
+ }
+
+ MQINQ(
+ mqdesc->conn,
+ mqobj->obj,
+ selectorCount,
+ selectors,
+ intAttrLength,
+ intAttrs,
+ charAttrLength,
+ charAttrs,
+ &comp_code,
+ &reason);
+
+ ZVAL_LONG(z_comp_code, comp_code);
+ ZVAL_LONG(z_reason, reason);
+
+ if (comp_code == MQCC_OK) {
+ if (charAttrLength > 0) { /* set only when charAttrs where requested */
+ ZVAL_STRING(z_charAttrs, charAttrs, strlen(charAttrs));
+ }
+ if (intAttrLength > 0) { /* set only when intAttrs where requested */
+ /* create an indexed array of long values */
+ for (i = 0; i < intAttrLength; i++) {
+ add_index_long(z_intAttrs, i, intAttrs[i]);
+ }
+ }
+ }
+
+ if (charAttrLength > 0) { /* set only when charAttrs where requested */
+ efree(charAttrs);
+ }
+ if (intAttrLength > 0) { /* set only when charAttrs where requested */
+ efree(intAttrs);
+ }
+ efree(selectors);
+
+}
+/* }}} */
+
+/* {{{ proto resource mqseries_set(tbd)
+ The MQSET call is used to change the attributes of an object represented by a \
handle. The object must be a queue. +
+ MQSET (Hconn, Hobj, SelectorCount, Selectors, IntAttrCount, IntAttrs, \
CharAttrLength, CharAttrs, CompCode, Reason) +*/
+PHP_FUNCTION(mqseries_set)
+{
+ mqseries_descriptor *mqdesc;
+ mqseries_obj *mqobj;
+ zval *z_mqdesc, *z_mqobj, *z_selectors, **option_val, *z_intAttrs, *z_charAttrs, \
*z_comp_code, *z_reason; + HashPosition pos;
+ MQLONG current=0, selectorCount, *selectors, intAttrLength, i, charAttrLength;
+ MQCHAR *charAttrs = NULL;
+ MQLONG *intAttrs = NULL;
+ MQLONG comp_code;
+ MQLONG reason;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrlalalazz",
+ &z_mqdesc,
+ &z_mqobj,
+ &selectorCount,
+ &z_selectors,
+ &intAttrLength,
+ &z_intAttrs,
+ &charAttrLength,
+ &z_charAttrs,
+ &z_comp_code,
+ &z_reason) == FAILURE) {
+ return;
+ }
+
+ if (!is_compcode_reason_ref(z_comp_code, z_reason)) return;
+
+ ZEND_FETCH_RESOURCE(mqdesc, mqseries_descriptor *, &z_mqdesc, -1, "mqseries_conn", \
le_mqseries_conn); + ZEND_FETCH_RESOURCE(mqobj, mqseries_obj *, &z_mqobj, -1, \
"mqseries_obj", le_mqseries_obj); +
+ selectors = (MQLONG *)emalloc(selectorCount * sizeof(MQLONG));
+
+ zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(z_selectors), &pos);
+ current = 0;
+ while (zend_hash_get_current_data_ex(Z_ARRVAL_P(z_selectors), (void **)&option_val, \
&pos) == SUCCESS) { + if (current < selectorCount) {
+ selectors[current++] = Z_LVAL_PP(option_val);
+ }
+ zend_hash_move_forward_ex(Z_ARRVAL_P(z_selectors), &pos);
+ }
+
+ if (intAttrLength > 0) { /* Are intAttr requested */
+ intAttrs = (MQLONG *)emalloc(intAttrLength+sizeof(MQLONG));
+ current = 0;
+ zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(z_intAttrs), &pos);
+ while (zend_hash_get_current_data_ex(Z_ARRVAL_P(z_intAttrs), (void **)&option_val, \
&pos) == SUCCESS) { + if (current < intAttrLength) {
+ intAttrs[current++] = Z_LVAL_PP(option_val);
+ }
+ zend_hash_move_forward_ex(Z_ARRVAL_P(z_intAttrs), &pos);
+ }
+ }
+
+
+ if (charAttrLength > 0) { /* Are charAttr requested */
+ charAttrs = (MQCHAR *)emalloc(charAttrLength+1);
+ current = 0;
+ zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(z_charAttrs), &pos);
+ while (zend_hash_get_current_data_ex(Z_ARRVAL_P(z_charAttrs), (void \
**)&option_val, &pos) == SUCCESS) { + if (current < charAttrLength) {
+ charAttrs[current++] = Z_LVAL_PP(option_val); /* hoe helen we char uit een \
array? */ + }
+ zend_hash_move_forward_ex(Z_ARRVAL_P(z_charAttrs), &pos);
+ }
+ }
+
+ MQSET(
+ mqdesc->conn,
+ mqobj->obj,
+ selectorCount,
+ selectors,
+ intAttrLength,
+ intAttrs,
+ charAttrLength,
+ charAttrs,
+ &comp_code,
+ &reason);
+
+
+ ZVAL_LONG(z_comp_code, comp_code);
+ ZVAL_LONG(z_reason, reason);
+
+
+ if (charAttrLength > 0) { /* set only when charAttrs where requested */
+ efree(charAttrs);
+ }
+ if (intAttrLength > 0) { /* set only when charAttrs where requested */
+ efree(intAttrs);
+ }
+ efree(selectors);
+
+}
+/* }}} */
+
+/******************************************************************************/
+/* Following are methods to make structs from arrays and vice verse */
+/* TODO Check if all fields are specified (hopefully the MQ API will not */
+/* change verry soon as we have to do this all over again). 'zucht'. */
+/* TODO These if else contructs, we should do better */
+/******************************************************************************/
+/* {{{ proto static set_authentication_information_record_from_array
+ * set authenication information from an array
+ */
+static void set_authentication_information_record_from_array(zval *array,
+ PMQAIR authentication_information_record,
+ PMQCHAR LDAPUserName)
+{
+ zval **option_val;
+ char *string_key;
+ uint string_key_len;
+ ulong num_key;
+ HashPosition pos;
+
+ zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(array), &pos);
+ while (zend_hash_get_current_data_ex(Z_ARRVAL_P(array), (void **)&option_val, &pos) \
== SUCCESS) { + if (zend_hash_get_current_key_ex(Z_ARRVAL_P(array), &string_key, \
&string_key_len, &num_key, 0, &pos) == HASH_KEY_IS_STRING) { + if \
(!strcmp(string_key, "Version")) { + authentication_information_record->Version = \
Z_LVAL_PP(option_val); + } else if (!strcmp(string_key, "AuthInfoType")) {
+ authentication_information_record->AuthInfoType = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "AuthInfoConnName")) {
+ strncpy(authentication_information_record->AuthInfoConnName, \
Z_STRVAL_PP(option_val), \
sizeof(authentication_information_record->AuthInfoConnName)); + } else if \
(!strcmp(string_key, "LDAPPassword")) { \
+ strncpy(authentication_information_record->LDAPPassword, \
Z_STRVAL_PP(option_val), sizeof(authentication_information_record->LDAPPassword)); \
+ } else if (!strcmp(string_key, "LDAPUserName")) { + strncpy(LDAPUserName, \
Z_STRVAL_PP(option_val), sizeof(LDAPUserName)); \
+ authentication_information_record->LDAPUserNamePtr = LDAPUserName; \
+ authentication_information_record->LDAPUserNameLength = strlen(LDAPUserName); \
+ } + }
+ zend_hash_move_forward_ex(Z_ARRVAL_P(array), &pos);
+ }
+}
+/* }}} */
+
+/* {{{ proto static set_ssl_configuration_from_array
+ * sets the ssl configuration from an array
+ */
+static void set_ssl_configuration_from_array(zval *array,
+ PMQSCO ssl_configuration,
+ PMQAIR authentication_information_record,
+ PMQCHAR LDAPUserName)
{
zval **option_val;
char *string_key;
uint string_key_len;
ulong num_key;
HashPosition pos;
+
+ zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(array), &pos);
+ while (zend_hash_get_current_data_ex(Z_ARRVAL_P(array), (void **)&option_val, &pos) \
== SUCCESS) { +
+ if (zend_hash_get_current_key_ex(Z_ARRVAL_P(array), &string_key, &string_key_len, \
&num_key, 0, &pos) == HASH_KEY_IS_STRING) { + if (!strcmp(string_key, "Version")) {
+ ssl_configuration->Version = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "KeyRepository")) {
+ strncpy(ssl_configuration->KeyRepository, Z_STRVAL_PP(option_val), \
sizeof(ssl_configuration->KeyRepository)); + } else if (!strcmp(string_key, \
"CryptoHardware")) { + strncpy(ssl_configuration->CryptoHardware, \
Z_STRVAL_PP(option_val), sizeof(ssl_configuration->CryptoHardware)); + } else if \
(!strcmp(string_key, "MQAIR")) { \
+ set_authentication_information_record_from_array(*option_val, \
authentication_information_record, LDAPUserName); \
+ ssl_configuration->AuthInfoRecCount = 1; + ssl_configuration->AuthInfoRecPtr \
= authentication_information_record; + }
+ }
+ zend_hash_move_forward_ex(Z_ARRVAL_P(array), &pos);
+ }
+}
+/* }}} */
+
+/* {{{ proto static set_channel_definition_from_array
+ * Set the MQCD struct from array.
+ * TODO: Findout whether all fields are needed. Do thay all have meaning during a
+ * connx call?
+ *
+ */
+static void set_channel_definition_from_array(zval *array, PMQCD channel_definition)
+{
+ zval **option_val;
+ char *string_key;
+ uint string_key_len;
+ ulong num_key;
+ HashPosition pos;
+
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(array), &pos);
while (zend_hash_get_current_data_ex(Z_ARRVAL_P(array), (void **)&option_val, &pos) \
== SUCCESS) {
if (zend_hash_get_current_key_ex(Z_ARRVAL_P(array), &string_key, &string_key_len, \
&num_key, 0, &pos) == HASH_KEY_IS_STRING) {
- if (!strcmp(string_key, "CorrelId")) {
- strncpy(msg_desc->CorrelId, Z_STRVAL_PP(option_val), \
sizeof(msg_desc->CorrelId));
- } else if (!strcmp(string_key, "StrucId")) {
- strncpy(msg_desc->StrucId, Z_STRVAL_PP(option_val),sizeof(msg_desc->StrucId));
+ if (!strcmp(string_key, "Version")) {
+ channel_definition->Version = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "ChannelName")) {
+ strncpy(channel_definition->ChannelName, Z_STRVAL_PP(option_val), \
sizeof(channel_definition->ChannelName)); + } else if (!strcmp(string_key, \
"ConnectionName")) { + strncpy(channel_definition->ConnectionName, \
Z_STRVAL_PP(option_val), sizeof(channel_definition->ConnectionName)); + } else if \
(!strcmp(string_key, "TransportType")) { + channel_definition->TransportType = \
Z_LVAL_PP(option_val); + } else if (!strcmp(string_key, "ChannelType")) {
+ channel_definition->ChannelType = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "Desc")) {
+ strncpy(channel_definition->Desc, Z_STRVAL_PP(option_val), \
sizeof(channel_definition->Desc)); + } else if (!strcmp(string_key, "QMgrName")) {
+ strncpy(channel_definition->QMgrName, Z_STRVAL_PP(option_val), \
sizeof(channel_definition->QMgrName)); + } else if (!strcmp(string_key, \
"XmitQName")) { + strncpy(channel_definition->XmitQName, Z_STRVAL_PP(option_val), \
sizeof(channel_definition->XmitQName)); + } else if (!strcmp(string_key, \
"ShortConnectionName")) { + strncpy(channel_definition->ShortConnectionName, \
Z_STRVAL_PP(option_val), sizeof(channel_definition->ShortConnectionName)); + } else \
if (!strcmp(string_key, "MCAName")) { + strncpy(channel_definition->MCAName, \
Z_STRVAL_PP(option_val), sizeof(channel_definition->MCAName)); + } else if \
(!strcmp(string_key, "ModeName")) { + strncpy(channel_definition->ModeName, \
Z_STRVAL_PP(option_val), sizeof(channel_definition->ModeName)); + } else if \
(!strcmp(string_key, "ModeName")) { + strncpy(channel_definition->ModeName, \
Z_STRVAL_PP(option_val), sizeof(channel_definition->ModeName)); + } else if \
(!strcmp(string_key, "TpName")) { + strncpy(channel_definition->TpName, \
Z_STRVAL_PP(option_val), sizeof(channel_definition->TpName)); + } else if \
(!strcmp(string_key, "BatchSize")) { + channel_definition->BatchSize = \
Z_LVAL_PP(option_val); + } else if (!strcmp(string_key, "DiscInterval")) {
+ channel_definition->DiscInterval = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "ShortRetryCount")) {
+ channel_definition->ShortRetryCount = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "ShortRetryInterval")) {
+ channel_definition->ShortRetryInterval = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "LongRetryCount")) {
+ channel_definition->LongRetryCount = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "LongRetryInterval")) {
+ channel_definition->LongRetryInterval = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "SecurityExit")) {
+ strncpy(channel_definition->SecurityExit, Z_STRVAL_PP(option_val), \
sizeof(channel_definition->SecurityExit)); + } else if (!strcmp(string_key, \
"MsgExit")) { + strncpy(channel_definition->MsgExit, Z_STRVAL_PP(option_val), \
sizeof(channel_definition->MsgExit)); + } else if (!strcmp(string_key, "SendExit")) \
{ + strncpy(channel_definition->SendExit, Z_STRVAL_PP(option_val), \
sizeof(channel_definition->SendExit)); + } else if (!strcmp(string_key, \
"ReceiveExit")) { + strncpy(channel_definition->ReceiveExit, \
Z_STRVAL_PP(option_val), sizeof(channel_definition->ReceiveExit)); + } else if \
(!strcmp(string_key, "SeqNumberWrap")) { + channel_definition->SeqNumberWrap = \
Z_LVAL_PP(option_val); + } else if (!strcmp(string_key, "MaxMsgLength")) {
+ channel_definition->MaxMsgLength = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "PutAuthority")) {
+ channel_definition->PutAuthority = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "DataConversion")) {
+ channel_definition->DataConversion = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "SecurityUserData")) {
+ strncpy(channel_definition->SecurityUserData, Z_STRVAL_PP(option_val), \
sizeof(channel_definition->SecurityUserData)); + } else if (!strcmp(string_key, \
"MsgUserData")) { + strncpy(channel_definition->MsgUserData, \
Z_STRVAL_PP(option_val), sizeof(channel_definition->MsgUserData)); + } else if \
(!strcmp(string_key, "SendUserData")) { \
+ strncpy(channel_definition->SendUserData, Z_STRVAL_PP(option_val), \
sizeof(channel_definition->SendUserData)); + } else if (!strcmp(string_key, \
"ReceiveUserData")) { + strncpy(channel_definition->ReceiveUserData, \
Z_STRVAL_PP(option_val), sizeof(channel_definition->ReceiveUserData)); + } else if \
(!strcmp(string_key, "UserIdentifier")) { \
+ strncpy(channel_definition->UserIdentifier, Z_STRVAL_PP(option_val), \
sizeof(channel_definition->UserIdentifier)); + } else if (!strcmp(string_key, \
"Password")) { + strncpy(channel_definition->Password, Z_STRVAL_PP(option_val), \
sizeof(channel_definition->Password)); + } else if (!strcmp(string_key, \
"MCAUserIdentifier")) { + strncpy(channel_definition->MCAUserIdentifier, \
Z_STRVAL_PP(option_val), sizeof(channel_definition->MCAUserIdentifier)); + } else \
if (!strcmp(string_key, "MCAType")) { + channel_definition->MCAType = \
Z_LVAL_PP(option_val); + } else if (!strcmp(string_key, "RemoteUserIdentifier")) {
+ strncpy(channel_definition->RemoteUserIdentifier, Z_STRVAL_PP(option_val), \
sizeof(channel_definition->RemoteUserIdentifier)); + } else if (!strcmp(string_key, \
"RemotePassword")) { + strncpy(channel_definition->RemotePassword, \
Z_STRVAL_PP(option_val), sizeof(channel_definition->RemotePassword)); + } else if \
(!strcmp(string_key, "MsgRetryExit")) { \
+ strncpy(channel_definition->MsgRetryExit, Z_STRVAL_PP(option_val), \
sizeof(channel_definition->MsgRetryExit)); + } else if (!strcmp(string_key, \
"MsgRetryUserData")) { + strncpy(channel_definition->MsgRetryUserData, \
Z_STRVAL_PP(option_val), sizeof(channel_definition->MsgRetryUserData)); + } else if \
(!strcmp(string_key, "MsgRetryCount")) { + channel_definition->MsgRetryCount = \
Z_LVAL_PP(option_val); + } else if (!strcmp(string_key, "MsgRetryInterval")) {
+ channel_definition->MsgRetryInterval = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "HeartbeatInterval")) {
+ channel_definition->HeartbeatInterval = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "BatchInterval")) {
+ channel_definition->BatchInterval = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "NonPersistentMsgSpeed")) {
+ channel_definition->NonPersistentMsgSpeed = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "StrucLength")) {
+ channel_definition->StrucLength = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "ExitNameLength")) {
+ channel_definition->ExitNameLength = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "ExitDataLength")) {
+ channel_definition->ExitDataLength = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "MsgExitsDefined")) {
+ channel_definition->MsgExitsDefined = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "SendExitsDefined")) {
+ channel_definition->SendExitsDefined = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "ReceiveExitsDefined")) {
+ channel_definition->ReceiveExitsDefined = Z_LVAL_PP(option_val);
+/* TODO: Do we need these? Or are they only needed during the creation of a \
channel? + MQPTR MsgExitPtr; Address of first MsgExit field \
+ MQPTR MsgUserDataPtr; Address of first MsgUserData field
+ MQPTR SendExitPtr; Address of first SendExit field
+ MQPTR SendUserDataPtr; Address of first SendUserData field
+ MQPTR ReceiveExitPtr; Address of first ReceiveExit field
+ MQPTR ReceiveUserDataPtr; Address of first ReceiveUserData field
+ MQPTR ClusterPtr; Address of a list of cluster names
+ */
+ } else if (!strcmp(string_key, "ClustersDefined")) {
+ channel_definition->ClustersDefined = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "NetworkPriority")) {
+ channel_definition->NetworkPriority = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "LongMCAUserIdLength")) {
+ channel_definition->LongMCAUserIdLength = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "LongRemoteUserIdLength")) {
+ channel_definition->LongRemoteUserIdLength = Z_LVAL_PP(option_val);
+/* MQPTR LongMCAUserIdPtr; Address of long MCA user identifier
+ MQPTR LongRemoteUserIdPtr; Address of long remote user identifier
+ MQBYTE40 MCASecurityId; MCA security identifier
+ MQBYTE40 RemoteSecurityId; Remote security identifier
+ } else if (!strcmp(string_key, "SSLCipherSpec")) {
+ strncpy(channel_definition->SSLCipherSpec, Z_STRVAL_PP(option_val), \
sizeof(channel_definition->SSLCipherSpec)); + MQPTR SSLPeerNamePtr; \
Address of SSL peer name + */
+ } else if (!strcmp(string_key, "SSLPeerNameLength")) {
+ channel_definition->SSLPeerNameLength = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "SSLClientAuth")) {
+ channel_definition->SSLClientAuth = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "KeepAliveInterval")) {
+ channel_definition->KeepAliveInterval = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "LocalAddress")) {
+ strncpy(channel_definition->LocalAddress, Z_STRVAL_PP(option_val), \
sizeof(channel_definition->LocalAddress)); + } else if (!strcmp(string_key, \
"BatchHeartbeat")) { + channel_definition->BatchHeartbeat = Z_LVAL_PP(option_val);
+ }
+
+
+ }
+
+ zend_hash_move_forward_ex(Z_ARRVAL_P(array), &pos);
+ }
+}
+/* }}} */
+
+/* {{{ proto static set_connect_opts_from_array
+ * Set MQCNO connect options from array.
+ * The MQCD struct is part of the connect options. Fields for this struct are
+ * prefixed with MQCD.
+ *
+ */
+static void set_connect_opts_from_array(zval *array,
+ PMQCNO connect_opts,
+ PMQCD channel_definition,
+ PMQSCO ssl_configuration,
+ PMQAIR authentication_information_record,
+ PMQCHAR LDAPUserName)
+{
+ zval **option_val;
+ char *string_key;
+ uint string_key_len;
+ ulong num_key;
+ HashPosition pos;
+
+ zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(array), &pos);
+ while (zend_hash_get_current_data_ex(Z_ARRVAL_P(array), (void **)&option_val, &pos) \
== SUCCESS) { + if (zend_hash_get_current_key_ex(Z_ARRVAL_P(array), &string_key, \
&string_key_len, &num_key, 0, &pos) == HASH_KEY_IS_STRING) { + if \
(!strcmp(string_key, "Options")) { + connect_opts->Options = \
Z_LVAL_PP(option_val); } else if (!strcmp(string_key, "Version")) {
- msg_desc->Version = Z_LVAL_PP(option_val);
- } else if (!strcmp(string_key, "Report")) {
+ connect_opts->Version = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "MQCD")) {
+ set_channel_definition_from_array(*option_val, channel_definition);
+ connect_opts->ClientConnPtr = channel_definition;
+ } else if (!strcmp(string_key, "MQSCO")) {
+ set_ssl_configuration_from_array(*option_val, ssl_configuration, \
authentication_information_record, LDAPUserName); + connect_opts->SSLConfigPtr = \
ssl_configuration; + }
+/*
+ QManager connection Tag
+ This field is used only on z/OS. In other environments, the value MQCT_NONE \
should be specified. | + MQBYTE128 ConnTag; Queue-manager connection tag
+*/
+ }
+
+ zend_hash_move_forward_ex(Z_ARRVAL_P(array), &pos);
+ }
+}
+/* }}} */
+
+/* {{{ proto static set_put_msg_opts_from_array
+ * fills the put message options struct from an array
+ */
+static void set_put_msg_opts_from_array(zval *array, PMQPMO put_msg_opts)
+{
+ zval **option_val;
+ char *string_key;
+ uint string_key_len;
+ ulong num_key;
+ HashPosition pos;
+ mqseries_obj *mqobj;
+
+ zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(array), &pos);
+ while (zend_hash_get_current_data_ex(Z_ARRVAL_P(array), (void **)&option_val, &pos) \
== SUCCESS) { +
+ if (zend_hash_get_current_key_ex(Z_ARRVAL_P(array), &string_key, &string_key_len, \
&num_key, 0, &pos) == HASH_KEY_IS_STRING) { + if (!strcmp(string_key, "Options")) {
+ put_msg_opts->Options = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "Version")) {
+ put_msg_opts->Version = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "Context")) {
+ ZEND_FETCH_RESOURCE_HELPER(mqobj, mqseries_obj *, option_val, -1, \
"mqseries_obj", le_mqseries_obj); + if (mqobj != NULL) {
+ put_msg_opts->Context = mqobj->obj;
+ }
+ }
+
+/* input fields not supported yet
+ MQLONG RecsPresent;
+ MQLONG PutMsgRecFields;
+ MQLONG PutMsgRecOffset;
+ MQPTR PutMsgRecPtr;
+ MQLONG ResponseRecOffset;
+ MQPTR ResponseRecPtr;
+*/
+ }
+
+ zend_hash_move_forward_ex(Z_ARRVAL_P(array), &pos);
+ }
+}
+/* }}} */
+
+/* {{{ proto static set_array_from_put_msg_opts
+ * makes an array from the put message options struct for output
+ */
+static void set_array_from_put_msg_opts(zval *array, PMQPMO put_msg_opts) {
+ array_init(array);
+ if (put_msg_opts->ResolvedQName != NULL && strlen(put_msg_opts->ResolvedQName) > 0) \
{ + add_assoc_stringl(array, "ResolvedQName",put_msg_opts->ResolvedQName, \
strlen(put_msg_opts->ResolvedQName),1); + }
+ if (put_msg_opts->ResolvedQMgrName != NULL && \
strlen(put_msg_opts->ResolvedQMgrName) >0) { + add_assoc_stringl(array, \
"ResolvedQMgrName",put_msg_opts->ResolvedQMgrName, \
strlen(put_msg_opts->ResolvedQMgrName),1); + }
+ add_assoc_long(array, "KnownDestCount",put_msg_opts->KnownDestCount);
+ add_assoc_long(array, "UnknownDestCount",put_msg_opts->UnknownDestCount);
+ add_assoc_long(array, "InvalidDestCount",put_msg_opts->InvalidDestCount);
+}
+/* }}} */
+
+/* {{{ proto static void set_msg_desc_from_array()
+ Put options from the given array into the MQMD structure.
+ Only version_1 of the MQMD is supported.
+
+Not supported:
+ AccountingToken
+
+*/
+static void set_msg_desc_from_array(zval *array, PMQMD msg_desc, int put_get)
+{
+ zval **option_val;
+ char *string_key;
+ uint string_key_len;
+ ulong num_key;
+ HashPosition pos;
+ mqseries_bytes *byte24;
+
+ zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(array), &pos);
+ while (zend_hash_get_current_data_ex(Z_ARRVAL_P(array), (void **)&option_val, &pos) \
== SUCCESS) { +
+ if (zend_hash_get_current_key_ex(Z_ARRVAL_P(array), &string_key, &string_key_len, \
&num_key, 0, &pos) == HASH_KEY_IS_STRING) { + if (!strcmp(string_key, "Report")) {
msg_desc->Report = Z_LVAL_PP(option_val);
} else if (!strcmp(string_key, "MsgType")) {
msg_desc->MsgType = Z_LVAL_PP(option_val);
@@ -569,8 +1556,41 @@
msg_desc->Persistence = Z_LVAL_PP(option_val);
} else if (!strcmp(string_key, "ReplyToQ")) {
strncpy(msg_desc->ReplyToQ, Z_STRVAL_PP(option_val), \
sizeof(msg_desc->ReplyToQ)); + } else if (!strcmp(string_key, "Feedback")) {
+ msg_desc->Feedback = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "Encoding")) {
+ msg_desc->Encoding = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "CodedCharSetId")) {
+ msg_desc->CodedCharSetId = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "MsgId")) {
+ if (put_get == MQMD_GET) {
+/* The messageID of the MQGet call should be the one specified by the MQPut either \
generated or user supplied*/ + ZEND_FETCH_RESOURCE_HELPER(byte24, mqseries_bytes \
*, option_val, -1, "mqseries_bytes", le_mqseries_bytes); + if (byte24 != NULL) {
+ memcpy(msg_desc->MsgId, byte24->bytes, sizeof(msg_desc->MsgId));
+ }
+ } else {
+ strncpy(msg_desc->MsgId, Z_STRVAL_PP(option_val), sizeof(msg_desc->MsgId));
+ }
+ } else if (!strcmp(string_key, "CorrelId")) {
+ if (put_get == MQMD_GET) {
+/*See mesgId comments*/
+ ZEND_FETCH_RESOURCE_HELPER(byte24, mqseries_bytes *, option_val, -1, \
"mqseries_bytes", le_mqseries_bytes); + if (byte24 != NULL) {
+ memcpy(msg_desc->CorrelId, byte24->bytes, sizeof(msg_desc->CorrelId));
+ }
+ } else {
+ strncpy(msg_desc->CorrelId, Z_STRVAL_PP(option_val), \
sizeof(msg_desc->CorrelId)); + }
+ } else if (!strcmp(string_key, "ReplyToQMgr")) {
+ strncpy(msg_desc->ReplyToQMgr, Z_STRVAL_PP(option_val), \
sizeof(msg_desc->ReplyToQMgr)); + } else if (!strcmp(string_key, "PutApplType")) {
+ msg_desc->PutApplType = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "MsgSeqNumber")) {
+ msg_desc->MsgSeqNumber = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "MsgFlags")) {
+ msg_desc->MsgFlags = Z_LVAL_PP(option_val);
}
-
}
zend_hash_move_forward_ex(Z_ARRVAL_P(array), &pos);
@@ -579,55 +1599,246 @@
}
/* }}} */
-/* {{{ proto static void _mqseries_close() */
-static void _mqseries_close(zend_rsrc_list_entry *rsrc TSRMLS_DC)
+/* {{{ proto static make_reference
+ * makes an mqseries_bytes reference, needed when returning message and correlation \
id's + */
+static zval* make_reference(PMQBYTE bytes, MQLONG size) {
+ mqseries_bytes *pBytes;
+ zval *z_byte24;
+
+
+ MAKE_STD_ZVAL(z_byte24);
+
+ pBytes = emalloc(sizeof(mqseries_bytes));
+ pBytes->bytes = emalloc(size*sizeof(MQBYTE));
+ memcpy(pBytes->bytes, bytes, size);
+ ZEND_REGISTER_RESOURCE(z_byte24, pBytes, le_mqseries_bytes);
+ pBytes->id = Z_LVAL_P(z_byte24);
+
+ return z_byte24;
+}
+/* }}} */
+
+/* {{{ proto static set_array_from_msg_desc
+ * makes an array from the message descriptor struct for output.
+ */
+static void set_array_from_msg_desc(zval *array, PMQMD msg_desc) {
+ array_init(array);
+
+ if (msg_desc->ApplIdentityData != NULL && strlen(msg_desc->ApplIdentityData) > 0) {
+ add_assoc_stringl(array, "ApplIdentityData",msg_desc->ApplIdentityData, \
sizeof(msg_desc->ApplIdentityData), 1); + }
+ if (msg_desc->ApplOriginData != NULL && strlen(msg_desc->ApplOriginData) > 0) {
+ add_assoc_stringl(array, "ApplOriginData",msg_desc->ApplOriginData, \
sizeof(msg_desc->ApplOriginData), 1); + }
+ add_assoc_long(array, "BackoutCount",msg_desc->BackoutCount);
+ add_assoc_long(array, "CodedCharSetId",msg_desc->CodedCharSetId);
+ add_assoc_resource(array, "CorrelId", Z_LVAL_P(make_reference(msg_desc->CorrelId, \
24))); + add_assoc_long(array, "Encoding",msg_desc->Encoding);
+ add_assoc_long(array, "Expiry",msg_desc->Expiry);
+ add_assoc_long(array, "Feedback",msg_desc->Feedback);
+ if (msg_desc->Format != NULL && strlen(msg_desc->Format) > 0) {
+ add_assoc_stringl(array, "Format",msg_desc->Format, strlen(msg_desc->Format),1);
+ }
+/* BYTE string with special meaning
+ add_assoc_string(array, "GroupId",msg_desc->GroupId, sizeof(msg_desc->GroupId));
+*/
+
+ add_assoc_long(array, "Report",msg_desc->Report);
+ add_assoc_long(array, "MsgType",msg_desc->MsgType);
+ add_assoc_long(array, "Priority",msg_desc->Priority);
+ add_assoc_long(array, "Persistence",msg_desc->Persistence);
+
+ add_assoc_resource(array, "MsgId", Z_LVAL_P(make_reference(msg_desc->MsgId, 24)));
+ if (msg_desc->ReplyToQ != NULL && strlen(msg_desc->ReplyToQ)>0)
+ add_assoc_stringl(array, "ReplyToQ",msg_desc->ReplyToQ, \
sizeof(msg_desc->ReplyToQ), 1); + if (msg_desc->ReplyToQMgr != NULL && \
strlen(msg_desc->ReplyToQMgr)>0) + add_assoc_stringl(array, \
"ReplyToQMgr",msg_desc->ReplyToQMgr, sizeof(msg_desc->ReplyToQMgr), 1); + if \
(msg_desc->UserIdentifier != NULL && strlen(msg_desc->UserIdentifier) >0) \
+ add_assoc_stringl(array, "UserIdentifier",msg_desc->UserIdentifier, \
sizeof(msg_desc->UserIdentifier), 1); +
+
+ add_assoc_long(array, "PutApplType",msg_desc->PutApplType);
+ if (msg_desc->PutApplName != NULL && strlen(msg_desc->PutApplName) >0)
+ add_assoc_stringl(array, "PutApplName",msg_desc->PutApplName, \
sizeof(msg_desc->PutApplName), 1); + if (msg_desc->PutDate != NULL && \
strlen(msg_desc->PutDate)>0) + add_assoc_stringl(array, \
"PutDate",msg_desc->PutDate, sizeof(msg_desc->PutDate), 1); + if (msg_desc->PutTime \
!= NULL && strlen(msg_desc->PutTime) >0) + add_assoc_stringl(array, \
"PutTime",msg_desc->PutTime, sizeof(msg_desc->PutTime), 1); +
+ add_assoc_long(array, "MsgSeqNumber",msg_desc->MsgSeqNumber);
+ add_assoc_long(array, "MsgFlags",msg_desc->MsgFlags);
+ add_assoc_long(array, "OriginalLength",msg_desc->OriginalLength);
+}
+/* }}} */
+
+/* {{{ proto static set_obj_desc_from_array
+ * Set the MQOD Object Descriptor from array
+ */
+static void set_obj_desc_from_array(zval *array, PMQOD obj_desc)
{
- MQLONG comp_code; /* Completion code */
- MQLONG reason; /* Qualifying reason */
- mqseries_obj *mqobj = (mqseries_obj *)rsrc->ptr;
+ zval **option_val;
+ char *string_key;
+ uint string_key_len;
+ ulong num_key;
+ HashPosition pos;
- MQCLOSE(
- *mqobj->conn,
- &mqobj->obj,
- MQCO_NONE,
- &comp_code,
- &reason);
+ zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(array), &pos);
+ while (zend_hash_get_current_data_ex(Z_ARRVAL_P(array), (void **)&option_val, &pos) \
== SUCCESS) {
- if ((comp_code != MQCC_OK) || (reason != MQRC_NONE && reason)) {
- switch(reason) {
- case MQRC_CONNECTION_BROKEN:
- case MQRC_HCONN_ERROR:
- break;
+ if (zend_hash_get_current_key_ex(Z_ARRVAL_P(array), &string_key, &string_key_len, \
&num_key, 0, &pos) == HASH_KEY_IS_STRING) { +
+ if (!strcmp(string_key, "Version")) {
+ obj_desc->Version = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key,"ObjectType")) {
+ obj_desc->ObjectType = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "ObjectName")) {
+ strncpy(obj_desc->ObjectName, Z_STRVAL_PP(option_val), \
sizeof(obj_desc->ObjectName)); + } else if (!strcmp(string_key, "ObjectQMgrName")) \
{ + strncpy(obj_desc->ObjectQMgrName, \
Z_STRVAL_PP(option_val),sizeof(obj_desc->ObjectQMgrName)); + } else if \
(!strcmp(string_key, "DynamicQName")) { + strncpy(obj_desc->DynamicQName, \
Z_STRVAL_PP(option_val), sizeof(obj_desc->DynamicQName)); + } else if \
(!strcmp(string_key, "AlternateUserId")) { + strncpy(obj_desc->AlternateUserId, \
Z_STRVAL_PP(option_val), sizeof(obj_desc->AlternateUserId)); + }
+/* TODO: Implement these ?
+ MQLONG RecsPresent;
+ MQLONG ObjectRecOffset;
+ MQLONG ResponseRecOffset;
+ MQPTR ObjectRecPtr;
+ MQPTR ResponseRecPtr;
- default:
- zend_error(E_WARNING, "_mqseries_close Error %d %d\n", comp_code, reason);
+ Will not support this.
+ not supported MQBYTE40 AlternateSecurityId;
+*/
}
- }
- efree(mqobj);
+ zend_hash_move_forward_ex(Z_ARRVAL_P(array), &pos);
+ }
}
/* }}} */
-/* {{{ proto static void _mqseries_disc() */
-static void _mqseries_disc(zend_rsrc_list_entry *rsrc TSRMLS_DC)
-{
- mqseries_descriptor *mqdesc = (mqseries_descriptor *)rsrc->ptr;
+/* {{{ proto static set_array_from_obj_desc
+ * Set array from MQOD Object Descriptor
+ */
+static void set_array_from_obj_desc(zval *array, PMQOD obj_desc) {
+ array_init(array);
- MQDISC(
- &mqdesc->conn,
- &mqdesc->comp_code,
- &mqdesc->reason);
+
+ add_assoc_string(array, "ObjectQMgrName",obj_desc->ObjectQMgrName, \
sizeof(obj_desc->ObjectQMgrName)); + add_assoc_string(array, \
"ObjectName",obj_desc->ObjectName, sizeof(obj_desc->ObjectName)); \
+ add_assoc_long(array, "KnownDestCount",obj_desc->KnownDestCount); \
+ add_assoc_long(array, "UnknownDestCount",obj_desc->UnknownDestCount); \
+ add_assoc_long(array, "InvalidDestCount",obj_desc->InvalidDestCount); \
+ add_assoc_string(array, "ResolvedQName",obj_desc->ResolvedQName, \
sizeof(obj_desc->ResolvedQName)); + add_assoc_string(array, \
"ResolvedQMgrName",obj_desc->ResolvedQMgrName, sizeof(obj_desc->ResolvedQMgrName)); \
+ +}
+/* }}} */
- if ((mqdesc->comp_code != MQCC_OK) || (mqdesc->reason != MQRC_NONE)) {
- switch(mqdesc->reason) {
- case MQRC_CONNECTION_BROKEN:
- case MQRC_HCONN_ERROR:
- break;
+/* {{{ proto static set_get_msg_opts_from_array
+ * sets the get message struct from an array.
+ */
+static void set_get_msg_opts_from_array(zval *array, PMQGMO get_msg_opts) {
+ zval **option_val;
+ char *string_key;
+ uint string_key_len;
+ ulong num_key;
+ HashPosition pos;
+ mqseries_bytes * byte16;
+
+ zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(array), &pos);
+ while (zend_hash_get_current_data_ex(Z_ARRVAL_P(array), (void **)&option_val, &pos) \
== SUCCESS) {
- default:
- zend_error(E_WARNING, "_mqseries_disc Error %d %d\n", mqdesc->comp_code, \
mqdesc->reason); + if (zend_hash_get_current_key_ex(Z_ARRVAL_P(array), &string_key, \
&string_key_len, &num_key, 0, &pos) == HASH_KEY_IS_STRING) { + if \
(!strcmp(string_key, "Version")) { + get_msg_opts->Version = \
Z_LVAL_PP(option_val); + } else if (!strcmp(string_key, "Options")) {
+ get_msg_opts->Options = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "WaitInterval")) {
+ get_msg_opts->WaitInterval = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "MatchOptions")) {
+ get_msg_opts->MatchOptions = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "Signal1")) {
+ get_msg_opts->Signal1 = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "Signal2")) {
+ get_msg_opts->Signal2 = Z_LVAL_PP(option_val);
+ } else if (!strcmp(string_key, "MsgToken")) {
+ ZEND_FETCH_RESOURCE_HELPER(byte16, mqseries_bytes *, option_val, -1, \
"mqseries_bytes", le_mqseries_bytes); + if (byte16 != NULL) {
+ memcpy(get_msg_opts->MsgToken, byte16->bytes, sizeof(get_msg_opts->MsgToken));
+ }
+ }
}
- }
- efree(mqdesc);
+ zend_hash_move_forward_ex(Z_ARRVAL_P(array), &pos);
+ }
+}
+/* }}} */
+
+/* {{{ proto static set_array_from_get_msg_opts
+ * Builds an array from the get message options struct for output
+ */
+static void set_array_from_get_msg_opts(zval *array, PMQGMO get_msg_opts) {
+ char str[2];
+
+ array_init(array);
+
+ add_assoc_resource(array, "MsgToken", \
Z_LVAL_P(make_reference(get_msg_opts->MsgToken, 16))); + if \
(get_msg_opts->ResolvedQName != NULL && strlen(get_msg_opts->ResolvedQName) > 0) { \
+ add_assoc_stringl(array, "ResolvedQName",get_msg_opts->ResolvedQName, \
sizeof(get_msg_opts->ResolvedQName), 1); + }
+ sprintf(str, "%c", get_msg_opts->GroupStatus);
+ add_assoc_string(array, "GroupStatus",str, sizeof(get_msg_opts->GroupStatus));
+ sprintf(str, "%c", get_msg_opts->SegmentStatus);
+ add_assoc_string(array, "SegmentStatus",str, sizeof(get_msg_opts->SegmentStatus));
+ sprintf(str, "%c", get_msg_opts->Segmentation);
+ add_assoc_string(array, "Segmentation",str, sizeof(get_msg_opts->Segmentation));
+
+ add_assoc_long(array, "ReturnedLength",get_msg_opts->ReturnedLength);
+
+}
+/* }}} */
+
+/******************************************************************************/
+/* End of conversion methods */
+/******************************************************************************/
+
+/* {{{ proto static _mqseries_bytes()
+ * frees memomory previuosly allocated
+ */
+static void _mqseries_bytes(zend_rsrc_list_entry *rsrc TSRMLS_DC)
+{
+ efree(((mqseries_bytes *)rsrc->ptr)->bytes);
+ efree(rsrc->ptr);
+}
+/* }}} */
+
+/* {{{ proto static is_compcode_reason_ref()
+ * test to see if compcode and reason where passed by reference.
+ */
+static int is_compcode_reason_ref(zval *z_comp_code, zval *z_reason) {
+ if (!PZVAL_IS_REF(z_comp_code)) {
+ zend_error(E_WARNING, "Parameter CompCode wasn't passed by reference");
+ return 0;
+ }
+ if (!PZVAL_IS_REF(z_reason)) {
+ zend_error(E_WARNING, "Parameter Reason wasn't passed by reference");
+ return 0;
+ }
+ return 1;
+}
+/* }}} */
+
+/* {{{ proto static is_called_by_ref()
+ * Test to see if a parameters was passed by reference.
+ */
+static int is_called_by_ref(zval *param, char *param_name) {
+ char str[255];
+ if (!PZVAL_IS_REF(param)) {
+ sprintf(str, "Parameter %s wasn't passed by reference", param_name);
+ zend_error(E_WARNING, str);
+ return 0;
+ }
+ return 1;
}
/* }}} */
@@ -639,3 +1850,4 @@
* vim600: noet sw=4 ts=4 fdm=marker
* vim<600: noet sw=4 ts=4
*/
+
http://cvs.php.net/viewcvs.cgi/pecl/mqseries/mqseries_init_const.h?r1=1.2&r2=1.3&diff_format=u
Index: pecl/mqseries/mqseries_init_const.h
diff -u pecl/mqseries/mqseries_init_const.h:1.2 \
pecl/mqseries/mqseries_init_const.h:1.3
--- pecl/mqseries/mqseries_init_const.h:1.2 Mon May 19 19:25:37 2003
+++ pecl/mqseries/mqseries_init_const.h Sat Apr 22 18:59:58 2006
@@ -413,11 +413,23 @@
REGISTER_LONG_CONSTANT("MQSERIES_MQOO_RESOLVE_NAMES", 0x00010000, CONST_PERSISTENT); \
/* C++ option only */ REGISTER_STRING_CONSTANT("MQSERIES_MQGMO_STRUC_ID", \
MQGMO_STRUC_ID, CONST_PERSISTENT); /* C++ option only */
-/* Get Message Options */
+/* close options */
+REGISTER_LONG_CONSTANT("MQSERIES_MQCO_NONE", MQCO_NONE, CONST_PERSISTENT);
+REGISTER_LONG_CONSTANT("MQSERIES_MQCO_DELETE", MQCO_DELETE, CONST_PERSISTENT);
+REGISTER_LONG_CONSTANT("MQSERIES_MQCO_DELETE_PURGE",MQCO_DELETE_PURGE, \
CONST_PERSISTENT); +
+
+ /*********************************************************************/
+ /* Values Related to MQGMO Structure */
+ /*********************************************************************/
+
+/* Structure Version Number */
REGISTER_LONG_CONSTANT("MQSERIES_MQGMO_VERSION_1", 1, CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("MQSERIES_MQGMO_VERSION_2", 2, CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("MQSERIES_MQGMO_VERSION_3", 3, CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("MQSERIES_MQGMO_CURRENT_VERSION", 3, CONST_PERSISTENT);
+
+/* Get-Message Options */
REGISTER_LONG_CONSTANT("MQSERIES_MQGMO_WAIT", 0x00000001, CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("MQSERIES_MQGMO_NO_WAIT", 0x00000000, CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("MQSERIES_MQGMO_SET_SIGNAL", 0x00000008, CONST_PERSISTENT);
@@ -443,16 +455,55 @@
/* Wait Interval */
REGISTER_LONG_CONSTANT("MQSERIES_MQWI_UNLIMITED", MQWI_UNLIMITED, CONST_PERSISTENT);
-/* Structure Identifier */
-REGISTER_STRING_CONSTANT("MQSERIES_MQMD_STRUC_ID", MQMD_STRUC_ID, CONST_PERSISTENT);
+ /* Signal Values */
+REGISTER_LONG_CONSTANT("MQSERIES_MQEC_MSG_ARRIVED", MQEC_MSG_ARRIVED, \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQEC_WAIT_INTERVAL_EXPIRED", \
MQEC_WAIT_INTERVAL_EXPIRED, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQEC_WAIT_CANCELED", MQEC_WAIT_CANCELED, \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQEC_Q_MGR_QUIESCING", \
MQEC_Q_MGR_QUIESCING, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQEC_CONNECTION_QUIESCING",MQEC_CONNECTION_QUIESCING \
, CONST_PERSISTENT); +
+ /* Match Options */
+REGISTER_LONG_CONSTANT("MQSERIES_MQMO_MATCH_MSG_ID",MQMO_MATCH_MSG_ID , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQMO_MATCH_CORREL_ID", \
MQMO_MATCH_CORREL_ID, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQMO_MATCH_GROUP_ID", MQMO_MATCH_GROUP_ID, \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQMO_MATCH_MSG_SEQ_NUMBER",MQMO_MATCH_MSG_SEQ_NUMBER \
, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQMO_MATCH_OFFSET",MQMO_MATCH_OFFSET , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQMO_MATCH_MSG_TOKEN",MQMO_MATCH_MSG_TOKEN \
, CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQMO_NONE", MQMO_NONE, \
CONST_PERSISTENT); +
+ /* Group Status */
+// char const
+//REGISTER_STRING_CONSTANT("MQSERIES_MQGS_NOT_IN_GROUP", MQGS_NOT_IN_GROUP, \
CONST_PERSISTENT); +//REGISTER_STRING_CONSTANT("MQSERIES_MQGS_MSG_IN_GROUP",MQGS_MSG_IN_GROUP \
, CONST_PERSISTENT); +//REGISTER_STRING_CONSTANT("MQSERIES_MQGS_LAST_MSG_IN_GROUP", \
MQGS_LAST_MSG_IN_GROUP, CONST_PERSISTENT); +
+ /* Segment Status */
+//REGISTER_STRING_CONSTANT("MQSERIES_MQSS_NOT_A_SEGMENT",MQSS_NOT_A_SEGMENT , \
CONST_PERSISTENT); +//REGISTER_STRING_CONSTANT("MQSERIES_MQSS_SEGMENT",MQSS_SEGMENT , \
CONST_PERSISTENT); +//REGISTER_STRING_CONSTANT("MQSERIES_MQSS_LAST_SEGMENT",MQSS_LAST_SEGMENT \
, CONST_PERSISTENT); +
+ /* Segmentation */
+//REGISTER_STRING_CONSTANT("MQSERIES_MQSEG_INHIBITED",MQSEG_INHIBITED , \
CONST_PERSISTENT); +//REGISTER_STRING_CONSTANT("MQSERIES_MQSEG_ALLOWED", \
MQSEG_ALLOWED, CONST_PERSISTENT); +
+ /* Message Token */
+REGISTER_STRING_CONSTANT("MQSERIES_MQMTOK_NONE", MQMTOK_NONE, CONST_PERSISTENT);
+
+
+ /* Returned Length */
+REGISTER_LONG_CONSTANT("MQSERIES_MQRL_UNDEFINED", MQRL_UNDEFINED, CONST_PERSISTENT);
+
+
+ /*********************************************************************/
+ /* Values Related to MQMD Structure */
+ /*********************************************************************/
+
+ /* Structure Version Number */
REGISTER_LONG_CONSTANT("MQSERIES_MQMD_VERSION_1", MQMD_VERSION_1, CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("MQSERIES_MQMD_VERSION_2", MQMD_VERSION_2, CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("MQSERIES_MQMD_CURRENT_VERSION", MQMD_CURRENT_VERSION, \
CONST_PERSISTENT);
-/* Expiry */
-REGISTER_LONG_CONSTANT("MQSERIES_MQEI_UNLIMITED", MQEI_UNLIMITED, CONST_PERSISTENT);
-
-/* Report */
+ /* Report Options */
REGISTER_LONG_CONSTANT("MQSERIES_MQRO_EXCEPTION", MQRO_EXCEPTION, CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("MQSERIES_MQRO_EXCEPTION_WITH_DATA", \
MQRO_EXCEPTION_WITH_DATA, CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("MQSERIES_MQRO_EXCEPTION_WITH_FULL_DATA", \
MQRO_EXCEPTION_WITH_FULL_DATA, CONST_PERSISTENT); @@ -474,6 +525,8 @@
REGISTER_LONG_CONSTANT("MQSERIES_MQRO_DEAD_LETTER_Q", MQRO_DEAD_LETTER_Q, \
CONST_PERSISTENT); REGISTER_LONG_CONSTANT("MQSERIES_MQRO_DISCARD_MSG", \
MQRO_DISCARD_MSG, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("MQSERIES_MQRO_NONE", \
MQRO_NONE, CONST_PERSISTENT); +
+ /* Report Options Masks */
REGISTER_LONG_CONSTANT("MQSERIES_MQRO_REJECT_UNSUP_MASK", MQRO_REJECT_UNSUP_MASK, \
CONST_PERSISTENT); REGISTER_LONG_CONSTANT("MQSERIES_MQRO_ACCEPT_UNSUP_MASK", \
MQRO_ACCEPT_UNSUP_MASK, CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("MQSERIES_MQRO_ACCEPT_UNSUP_IF_XMIT_MASK", \
MQRO_ACCEPT_UNSUP_IF_XMIT_MASK, CONST_PERSISTENT); @@ -490,18 +543,90 @@
REGISTER_LONG_CONSTANT("MQSERIES_MQMT_APPL_FIRST", MQMT_APPL_FIRST, \
CONST_PERSISTENT); REGISTER_LONG_CONSTANT("MQSERIES_MQMT_APPL_LAST", MQMT_APPL_LAST, \
CONST_PERSISTENT);
-/* Persistent */
-REGISTER_LONG_CONSTANT("MQSERIES_MQPER_NOT_PERSISTENT", MQPER_NOT_PERSISTENT, \
CONST_PERSISTENT);
-REGISTER_LONG_CONSTANT("MQSERIES_MQPER_PERSISTENT", MQPER_PERSISTENT, \
CONST_PERSISTENT);
-REGISTER_LONG_CONSTANT("MQSERIES_MQPER_PERSISTENCE_AS_Q_DEF", \
MQPER_PERSISTENCE_AS_Q_DEF, CONST_PERSISTENT); +/* Expiry */
+REGISTER_LONG_CONSTANT("MQSERIES_MQEI_UNLIMITED", MQEI_UNLIMITED, CONST_PERSISTENT);
-/* Begin Options */
-REGISTER_STRING_CONSTANT("MQSERIES_MQBO_STRUC_ID", MQBO_STRUC_ID, CONST_PERSISTENT);
-REGISTER_LONG_CONSTANT("MQSERIES_MQBO_VERSION_1", MQBO_VERSION_1, CONST_PERSISTENT);
-REGISTER_LONG_CONSTANT("MQSERIES_MQBO_CURRENT_VERSION", MQBO_CURRENT_VERSION, \
CONST_PERSISTENT);
-REGISTER_LONG_CONSTANT("MQSERIES_MQBO_NONE", MQBO_NONE, CONST_PERSISTENT);
+ /* Feedback Values */
+REGISTER_LONG_CONSTANT("MQSERIES_MQFB_NONE",MQFB_NONE , CONST_PERSISTENT);
+REGISTER_LONG_CONSTANT("MQSERIES_MQFB_SYSTEM_FIRST",MQFB_SYSTEM_FIRST , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQFB_QUIT",MQFB_QUIT , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQFB_EXPIRATION",MQFB_EXPIRATION \
, CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQFB_COA", MQFB_COA, \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQFB_COD",MQFB_COD , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQFB_CHANNEL_COMPLETED",MQFB_CHANNEL_COMPLETED \
, CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQFB_CHANNEL_FAIL_RETRY", \
MQFB_CHANNEL_FAIL_RETRY, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQFB_CHANNEL_FAIL",MQFB_CHANNEL_FAIL , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQFB_APPL_CANNOT_BE_STARTED", \
MQFB_APPL_CANNOT_BE_STARTED, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQFB_TM_ERROR",MQFB_TM_ERROR , CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQFB_APPL_TYPE_ERROR",MQFB_APPL_TYPE_ERROR , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQFB_STOPPED_BY_MSG_EXIT", \
MQFB_STOPPED_BY_MSG_EXIT, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQFB_XMIT_Q_MSG_ERROR",MQFB_XMIT_Q_MSG_ERROR , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQFB_PAN", MQFB_PAN, \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQFB_NAN",MQFB_NAN , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQFB_STOPPED_BY_CHAD_EXIT", \
MQFB_STOPPED_BY_CHAD_EXIT, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQFB_STOPPED_BY_PUBSUB_EXIT",MQFB_STOPPED_BY_PUBSUB_EXIT \
, CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQFB_NOT_A_REPOSITORY_MSG", \
MQFB_NOT_A_REPOSITORY_MSG, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQFB_BIND_OPEN_CLUSRCVR_DEL", \
MQFB_BIND_OPEN_CLUSRCVR_DEL, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQFB_DATA_LENGTH_ZERO",MQFB_DATA_LENGTH_ZERO , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQFB_DATA_LENGTH_NEGATIVE",MQFB_DATA_LENGTH_NEGATIVE \
, CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQFB_DATA_LENGTH_TOO_BIG", \
MQFB_DATA_LENGTH_TOO_BIG, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQFB_BUFFER_OVERFLOW", MQFB_BUFFER_OVERFLOW, \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQFB_LENGTH_OFF_BY_ONE",MQFB_LENGTH_OFF_BY_ONE \
, CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQFB_IIH_ERROR", \
MQFB_IIH_ERROR, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQFB_NOT_AUTHORIZED_FOR_IMS",MQFB_NOT_AUTHORIZED_FOR_IMS \
, CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQFB_IMS_ERROR", \
MQFB_IMS_ERROR, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQFB_IMS_FIRST",MQFB_IMS_FIRST , CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQFB_IMS_LAST",MQFB_IMS_LAST , CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQFB_CICS_INTERNAL_ERROR", \
MQFB_CICS_INTERNAL_ERROR, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQFB_CICS_NOT_AUTHORIZED",MQFB_CICS_NOT_AUTHORIZED \
, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQFB_CICS_BRIDGE_FAILURE",MQFB_CICS_BRIDGE_FAILURE \
, CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQFB_CICS_CORREL_ID_ERROR", \
MQFB_CICS_CORREL_ID_ERROR, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQFB_CICS_CCSID_ERROR",MQFB_CICS_CCSID_ERROR , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQFB_CICS_ENCODING_ERROR", \
MQFB_CICS_ENCODING_ERROR, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQFB_CICS_CIH_ERROR", MQFB_CICS_CIH_ERROR, \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQFB_CICS_UOW_ERROR",MQFB_CICS_UOW_ERROR \
, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQFB_CICS_COMMAREA_ERROR",MQFB_CICS_COMMAREA_ERROR \
, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQFB_CICS_APPL_NOT_STARTED",MQFB_CICS_APPL_NOT_STARTED \
, CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQFB_CICS_APPL_ABENDED", \
MQFB_CICS_APPL_ABENDED, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQFB_CICS_DLQ_ERROR",MQFB_CICS_DLQ_ERROR, \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQFB_CICS_UOW_BACKED_OUT",MQFB_CICS_UOW_BACKED_OUT \
, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQFB_SYSTEM_LAST",MQFB_SYSTEM_LAST , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQFB_APPL_FIRST",MQFB_APPL_FIRST \
, CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQFB_APPL_LAST", \
MQFB_APPL_LAST, CONST_PERSISTENT); +
+ /* Encoding */
+REGISTER_LONG_CONSTANT("MQSERIES_MQENC_NATIVE", MQENC_NATIVE, CONST_PERSISTENT);
+
+ /* Encoding Masks */
+REGISTER_LONG_CONSTANT("MQSERIES_MQENC_INTEGER_MASK", MQENC_INTEGER_MASK, \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQENC_DECIMAL_MASK",MQENC_DECIMAL_MASK \
, CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQENC_FLOAT_MASK", \
MQENC_FLOAT_MASK, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQENC_RESERVED_MASK",MQENC_RESERVED_MASK , \
CONST_PERSISTENT); +
+ /* Encodings for Binary Integers */
+REGISTER_LONG_CONSTANT("MQSERIES_MQENC_INTEGER_UNDEFINED",MQENC_INTEGER_UNDEFINED , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQENC_INTEGER_NORMAL",MQENC_INTEGER_NORMAL \
, CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQENC_INTEGER_REVERSED", \
MQENC_INTEGER_REVERSED, CONST_PERSISTENT); +
+ /* Encodings for Packed-Decimal Integers */
+REGISTER_LONG_CONSTANT("MQSERIES_MQENC_DECIMAL_UNDEFINED",MQENC_DECIMAL_UNDEFINED , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQENC_DECIMAL_NORMAL",MQENC_DECIMAL_NORMAL \
, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQENC_DECIMAL_REVERSED",MQENC_DECIMAL_REVERSED , \
CONST_PERSISTENT); +
+ /* Encodings for Floating-Point Numbers */
+REGISTER_LONG_CONSTANT("MQSERIES_MQENC_FLOAT_UNDEFINED",MQENC_FLOAT_UNDEFINED , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQENC_FLOAT_IEEE_NORMAL",MQENC_FLOAT_IEEE_NORMAL \
, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQENC_FLOAT_IEEE_REVERSED",MQENC_FLOAT_IEEE_REVERSED \
, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQENC_FLOAT_S390",MQENC_FLOAT_S390 , \
CONST_PERSISTENT); +
+ /* Coded Character-Set Identifiers */
+REGISTER_LONG_CONSTANT("MQSERIES_MQCCSI_UNDEFINED",MQCCSI_UNDEFINED , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCCSI_DEFAULT",MQCCSI_DEFAULT , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCCSI_Q_MGR",MQCCSI_Q_MGR , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCCSI_INHERIT", MQCCSI_INHERIT, \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCCSI_EMBEDDED", \
MQCCSI_EMBEDDED, CONST_PERSISTENT);
-/* Formats */
+ /* Formats */
REGISTER_STRING_CONSTANT("MQSERIES_MQFMT_NONE", MQFMT_NONE, CONST_PERSISTENT);
REGISTER_STRING_CONSTANT("MQSERIES_MQFMT_ADMIN", MQFMT_ADMIN, CONST_PERSISTENT);
REGISTER_STRING_CONSTANT("MQSERIES_MQFMT_CHANNEL_COMPLETED", \
MQFMT_CHANNEL_COMPLETED, CONST_PERSISTENT); @@ -523,8 +648,103 @@
REGISTER_STRING_CONSTANT("MQSERIES_MQFMT_WORK_INFO_HEADER", MQFMT_WORK_INFO_HEADER, \
CONST_PERSISTENT); REGISTER_STRING_CONSTANT("MQSERIES_MQFMT_XMIT_Q_HEADER", \
MQFMT_XMIT_Q_HEADER, CONST_PERSISTENT);
+
+ /* Priority */
+REGISTER_LONG_CONSTANT("MQSERIES_MQPRI_PRIORITY_AS_Q_DEF", MQPRI_PRIORITY_AS_Q_DEF, \
CONST_PERSISTENT); +
+ /* Persistence Values */
+REGISTER_LONG_CONSTANT("MQSERIES_MQPER_NOT_PERSISTENT", MQPER_NOT_PERSISTENT, \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQPER_PERSISTENT", \
MQPER_PERSISTENT, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQPER_PERSISTENCE_AS_Q_DEF", \
MQPER_PERSISTENCE_AS_Q_DEF, CONST_PERSISTENT); +
+
+ /* Message Identifier */
+REGISTER_STRING_CONSTANT("MQSERIES_MQMI_NONE",MQMI_NONE , CONST_PERSISTENT);
+
+
+ /* Correlation Identifier */
+REGISTER_STRING_CONSTANT("MQSERIES_MQCI_NONE", MQCI_NONE, CONST_PERSISTENT);
+REGISTER_STRING_CONSTANT("MQSERIES_MQCI_NEW_SESSION", MQCI_NEW_SESSION, \
CONST_PERSISTENT); +
+
+ /* Accounting Token */
+REGISTER_STRING_CONSTANT("MQSERIES_MQACT_NONE", MQACT_NONE , CONST_PERSISTENT);
+
+
+ /* Accounting Token Type */
+// not supported
+//REGISTER_STRING_CONSTANT("MQSERIES_MQACTT_UNKNOWN",MQACTT_UNKNOWN , \
CONST_PERSISTENT); +//REGISTER_STRING_CONSTANT("MQSERIES_MQACTT_CICS_LUOW_ID",MQACTT_CICS_LUOW_ID \
, CONST_PERSISTENT); +//REGISTER_STRING_CONSTANT("MQSERIES_MQACTT_OS2_DEFAULT", \
MQACTT_OS2_DEFAULT, CONST_PERSISTENT); \
+//REGISTER_STRING_CONSTANT("MQSERIES_MQACTT_DOS_DEFAULT",MQACTT_DOS_DEFAULT , \
CONST_PERSISTENT); +//REGISTER_STRING_CONSTANT("MQSERIES_MQACTT_UNIX_NUMERIC_ID",MQACTT_UNIX_NUMERIC_ID \
, CONST_PERSISTENT); \
+//REGISTER_STRING_CONSTANT("MQSERIES_MQACTT_OS400_ACCOUNT_TOKEN",MQACTT_OS400_ACCOUNT_TOKEN \
, CONST_PERSISTENT); \
+//REGISTER_STRING_CONSTANT("MQSERIES_MQACTT_WINDOWS_DEFAULT",MQACTT_WINDOWS_DEFAULT \
, CONST_PERSISTENT); \
+//REGISTER_STRING_CONSTANT("MQSERIES_MQACTT_NT_SECURITY_ID",MQACTT_NT_SECURITY_ID , \
CONST_PERSISTENT); +//REGISTER_STRING_CONSTANT("MQSERIES_MQACTT_USER", MQACTT_USER, \
CONST_PERSISTENT); +
+ /* Put Application Type */
+REGISTER_LONG_CONSTANT("MQSERIES_MQAT_UNKNOWN", MQAT_UNKNOWN, CONST_PERSISTENT);
+REGISTER_LONG_CONSTANT("MQSERIES_MQAT_NO_CONTEXT",MQAT_NO_CONTEXT , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQAT_CICS",MQAT_CICS , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQAT_MVS", MQAT_MVS, \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQAT_OS390", MQAT_OS390, \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQAT_ZOS",MQAT_ZOS , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQAT_IMS",MQAT_IMS , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQAT_OS2",MQAT_OS2 , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQAT_DOS",MQAT_DOS , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQAT_AIX", MQAT_AIX, \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQAT_UNIX",MQAT_UNIX , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQAT_QMGR", MQAT_QMGR, \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQAT_OS400",MQAT_OS400 , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQAT_WINDOWS",MQAT_WINDOWS , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQAT_CICS_VSE",MQAT_CICS_VSE , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQAT_WINDOWS_NT",MQAT_WINDOWS_NT \
, CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQAT_VMS", MQAT_VMS, \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQAT_GUARDIAN",MQAT_GUARDIAN , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQAT_NSK",MQAT_NSK , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQAT_VOS",MQAT_VOS , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQAT_IMS_BRIDGE", \
MQAT_IMS_BRIDGE, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQAT_XCF",MQAT_XCF , CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQAT_CICS_BRIDGE",MQAT_CICS_BRIDGE , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQAT_NOTES_AGENT",MQAT_NOTES_AGENT \
, CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQAT_USER",MQAT_USER , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQAT_BROKER", MQAT_BROKER, \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQAT_JAVA",MQAT_JAVA , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQAT_DQM",MQAT_DQM , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQAT_CHANNEL_INITIATOR",MQAT_CHANNEL_INITIATOR \
, CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQAT_DEFAULT", MQAT_DEFAULT, \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQAT_USER_FIRST",MQAT_USER_FIRST \
, CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQAT_USER_LAST",MQAT_USER_LAST \
, CONST_PERSISTENT); +
+ /* Group Identifier */
+REGISTER_STRING_CONSTANT("MQSERIES_MQGI_NONE",MQGI_NONE , CONST_PERSISTENT);
+
+ /* Message Flags */
+REGISTER_LONG_CONSTANT("MQSERIES_MQMF_SEGMENTATION_INHIBITED",MQMF_SEGMENTATION_INHIBITED \
, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQMF_SEGMENTATION_ALLOWED",MQMF_SEGMENTATION_ALLOWED \
, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQMF_MSG_IN_GROUP",MQMF_MSG_IN_GROUP , \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQMF_LAST_MSG_IN_GROUP",MQMF_LAST_MSG_IN_GROUP \
, CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQMF_SEGMENT", MQMF_SEGMENT, \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQMF_LAST_SEGMENT",MQMF_LAST_SEGMENT \
, CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQMF_NONE",MQMF_NONE , \
CONST_PERSISTENT); +
+ /* Message Flags Masks */
+REGISTER_LONG_CONSTANT("MQSERIES_MQMF_REJECT_UNSUP_MASK", MQMF_REJECT_UNSUP_MASK, \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQMF_ACCEPT_UNSUP_MASK",MQMF_ACCEPT_UNSUP_MASK \
, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQMF_ACCEPT_UNSUP_IF_XMIT_MASK",MQMF_ACCEPT_UNSUP_IF_XMIT_MASK \
, CONST_PERSISTENT); +
+ /* Original Length */
+REGISTER_LONG_CONSTANT("MQSERIES_MQOL_UNDEFINED", MQOL_UNDEFINED, CONST_PERSISTENT);
+
+
+/* Begin Options */
+REGISTER_LONG_CONSTANT("MQSERIES_MQBO_VERSION_1", MQBO_VERSION_1, CONST_PERSISTENT);
+REGISTER_LONG_CONSTANT("MQSERIES_MQBO_CURRENT_VERSION", MQBO_CURRENT_VERSION, \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQBO_NONE", MQBO_NONE, \
CONST_PERSISTENT); +
+
/* PMO Structure Identifier */
-REGISTER_STRING_CONSTANT("MQSERIES_MQPMO_STRUC_ID", MQPMO_STRUC_ID, \
CONST_PERSISTENT); REGISTER_LONG_CONSTANT("MQSERIES_MQPMO_VERSION_1", \
MQPMO_VERSION_1, CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("MQSERIES_MQPMO_VERSION_2", MQPMO_VERSION_2, \
CONST_PERSISTENT); REGISTER_LONG_CONSTANT("MQSERIES_MQPMO_CURRENT_VERSION", \
MQPMO_CURRENT_VERSION, CONST_PERSISTENT); @@ -545,3 +765,164 @@
REGISTER_LONG_CONSTANT("MQSERIES_MQPMO_ALTERNATE_USER_AUTHORITY", \
MQPMO_ALTERNATE_USER_AUTHORITY, CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("MQSERIES_MQPMO_FAIL_IF_QUIESCING", MQPMO_FAIL_IF_QUIESCING, \
CONST_PERSISTENT); REGISTER_LONG_CONSTANT("MQSERIES_MQPMO_NONE", MQPMO_NONE, \
CONST_PERSISTENT); +
+/* MQCNO - Connect options */
+REGISTER_LONG_CONSTANT("MQSERIES_MQCNO_VERSION_1", MQCNO_VERSION_1, \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCNO_VERSION_2", \
MQCNO_VERSION_2, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQCNO_CURRENT_VERSION", MQCNO_CURRENT_VERSION, \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCNO_STANDARD_BINDING", \
MQCNO_STANDARD_BINDING, CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQCNO_FASTPATH_BINDING", MQCNO_FASTPATH_BINDING, \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCNO_NONE", MQCNO_NONE, \
CONST_PERSISTENT); +
+/* Transport types for channel definitions */
+REGISTER_LONG_CONSTANT("MQSERIES_MQXPT_LOCAL",MQXPT_LOCAL, CONST_PERSISTENT);
+REGISTER_LONG_CONSTANT("MQSERIES_MQXPT_LU62",MQXPT_LU62, CONST_PERSISTENT);
+REGISTER_LONG_CONSTANT("MQSERIES_MQXPT_TCP",MQXPT_TCP, CONST_PERSISTENT);
+REGISTER_LONG_CONSTANT("MQSERIES_MQXPT_NETBIOS",MQXPT_NETBIOS, CONST_PERSISTENT);
+REGISTER_LONG_CONSTANT("MQSERIES_MQXPT_SPX",MQXPT_SPX, CONST_PERSISTENT);
+REGISTER_LONG_CONSTANT("MQSERIES_MQXPT_DECNET",MQXPT_DECNET, CONST_PERSISTENT);
+REGISTER_LONG_CONSTANT("MQSERIES_MQXPT_UDP",MQXPT_UDP, CONST_PERSISTENT);
+
+/* Object type for MQOpen */
+REGISTER_LONG_CONSTANT("MQSERIES_MQOT_Q",MQOT_Q, CONST_PERSISTENT);
+REGISTER_LONG_CONSTANT("MQSERIES_MQOT_NAMELIST",MQOT_NAMELIST, CONST_PERSISTENT);
+REGISTER_LONG_CONSTANT("MQSERIES_MQOT_PROCESS",MQOT_PROCESS, CONST_PERSISTENT);
+REGISTER_LONG_CONSTANT("MQSERIES_MQOT_Q_MGR",MQOT_Q_MGR, CONST_PERSISTENT);
+REGISTER_LONG_CONSTANT("MQSERIES_MQOT_RESERVED_1",MQOT_RESERVED_1, \
CONST_PERSISTENT); +
+/* Selectors for MQINQ */
+REGISTER_LONG_CONSTANT("MQSERIES_MQCA_ALTERATION_DATE", MQCA_ALTERATION_DATE, \
CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_ALTERATION_TIME", \
MQCA_ALTERATION_TIME,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQCA_APPL_ID",MQCA_APPL_ID ,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQCA_AUTH_INFO_CONN_NAME",MQCA_AUTH_INFO_CONN_NAME \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_AUTH_INFO_DESC",MQCA_AUTH_INFO_DESC \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_AUTH_INFO_NAME", \
MQCA_AUTH_INFO_NAME,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQCA_BACKOUT_REQ_Q_NAME",MQCA_BACKOUT_REQ_Q_NAME \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_BASE_Q_NAME",MQCA_BASE_Q_NAME \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_CF_STRUC_DESC",MQCA_CF_STRUC_DESC \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_CF_STRUC_NAME", \
MQCA_CF_STRUC_NAME,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQCA_CHANNEL_AUTO_DEF_EXIT", \
MQCA_CHANNEL_AUTO_DEF_EXIT,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQCA_CLUSTER_DATE", \
MQCA_CLUSTER_DATE,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQCA_CLUSTER_NAME",MQCA_CLUSTER_NAME \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_CLUSTER_NAMELIST",MQCA_CLUSTER_NAMELIST \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_CLUSTER_Q_MGR_NAME",MQCA_CLUSTER_Q_MGR_NAME \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_CLUSTER_TIME", \
MQCA_CLUSTER_TIME,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQCA_CLUSTER_WORKLOAD_DATA",MQCA_CLUSTER_WORKLOAD_DATA \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_CLUSTER_WORKLOAD_EXIT",MQCA_CLUSTER_WORKLOAD_EXIT \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_COMMAND_INPUT_Q_NAME", \
MQCA_COMMAND_INPUT_Q_NAME,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQCA_CREATION_DATE", \
MQCA_CREATION_DATE,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQCA_CREATION_TIME",MQCA_CREATION_TIME \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_DEAD_LETTER_Q_NAME", \
MQCA_DEAD_LETTER_Q_NAME,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQCA_DEF_XMIT_Q_NAME",MQCA_DEF_XMIT_Q_NAME \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_ENV_DATA", \
MQCA_ENV_DATA,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_FIRST", \
MQCA_FIRST,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQCA_IGQ_USER_ID",MQCA_IGQ_USER_ID \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_INITIATION_Q_NAME", \
MQCA_INITIATION_Q_NAME,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQCA_LAST", MQCA_LAST,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQCA_LAST_USED",MQCA_LAST_USED ,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQCA_LDAP_PASSWORD",MQCA_LDAP_PASSWORD \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_LDAP_USER_NAME",MQCA_LDAP_USER_NAME \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_NAMELIST_DESC",MQCA_NAMELIST_DESC \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_NAMELIST_NAME",MQCA_NAMELIST_NAME \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_NAMES", \
MQCA_NAMES,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQCA_PROCESS_DESC",MQCA_PROCESS_DESC \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_PROCESS_NAME",MQCA_PROCESS_NAME \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_Q_DESC", \
MQCA_Q_DESC,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQCA_Q_MGR_DESC",MQCA_Q_MGR_DESC \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_Q_MGR_IDENTIFIER", \
MQCA_Q_MGR_IDENTIFIER,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQCA_Q_MGR_NAME",MQCA_Q_MGR_NAME \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_Q_NAME",MQCA_Q_NAME \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_QSG_NAME", \
MQCA_QSG_NAME,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQCA_REMOTE_Q_MGR_NAME",MQCA_REMOTE_Q_MGR_NAME \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_REMOTE_Q_NAME", \
MQCA_REMOTE_Q_NAME,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQCA_REPOSITORY_NAME",MQCA_REPOSITORY_NAME \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_REPOSITORY_NAMELIST",MQCA_REPOSITORY_NAMELIST \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_SSL_CRL_NAMELIST", \
MQCA_SSL_CRL_NAMELIST,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQCA_SSL_CRYPTO_HARDWARE",MQCA_SSL_CRYPTO_HARDWARE \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_SSL_KEY_REPOSITORY", \
MQCA_SSL_KEY_REPOSITORY,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQCA_STORAGE_CLASS", \
MQCA_STORAGE_CLASS,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQCA_STORAGE_CLASS_DESC", \
MQCA_STORAGE_CLASS_DESC,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQCA_TRIGGER_DATA",MQCA_TRIGGER_DATA \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_USER_DATA", \
MQCA_USER_DATA,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQCA_USER_LIST",MQCA_USER_LIST ,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQCA_XCF_GROUP_NAME",MQCA_XCF_GROUP_NAME \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQCA_XCF_MEMBER_NAME", \
MQCA_XCF_MEMBER_NAME,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQCA_XMIT_Q_NAME", \
MQCA_XMIT_Q_NAME,CONST_PERSISTENT); +
+ /* Integer-Attribute Selectors */
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_APPL_TYPE", MQIA_APPL_TYPE,CONST_PERSISTENT);
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_ARCHIVE", MQIA_ARCHIVE,CONST_PERSISTENT);
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_AUTH_INFO_TYPE", \
MQIA_AUTH_INFO_TYPE,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_AUTHORITY_EVENT",MQIA_AUTHORITY_EVENT \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_BACKOUT_THRESHOLD",MQIA_BACKOUT_THRESHOLD \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_CF_LEVEL", \
MQIA_CF_LEVEL,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_CF_RECOVER", \
MQIA_CF_RECOVER,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_CHANNEL_AUTO_DEF", \
MQIA_CHANNEL_AUTO_DEF,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_CHANNEL_AUTO_DEF_EVENT", \
MQIA_CHANNEL_AUTO_DEF_EVENT,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_CLUSTER_Q_TYPE",MQIA_CLUSTER_Q_TYPE \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_CLUSTER_WORKLOAD_LENGTH", \
MQIA_CLUSTER_WORKLOAD_LENGTH,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_CODED_CHAR_SET_ID",MQIA_CODED_CHAR_SET_ID \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_COMMAND_LEVEL", \
MQIA_COMMAND_LEVEL,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_CONFIGURATION_EVENT",MQIA_CONFIGURATION_EVENT \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_CURRENT_Q_DEPTH",MQIA_CURRENT_Q_DEPTH \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_DEF_BIND", \
MQIA_DEF_BIND,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_DEF_INPUT_OPEN_OPTION", \
MQIA_DEF_INPUT_OPEN_OPTION,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_DEF_PERSISTENCE",MQIA_DEF_PERSISTENCE \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_DEF_PRIORITY", \
MQIA_DEF_PRIORITY,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_DEFINITION_TYPE", \
MQIA_DEFINITION_TYPE,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_DIST_LISTS",MQIA_DIST_LISTS \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_EXPIRY_INTERVAL",MQIA_EXPIRY_INTERVAL \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_FIRST", \
MQIA_FIRST,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_HARDEN_GET_BACKOUT",MQIA_HARDEN_GET_BACKOUT \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_HIGH_Q_DEPTH", \
MQIA_HIGH_Q_DEPTH,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_IGQ_PUT_AUTHORITY",MQIA_IGQ_PUT_AUTHORITY \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_INDEX_TYPE", \
MQIA_INDEX_TYPE,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_INHIBIT_EVENT", \
MQIA_INHIBIT_EVENT,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_INHIBIT_GET", \
MQIA_INHIBIT_GET,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_INHIBIT_PUT", \
MQIA_INHIBIT_PUT,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_INTRA_GROUP_QUEUING",MQIA_INTRA_GROUP_QUEUING \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_LAST", \
MQIA_LAST,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_LAST_USED",MQIA_LAST_USED ,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_LOCAL_EVENT", \
MQIA_LOCAL_EVENT,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_MAX_HANDLES", \
MQIA_MAX_HANDLES,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_MAX_MSG_LENGTH",MQIA_MAX_MSG_LENGTH \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_MAX_PRIORITY",MQIA_MAX_PRIORITY \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_MAX_Q_DEPTH",MQIA_MAX_Q_DEPTH \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_MAX_UNCOMMITTED_MSGS",MQIA_MAX_UNCOMMITTED_MSGS \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_MSG_DELIVERY_SEQUENCE", \
MQIA_MSG_DELIVERY_SEQUENCE,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_MSG_DEQ_COUNT",MQIA_MSG_DEQ_COUNT \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_MSG_ENQ_COUNT", \
MQIA_MSG_ENQ_COUNT,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_NAME_COUNT", \
MQIA_NAME_COUNT,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_NAMELIST_TYPE", \
MQIA_NAMELIST_TYPE,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_NPM_CLASS", MQIA_NPM_CLASS,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_OPEN_INPUT_COUNT", \
MQIA_OPEN_INPUT_COUNT,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_OPEN_OUTPUT_COUNT", \
MQIA_OPEN_OUTPUT_COUNT,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_PAGESET_ID", \
MQIA_PAGESET_ID,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_PERFORMANCE_EVENT",MQIA_PERFORMANCE_EVENT \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_PLATFORM", \
MQIA_PLATFORM,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_Q_DEPTH_HIGH_EVENT", \
MQIA_Q_DEPTH_HIGH_EVENT,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_Q_DEPTH_HIGH_LIMIT",MQIA_Q_DEPTH_HIGH_LIMIT \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_Q_DEPTH_LOW_EVENT", \
MQIA_Q_DEPTH_LOW_EVENT,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_Q_DEPTH_LOW_LIMIT", \
MQIA_Q_DEPTH_LOW_LIMIT,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_Q_DEPTH_MAX_EVENT",MQIA_Q_DEPTH_MAX_EVENT \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_Q_SERVICE_INTERVAL", \
MQIA_Q_SERVICE_INTERVAL,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_Q_SERVICE_INTERVAL_EVENT", \
MQIA_Q_SERVICE_INTERVAL_EVENT,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_Q_TYPE", MQIA_Q_TYPE,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_QSG_DISP",MQIA_QSG_DISP ,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_REMOTE_EVENT",MQIA_REMOTE_EVENT \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_RETENTION_INTERVAL",MQIA_RETENTION_INTERVAL \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_SCOPE", \
MQIA_SCOPE,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_SHAREABILITY", \
MQIA_SHAREABILITY,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_SSL_TASKS",MQIA_SSL_TASKS ,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_START_STOP_EVENT",MQIA_START_STOP_EVENT \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_SYNCPOINT", \
MQIA_SYNCPOINT,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_TIME_SINCE_RESET",MQIA_TIME_SINCE_RESET \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_TRIGGER_CONTROL",MQIA_TRIGGER_CONTROL \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_TRIGGER_DEPTH",MQIA_TRIGGER_DEPTH \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_TRIGGER_INTERVAL",MQIA_TRIGGER_INTERVAL \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_TRIGGER_MSG_PRIORITY", \
MQIA_TRIGGER_MSG_PRIORITY,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_TRIGGER_TYPE",MQIA_TRIGGER_TYPE \
,CONST_PERSISTENT); +REGISTER_LONG_CONSTANT("MQSERIES_MQIA_USAGE", \
MQIA_USAGE,CONST_PERSISTENT); \
+REGISTER_LONG_CONSTANT("MQSERIES_MQIA_USER_LIST",MQIA_USER_LIST ,CONST_PERSISTENT); \
+ +
http://cvs.php.net/viewcvs.cgi/pecl/mqseries/mqseries_reason_texts.h?r1=1.2&r2=1.3&diff_format=u
Index: pecl/mqseries/mqseries_reason_texts.h
diff -u pecl/mqseries/mqseries_reason_texts.h:1.2 \
pecl/mqseries/mqseries_reason_texts.h:1.3
--- pecl/mqseries/mqseries_reason_texts.h:1.2 Mon May 19 09:10:11 2003
+++ pecl/mqseries/mqseries_reason_texts.h Sat Apr 22 18:59:58 2006
@@ -444,3 +444,5 @@
add_assoc_string(z_reason_texts, "4088", "Network priority value is not valid.", 1);
add_assoc_string(z_reason_texts, "4089", "Network priority parameter not allowed for \
this channel type.", 1); add_assoc_string(z_reason_texts, "6117", "Length is \
negative.", 1); +
+
http://cvs.php.net/viewcvs.cgi/pecl/mqseries/package.xml?r1=1.1&r2=1.2&diff_format=u
Index: pecl/mqseries/package.xml
diff -u pecl/mqseries/package.xml:1.1 pecl/mqseries/package.xml:1.2
--- pecl/mqseries/package.xml:1.1 Sat May 17 19:29:28 2003
+++ pecl/mqseries/package.xml Sat Apr 22 18:59:58 2006
@@ -1,62 +1,130 @@
-<?xml version="1.0" encoding="ISO-8859-1" ?>
-<!-- do not use the "Type" attribute here, that one is only for
- generated package.xml files -->
-<package>
-
- <name>mqseries</name>
- <summary>mqseries client library</summary>
- <description>
-This package provides support for IBM Websphere MQ (MQSeries).
- </description>
-
- <maintainers>
- <maintainer>
- <user>mbretter</user>
- <name>Michael Bretterklieber</name>
- <email>mbretter@php.net</email>
- <role>lead</role>
- </maintainer>
- </maintainers>
-
- <license>BSD</license>
-
- <release>
- <version>0.7.0</version>
- <date>2003-05-15</date>
- <state>alpha</state>
- <notes>
- - Release 0.7.0
- - Initial Release
- </notes>
- </release>
-
- <filelist>
- <dir role="src" name="/">
- <file>CREDITS</file>
- <file>config.m4</file>
- <file>php_mqseries.h</file>
- <file>mqseries.c</file>
- <file>mqseries.dsp</file>
- <file>mqseries_init_const.h</file>
- <file>mqseries_reason_texts.h</file>
- <dir name="examples" role="doc">
- <file>mqclient.php</file>
- </dir>
- </dir>
- </filelist>
-
- <changelog>
-
- <release>
- <version>0.7.0</version>
- <date>2003-05-15</date>
- <state>alpha</state>
- <notes>
- - Release 0.7.0
- - Initial Release
- </notes>
- </release>
-
- </changelog>
-
+<?xml version="1.0" encoding="UTF-8"?>
+<package packagerversion="1.4.9" version="2.0" \
xmlns="http://pear.php.net/dtd/package-2.0" \
xmlns:tasks="http://pear.php.net/dtd/tasks-1.0" \
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" \
xsi:schemaLocation="http://pear.php.net/dtd/tasks-1.0 \
+http://pear.php.net/dtd/tasks-1.0.xsd +http://pear.php.net/dtd/package-2.0
+http://pear.php.net/dtd/package-2.0.xsd">
+ <name>mqseries</name>
+ <channel>pecl.php.net</channel>
+ <summary>mqseries client library</summary>
+ <description>This package provides support for IBM Websphere MQ (MQSeries).
+ </description>
+ <lead>
+ <name>Philippe Tjon A Hen</name>
+ <user>philippe</user>
+ <email>tjonahen@php.net</email>
+ <active>yes</active>
+ </lead>
+ <date>2006-04-20</date>
+<time>21:25:00</time>
+ <version>
+ <release>0.10.0</release>
+ <api>0.10.0</api>
+ </version>
+ <stability>
+ <release>alpha</release>
+ <api>alpha</api>
+ </stability>
+ <license uri="http://www.opensource.org/licenses/bsd-license.php">BSD</license>
+ <notes>Made some changes to the config.m4 configuration file.
+ It shoud now be possible to build the extention without the MQ Client libraries.
+ This would enable the transaction posibilities of MQ.
+ The MQBegin, MQCMit and MQBack function wil now work.
+ Check the README file for additional build instructions.
+ </notes>
+ <contents>
+ <dir name="/">
+ <dir name="examples">
+ <file name="connx.php" role="doc" />
+ <file name="get.php" role="doc" />
+ <file name="msgid.php" role="doc" />
+ <file name="msgidput.php" role="doc" />
+ <file name="put.php" role="doc" />
+ <file name="transaction.php" role="doc" />
+ </dir> <!-- //examples -->
+ <file name="config.m4" role="src" />
+ <file name="CREDITS" role="src" />
+ <file name="mqseries.c" role="src" />
+ <file name="mqseries.dsp" role="src" />
+ <file name="mqseries_init_const.h" role="src" />
+ <file name="mqseries_reason_texts.h" role="src" />
+ <file name="php_mqseries.h" role="src" />
+ <file name="README" role="src" />
+ </dir> <!-- / -->
+ </contents>
+ <dependencies>
+ <required>
+ <php>
+ <min>4.0.0</min>
+ </php>
+ <pearinstaller>
+ <min>1.4.0b1</min>
+ </pearinstaller>
+ </required>
+ </dependencies>
+ <providesextension>mqseries</providesextension>
+ <extsrcrelease />
+ <changelog>
+ <release>
+ <version>
+ <release>0.10.0</release>
+ <api>0.10.0</api>
+ </version>
+ <stability>
+ <release>alpha</release>
+ <api>alpha</api>
+ </stability>
+ <date>2006-04-20</date>
+ <license uri="http://www.opensource.org/licenses/bsd-license.php">BSD</license>
+ <notes>Made some changes to the config.m4 configuration file.
+ It shoud now be possible to build the extention without the MQ Client libraries.
+ This would enable the transaction posibilities of MQ.
+ The MQBegin, MQCMit and MQBack function wil now work.
+ Check the README file for additional build instructions.
+ </notes>
+ </release>
+ <release>
+ <version>
+ <release>0.9.0</release>
+ <api>0.9.0</api>
+ </version>
+ <stability>
+ <release>alpha</release>
+ <api>alpha</api>
+ </stability>
+ <date>2006-04-16</date>
+ <license uri="http://www.opensource.org/licenses/bsd-license.php">BSD</license>
+ <notes>mostly bug fixes, especially the msgId and correlId
+ </notes>
+ </release>
+ <release>
+ <version>
+ <release>0.8.0</release>
+ <api>0.8.0</api>
+ </version>
+ <stability>
+ <release>alpha</release>
+ <api>alpha</api>
+ </stability>
+ <date>2005-04-07</date>
+ <license uri="http://www.opensource.org/licenses/bsd-license.php">BSD</license>
+ <notes>Added some extra mqseries implementation. (mqconnx and mqput1)
+Changed all signatures. Each method now mimics the actual MQSeries api.
+ </notes>
+ </release>
+ <release>
+ <version>
+ <release>0.7.0</release>
+ <api>0.7.0</api>
+ </version>
+ <stability>
+ <release>alpha</release>
+ <api>alpha</api>
+ </stability>
+ <date>2003-05-15</date>
+ <license uri="http://www.opensource.org/licenses/bsd-license.php">BSD</license>
+ <notes>- Release 0.7.0
+- Initial Release
+ </notes>
+ </release>
+ </changelog>
</package>
http://cvs.php.net/viewcvs.cgi/pecl/mqseries/php_mqseries.h?r1=1.2&r2=1.3&diff_format=u
Index: pecl/mqseries/php_mqseries.h
diff -u pecl/mqseries/php_mqseries.h:1.2 pecl/mqseries/php_mqseries.h:1.3
--- pecl/mqseries/php_mqseries.h:1.2 Mon May 19 09:10:11 2003
+++ pecl/mqseries/php_mqseries.h Sat Apr 22 18:59:58 2006
@@ -28,9 +28,10 @@
This code cannot simply be copied and put under the GNU Public License or
any other GPL-like (LGPL, GPL2) License.
- $Id: php_mqseries.h,v 1.2 2003/05/19 09:10:11 mbretter Exp $
+ $Id: php_mqseries.h,v 1.3 2006/04/22 18:59:58 philippe Exp $
Author: Michael Bretterklieber <mbretter@jawa.at>
+ philippe Tjon A Hen <tjonahen@zonnet.nl>
*/
#ifndef PHP_MQSERIES_H
@@ -39,6 +40,7 @@
#include "cmqc.h" /* MQI */
#include "cmqcfc.h" /* PCF */
#include "cmqbc.h" /* MQAI */
+#include "cmqxc.h" /* MQCD */
#define phpext_mqseries_ptr &mqseries_module_entry
@@ -57,8 +59,6 @@
typedef struct {
int id;
MQHCONN conn;
- MQLONG comp_code; /* Completion code */
- MQLONG reason; /* Qualifying reason */
} mqseries_descriptor;
typedef struct {
@@ -67,22 +67,34 @@
MQHCONN *conn;
} mqseries_obj;
+typedef struct {
+ int id;
+ PMQBYTE bytes;
+} mqseries_bytes;
+
+#define ZEND_FETCH_RESOURCE_HELPER(rsrc, rsrc_type, passed_id, default_id, \
resource_type_name, resource_type) \ + rsrc = (rsrc_type) \
zend_fetch_resource(passed_id TSRMLS_CC, default_id, resource_type_name, NULL, 1, \
resource_type); +
+
PHP_MINIT_FUNCTION(mqseries);
PHP_MSHUTDOWN_FUNCTION(mqseries);
PHP_RINIT_FUNCTION(mqseries);
PHP_RSHUTDOWN_FUNCTION(mqseries);
PHP_MINFO_FUNCTION(mqseries);
+PHP_FUNCTION(mqseries_back);
+PHP_FUNCTION(mqseries_begin);
+PHP_FUNCTION(mqseries_close);
+PHP_FUNCTION(mqseries_cmit);
PHP_FUNCTION(mqseries_conn);
+PHP_FUNCTION(mqseries_connx);
PHP_FUNCTION(mqseries_disc);
-PHP_FUNCTION(mqseries_open);
PHP_FUNCTION(mqseries_get);
+PHP_FUNCTION(mqseries_inq);
+PHP_FUNCTION(mqseries_open);
PHP_FUNCTION(mqseries_put);
-PHP_FUNCTION(mqseries_begin);
-PHP_FUNCTION(mqseries_cmit);
-PHP_FUNCTION(mqseries_back);
-PHP_FUNCTION(mqseries_close);
-PHP_FUNCTION(mqseries_disc);
+PHP_FUNCTION(mqseries_put1);
+PHP_FUNCTION(mqseries_set);
PHP_FUNCTION(mqseries_error);
PHP_FUNCTION(mqseries_strerror);
@@ -101,4 +113,4 @@
* c-basic-offset: 4
* indent-tabs-mode: t
* End:
- */
\ No newline at end of file
+ */
--
PECL CVS Mailing List
To unsubscribe, visit: http://www.php.net/unsub.php
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic