amqp_connection.c
No OneTemporary
Actions

Authored By

Unknown

Size

66 KB

Referenced Files

None

Subscribers

None

amqp_connection.c
View Options

	/*
	+----------------------------------------------------------------------+
	\| PHP Version 5 \|
	+----------------------------------------------------------------------+
	\| Copyright (c) 1997-2007 The PHP Group \|
	+----------------------------------------------------------------------+
	\| This source file is subject to version 3.01 of the PHP license, \|
	\| that is bundled with this package in the file LICENSE, and is \|
	\| available through the world-wide-web at the following url: \|
	\| http://www.php.net/license/3_01.txt \|
	\| If you did not receive a copy of the PHP license and are unable to \|
	\| obtain it through the world-wide-web, please send a note to \|
	\| license@php.net so we can mail you a copy immediately. \|
	+----------------------------------------------------------------------+
	\| Author: Alexandre Kalendarev akalend@mail.ru Copyright (c) 2009-2010 \|
	\| Lead: \|
	\| - Pieter de Zwart \|
	\| Maintainers: \|
	\| - Brad Rodriguez \|
	\| - Jonathan Tansavatdi \|
	+----------------------------------------------------------------------+
	*/


	#ifdef HAVE_CONFIG_H
	#include "config.h"
	#endif

	#include "php.h"
	#include "php_ini.h"
	#include "zend_exceptions.h"

	#ifdef PHP_WIN32
	#if PHP_VERSION_ID >= 80000
	#include <stdint.h>
	#else
	#include "win32/php_stdint.h"
	#endif
	#include "win32/signal.h"
	#else
	#include <signal.h>
	#include <stdint.h>
	#endif

	#if HAVE_LIBRABBITMQ_NEW_LAYOUT
	#include <rabbitmq-c/amqp.h>
	#else
	#include <amqp.h>
	#endif

	#ifdef PHP_WIN32
	#include "win32/unistd.h"
	#else
	#include <unistd.h>
	#endif

	#include "php_amqp.h"
	#include "amqp_channel.h"
	#include "amqp_connection_resource.h"
	#include "amqp_connection.h"

	zend_class_entry *amqp_connection_class_entry;
	#define this_ce amqp_connection_class_entry

	zend_object_handlers amqp_connection_object_handlers;

	#define PHP_AMQP_EXTRACT_CONNECTION_STR(name) \
	zdata = NULL; \
	if (ini_arr && (zdata = zend_hash_str_find(HASH_OF(ini_arr), ZEND_STRL(name))) != NULL) { \
	SEPARATE_ZVAL(zdata); \
	convert_to_string(zdata); \
	} \
	if (zdata && Z_STRLEN_P(zdata) > 0) { \
	zend_update_property_string(this_ce, PHP_AMQP_COMPAT_OBJ_P(getThis()), ZEND_STRL(name), Z_STRVAL_P(zdata)); \
	} else if (strlen(INI_STR("amqp." name)) > 0) { \
	zend_update_property_string( \
	this_ce, \
	PHP_AMQP_COMPAT_OBJ_P(getThis()), \
	ZEND_STRL(name), \
	INI_STR("amqp." name) \
	); \
	}

	#define PHP_AMQP_EXTRACT_CONNECTION_BOOL(name) \
	zdata = NULL; \
	if (ini_arr && (zdata = zend_hash_str_find(HASH_OF(ini_arr), ZEND_STRL(name))) != NULL) { \
	SEPARATE_ZVAL(zdata); \
	convert_to_long(zdata); \
	} \
	if (zdata) { \
	zend_update_property_bool(this_ce, PHP_AMQP_COMPAT_OBJ_P(getThis()), ZEND_STRL(name), Z_LVAL_P(zdata)); \
	} else { \
	zend_update_property_bool(this_ce, PHP_AMQP_COMPAT_OBJ_P(getThis()), ZEND_STRL(name), INI_INT("amqp." name)); \
	}

	static int php_amqp_connection_resource_deleter(zval el, amqp_connection_resource connection_resource)
	{
	if (Z_RES_P(el)->ptr == connection_resource) {
	return ZEND_HASH_APPLY_REMOVE \| ZEND_HASH_APPLY_STOP;
	}

	return ZEND_HASH_APPLY_KEEP;
	}

	static size_t php_amqp_get_connection_hash(amqp_connection_params params, char *hash)
	{
	return spprintf(
	hash,
	0,
	"amqp_conn_res_h:%s_p:%d_v:%s_l:%s_p:%s_f:%d_c:%d_h:%d_cacert:%s_cert:%s_key:%s_sasl_method:%d_connection_name:"
	"%s",
	params->host,
	params->port,
	params->vhost,
	params->login,
	params->password,
	params->frame_max,
	params->channel_max,
	params->heartbeat,
	params->cacert,
	params->cert,
	params->key,
	params->sasl_method,
	params->connection_name
	);
	}

	static void php_amqp_cleanup_connection_resource(amqp_connection_resource *connection_resource)
	{
	if (!connection_resource) {
	return;
	}

	zend_resource *resource = connection_resource->resource;

	connection_resource->parent->connection_resource = NULL;
	connection_resource->parent = NULL;

	if (connection_resource->is_dirty) {
	if (connection_resource->is_persistent) {
	zend_hash_apply_with_argument(
	&EG(persistent_list),
	(apply_func_arg_t) php_amqp_connection_resource_deleter,
	(void *) connection_resource
	);
	}

	zend_list_delete(resource);
	} else {
	if (connection_resource->is_persistent) {
	connection_resource->resource = NULL;
	}

	if (connection_resource->resource != NULL) {
	zend_list_delete(resource);
	}
	}
	}

	static void php_amqp_disconnect(amqp_connection_resource *resource)
	{
	php_amqp_prepare_for_disconnect(resource);
	php_amqp_cleanup_connection_resource(resource);
	}


	void php_amqp_disconnect_force(amqp_connection_resource *resource)
	{
	php_amqp_prepare_for_disconnect(resource);
	resource->is_dirty = '\1';
	php_amqp_cleanup_connection_resource(resource);
	}

	/**
	* php_amqp_connect
	* handles connecting to amqp
	* called by connect(), pconnect(), reconnect(), preconnect()
	*/
	int php_amqp_connect(amqp_connection_object *connection, bool persistent, INTERNAL_FUNCTION_PARAMETERS)
	{
	zval rv;

	char *key = NULL;
	size_t key_len = 0;

	if (connection->connection_resource) {
	/* Clean up old memory allocations which are now invalid (new connection) */
	php_amqp_cleanup_connection_resource(connection->connection_resource);
	}

	assert(connection->connection_resource == NULL);

	amqp_connection_params connection_params;

	connection_params.host = PHP_AMQP_READ_THIS_PROP_STR("host");
	connection_params.port = (int) PHP_AMQP_READ_THIS_PROP_LONG("port");
	connection_params.vhost = PHP_AMQP_READ_THIS_PROP_STR("vhost");
	connection_params.login = PHP_AMQP_READ_THIS_PROP_STR("login");
	connection_params.password = PHP_AMQP_READ_THIS_PROP_STR("password");
	connection_params.frame_max = (int) PHP_AMQP_READ_THIS_PROP_LONG("frameMax");
	connection_params.channel_max = (int) PHP_AMQP_READ_THIS_PROP_LONG("channelMax");
	connection_params.heartbeat = (int) PHP_AMQP_READ_THIS_PROP_LONG("heartbeat");
	connection_params.read_timeout = PHP_AMQP_READ_THIS_PROP_DOUBLE("readTimeout");
	connection_params.write_timeout = PHP_AMQP_READ_THIS_PROP_DOUBLE("writeTimeout");
	connection_params.connect_timeout = PHP_AMQP_READ_THIS_PROP_DOUBLE("connectTimeout");
	connection_params.rpc_timeout = PHP_AMQP_READ_THIS_PROP_DOUBLE("rpcTimeout");
	connection_params.cacert = PHP_AMQP_READ_THIS_PROP_STRLEN("cacert") ? PHP_AMQP_READ_THIS_PROP_STR("cacert") : NULL;
	connection_params.cert = PHP_AMQP_READ_THIS_PROP_STRLEN("cert") ? PHP_AMQP_READ_THIS_PROP_STR("cert") : NULL;
	connection_params.key = PHP_AMQP_READ_THIS_PROP_STRLEN("key") ? PHP_AMQP_READ_THIS_PROP_STR("key") : NULL;
	connection_params.verify = (int) PHP_AMQP_READ_THIS_PROP_BOOL("verify");
	connection_params.sasl_method = (int) PHP_AMQP_READ_THIS_PROP_LONG("saslMethod");
	connection_params.connection_name =
	PHP_AMQP_READ_THIS_PROP_STRLEN("connectionName") ? PHP_AMQP_READ_THIS_PROP_STR("connectionName") : NULL;

	if (persistent) {
	zend_resource *le = NULL;

	/* Look for an established resource */
	key_len = php_amqp_get_connection_hash(&connection_params, &key);

	if ((le = zend_hash_str_find_ptr(&EG(persistent_list), key, key_len)) != NULL) {
	efree(key);

	if (le->type != le_amqp_connection_resource_persistent) {
	/* hash conflict, given name associate with non-amqp persistent connection resource */
	zend_throw_exception(
	amqp_connection_exception_class_entry,
	"Connection hash conflict detected. Persistent connection found that does not belong to AMQP.",
	0
	);
	return 0;
	}

	/* An entry for this connection resource already exists */
	/* Stash the connection resource in the connection */
	connection->connection_resource = le->ptr;

	if (connection->connection_resource->resource != NULL) {
	/* resource in use! */
	connection->connection_resource = NULL;

	zend_throw_exception(
	amqp_connection_exception_class_entry,
	"There are already established persistent connection to the same resource.",
	0
	);
	return 0;
	}

	connection->connection_resource->resource = zend_register_resource(
	connection->connection_resource,
	persistent ? le_amqp_connection_resource_persistent : le_amqp_connection_resource
	);
	connection->connection_resource->parent = connection;

	/* Set desired timeouts */
	if (php_amqp_set_resource_read_timeout(
	connection->connection_resource,
	PHP_AMQP_READ_THIS_PROP_DOUBLE("readTimeout")
	) == 0 \|\|
	php_amqp_set_resource_write_timeout(
	connection->connection_resource,
	PHP_AMQP_READ_THIS_PROP_DOUBLE("writeTimeout")
	) == 0 \|\|
	php_amqp_set_resource_rpc_timeout(
	connection->connection_resource,
	PHP_AMQP_READ_THIS_PROP_DOUBLE("rpcTimeout")
	) == 0) {

	php_amqp_disconnect_force(connection->connection_resource);
	return 0;
	}

	/* Set connection status to connected */
	connection->connection_resource->is_connected = '\1';
	connection->connection_resource->is_persistent = persistent;

	return 1;
	}

	efree(key);
	}

	connection->connection_resource = connection_resource_constructor(&connection_params, persistent);

	if (connection->connection_resource == NULL) {
	return 0;
	}

	connection->connection_resource->resource = zend_register_resource(
	connection->connection_resource,
	persistent ? le_amqp_connection_resource_persistent : le_amqp_connection_resource
	);
	connection->connection_resource->parent = connection;

	/* Set connection status to connected */
	connection->connection_resource->is_connected = '\1';

	if (persistent) {
	connection->connection_resource->is_persistent = persistent;

	key_len = php_amqp_get_connection_hash(&connection_params, &key);

	zend_resource new_le;

	/* Store a reference in the persistence list */
	new_le.ptr = connection->connection_resource;
	new_le.type = le_amqp_connection_resource_persistent;

	if (!zend_hash_str_update_mem(&EG(persistent_list), key, key_len, &new_le, sizeof(zend_resource))) {
	efree(key);
	php_amqp_disconnect_force(connection->connection_resource);

	zend_throw_exception(
	amqp_connection_exception_class_entry,
	"Could not store persistent connection in pool.",
	0
	);

	return 0;
	}
	efree(key);
	}

	return 1;
	}

	void amqp_connection_free(zend_object *object)
	{
	amqp_connection_object *connection = PHP_AMQP_FETCH_CONNECTION(object);

	if (connection->connection_resource) {
	php_amqp_disconnect(connection->connection_resource);
	}

	zend_object_std_dtor(&connection->zo);
	}

	zend_object amqp_connection_ctor(zend_class_entry ce)
	{
	amqp_connection_object *connection =
	(amqp_connection_object *) ecalloc(1, sizeof(amqp_connection_object) + zend_object_properties_size(ce));

	zend_object_std_init(&connection->zo, ce);
	AMQP_OBJECT_PROPERTIES_INIT(connection->zo, ce);

	connection->zo.handlers = &amqp_connection_object_handlers;

	return &connection->zo;
	}


	/* {{{ proto AMQPConnection::__construct([array optional])
	* The array can contain 'host', 'port', 'login', 'password', 'vhost', 'read_timeout', 'write_timeout', 'connect_timeout', 'rpc_timeout' and 'timeout' (deprecated) indexes
	*/
	static PHP_METHOD(amqp_connection_class, __construct)
	{
	zval *ini_arr = NULL;

	zval *zdata = NULL;

	/* Parse out the method parameters */
	if (zend_parse_parameters(ZEND_NUM_ARGS(), "\|a/", &ini_arr) == FAILURE) {
	RETURN_THROWS();
	}

	/* Pull the login out of the $params array */
	zdata = NULL;
	if (ini_arr && (zdata = zend_hash_str_find(HASH_OF(ini_arr), ZEND_STRL("login"))) != NULL) {
	SEPARATE_ZVAL(zdata);
	convert_to_string(zdata);
	}
	/* Validate the given login */
	if (zdata && Z_STRLEN_P(zdata) > 0) {
	if (!php_amqp_is_valid_credential(Z_STR_P(zdata))) {
	zend_throw_exception_ex(
	amqp_connection_exception_class_entry,
	0,
	"Parameter 'login' exceeds %d character limit.",
	PHP_AMQP_MAX_CREDENTIALS_LENGTH
	);
	return;
	}

	zend_update_property(this_ce, PHP_AMQP_COMPAT_OBJ_P(getThis()), ZEND_STRL("login"), zdata);
	} else {
	zend_update_property_string(
	this_ce,
	PHP_AMQP_COMPAT_OBJ_P(getThis()),
	ZEND_STRL("login"),
	INI_STR("amqp.login")
	);
	}

	/* Pull the password out of the $params array */
	zdata = NULL;
	if (ini_arr && (zdata = zend_hash_str_find(HASH_OF(ini_arr), ZEND_STRL("password"))) != NULL) {
	SEPARATE_ZVAL(zdata);
	convert_to_string(zdata);
	}
	/* Validate the given password */
	if (zdata && Z_STRLEN_P(zdata) > 0) {
	if (!php_amqp_is_valid_credential(Z_STR_P(zdata))) {
	zend_throw_exception_ex(
	amqp_connection_exception_class_entry,
	0,
	"Parameter 'password' exceeds %d character limit.",
	PHP_AMQP_MAX_CREDENTIALS_LENGTH
	);
	return;
	}

	zend_update_property_stringl(
	this_ce,
	PHP_AMQP_COMPAT_OBJ_P(getThis()),
	ZEND_STRL("password"),
	Z_STRVAL_P(zdata),
	Z_STRLEN_P(zdata)
	);
	} else {
	zend_update_property_string(
	this_ce,
	PHP_AMQP_COMPAT_OBJ_P(getThis()),
	ZEND_STRL("password"),
	INI_STR("amqp.password")
	);
	}

	/* Pull the host out of the $params array */
	zdata = NULL;
	if (ini_arr && (zdata = zend_hash_str_find(HASH_OF(ini_arr), ZEND_STRL("host"))) != NULL) {
	SEPARATE_ZVAL(zdata);
	convert_to_string(zdata);
	}
	/* Validate the given host */
	if (zdata && Z_STRLEN_P(zdata) > 0) {
	if (!php_amqp_is_valid_identifier(Z_STR_P(zdata))) {
	zend_throw_exception_ex(
	amqp_connection_exception_class_entry,
	0,
	"Parameter 'host' exceeds %d character limit.",
	PHP_AMQP_MAX_IDENTIFIER_LENGTH
	);
	return;
	}

	zend_update_property_stringl(
	this_ce,
	PHP_AMQP_COMPAT_OBJ_P(getThis()),
	ZEND_STRL("host"),
	Z_STRVAL_P(zdata),
	Z_STRLEN_P(zdata)
	);
	} else {
	zend_update_property_string(this_ce, PHP_AMQP_COMPAT_OBJ_P(getThis()), ZEND_STRL("host"), INI_STR("amqp.host"));
	}

	/* Pull the vhost out of the $params array */
	zdata = NULL;
	if (ini_arr && (zdata = zend_hash_str_find(HASH_OF(ini_arr), ZEND_STRL("vhost"))) != NULL) {
	SEPARATE_ZVAL(zdata);
	convert_to_string(zdata);
	}
	/* Validate the given vhost */
	if (zdata && Z_STRLEN_P(zdata) > 0) {
	if (!php_amqp_is_valid_identifier(Z_STR_P(zdata))) {
	zend_throw_exception_ex(
	amqp_connection_exception_class_entry,
	0,
	"Parameter 'vhost' exceeds %d character limit.",
	PHP_AMQP_MAX_IDENTIFIER_LENGTH
	);
	return;
	}

	zend_update_property_stringl(
	this_ce,
	PHP_AMQP_COMPAT_OBJ_P(getThis()),
	ZEND_STRL("vhost"),
	Z_STRVAL_P(zdata),
	Z_STRLEN_P(zdata)
	);
	} else {
	zend_update_property_string(
	this_ce,
	PHP_AMQP_COMPAT_OBJ_P(getThis()),
	ZEND_STRL("vhost"),
	INI_STR("amqp.vhost")
	);
	}

	zend_update_property_long(this_ce, PHP_AMQP_COMPAT_OBJ_P(getThis()), ZEND_STRL("port"), INI_INT("amqp.port"));

	if (ini_arr && (zdata = zend_hash_str_find(HASH_OF(ini_arr), ZEND_STRL("port"))) != NULL) {
	SEPARATE_ZVAL(zdata);
	convert_to_long(zdata);

	if (!php_amqp_is_valid_port(Z_LVAL_P(zdata))) {
	zend_throw_exception_ex(
	amqp_connection_exception_class_entry,
	0,
	"Parameter 'port' must be a valid port number between %d and %d.",
	PHP_AMQP_MIN_PORT,
	PHP_AMQP_MAX_PORT
	);
	return;
	}

	zend_update_property_long(this_ce, PHP_AMQP_COMPAT_OBJ_P(getThis()), ZEND_STRL("port"), Z_LVAL_P(zdata));
	}

	zend_update_property_double(
	this_ce,
	PHP_AMQP_COMPAT_OBJ_P(getThis()),
	ZEND_STRL("readTimeout"),
	INI_FLT("amqp.read_timeout")
	);

	if (ini_arr && (zdata = zend_hash_str_find(HASH_OF(ini_arr), ZEND_STRL("read_timeout"))) != NULL) {
	SEPARATE_ZVAL(zdata);
	convert_to_double(zdata);

	if (!php_amqp_is_valid_timeout(Z_DVAL_P(zdata))) {
	zend_throw_exception(
	amqp_connection_exception_class_entry,
	"Parameter 'read_timeout' must be greater than or equal to zero.",
	0
	);
	return;
	}

	zend_update_property_double(
	this_ce,
	PHP_AMQP_COMPAT_OBJ_P(getThis()),
	ZEND_STRL("readTimeout"),
	Z_DVAL_P(zdata)
	);

	if (ini_arr && (zdata = zend_hash_str_find(HASH_OF(ini_arr), ZEND_STRL("timeout"))) != NULL) {
	/* 'read_timeout' takes precedence on 'timeout' but users have to know this */
	php_error_docref(NULL, E_NOTICE, "Parameter 'timeout' is deprecated, 'read_timeout' used instead");
	}

	} else if (ini_arr && (zdata = zend_hash_str_find(HASH_OF(ini_arr), ZEND_STRL("timeout"))) != NULL) {

	php_error_docref(NULL, E_DEPRECATED, "Parameter 'timeout' is deprecated; use 'read_timeout' instead");

	SEPARATE_ZVAL(zdata);
	convert_to_double(zdata);

	if (!php_amqp_is_valid_timeout(Z_DVAL_P(zdata))) {
	zend_throw_exception(
	amqp_connection_exception_class_entry,
	"Parameter 'timeout' must be greater than or equal to zero.",
	0
	);
	return;
	}

	zend_update_property_double(
	this_ce,
	PHP_AMQP_COMPAT_OBJ_P(getThis()),
	ZEND_STRL("readTimeout"),
	Z_DVAL_P(zdata)
	);
	} else {

	assert(DEFAULT_TIMEOUT != NULL);
	if (strcmp(DEFAULT_TIMEOUT, INI_STR("amqp.timeout")) != 0) {
	php_error_docref(
	NULL,
	E_DEPRECATED,
	"INI setting 'amqp.timeout' is deprecated; use 'amqp.read_timeout' instead"
	);

	if (strcmp(DEFAULT_READ_TIMEOUT, INI_STR("amqp.read_timeout")) == 0) {
	zend_update_property_double(
	this_ce,
	PHP_AMQP_COMPAT_OBJ_P(getThis()),
	ZEND_STRL("readTimeout"),
	INI_FLT("amqp.timeout")
	);
	} else {
	php_error_docref(
	NULL,
	E_NOTICE,
	"INI setting 'amqp.read_timeout' will be used instead of 'amqp.timeout'"
	);
	zend_update_property_double(
	this_ce,
	PHP_AMQP_COMPAT_OBJ_P(getThis()),
	ZEND_STRL("readTimeout"),
	INI_FLT("amqp.read_timeout")
	);
	}
	} else {
	zend_update_property_double(
	this_ce,
	PHP_AMQP_COMPAT_OBJ_P(getThis()),
	ZEND_STRL("readTimeout"),
	INI_FLT("amqp.read_timeout")
	);
	}
	}

	zend_update_property_double(
	this_ce,
	PHP_AMQP_COMPAT_OBJ_P(getThis()),
	ZEND_STRL("writeTimeout"),
	INI_FLT("amqp.write_timeout")
	);

	if (ini_arr && (zdata = zend_hash_str_find(HASH_OF(ini_arr), ZEND_STRL("write_timeout"))) != NULL) {
	SEPARATE_ZVAL(zdata);
	convert_to_double(zdata);

	if (!php_amqp_is_valid_timeout(Z_DVAL_P(zdata))) {
	zend_throw_exception(
	amqp_connection_exception_class_entry,
	"Parameter 'write_timeout' must be greater than or equal to zero.",
	0
	);
	return;
	}

	zend_update_property_double(
	this_ce,
	PHP_AMQP_COMPAT_OBJ_P(getThis()),
	ZEND_STRL("writeTimeout"),
	Z_DVAL_P(zdata)
	);
	}

	zend_update_property_double(
	this_ce,
	PHP_AMQP_COMPAT_OBJ_P(getThis()),
	ZEND_STRL("rpcTimeout"),
	INI_FLT("amqp.rpc_timeout")
	);

	if (ini_arr && (zdata = zend_hash_str_find(HASH_OF(ini_arr), ZEND_STRL("rpc_timeout"))) != NULL) {
	SEPARATE_ZVAL(zdata);
	convert_to_double(zdata);

	if (!php_amqp_is_valid_timeout(Z_DVAL_P(zdata))) {
	zend_throw_exception(
	amqp_connection_exception_class_entry,
	"Parameter 'rpc_timeout' must be greater than or equal to zero.",
	0
	);
	RETURN_THROWS();
	}

	zend_update_property_double(
	this_ce,
	PHP_AMQP_COMPAT_OBJ_P(getThis()),
	ZEND_STRL("rpcTimeout"),
	Z_DVAL_P(zdata)
	);
	}

	zend_update_property_double(
	this_ce,
	PHP_AMQP_COMPAT_OBJ_P(getThis()),
	ZEND_STRL("connectTimeout"),
	INI_FLT("amqp.connect_timeout")
	);

	if (ini_arr && (zdata = zend_hash_str_find(HASH_OF(ini_arr), ZEND_STRL("connect_timeout"))) != NULL) {
	SEPARATE_ZVAL(zdata);
	convert_to_double(zdata);

	if (!php_amqp_is_valid_timeout(Z_DVAL_P(zdata))) {
	zend_throw_exception(
	amqp_connection_exception_class_entry,
	"Parameter 'connect_timeout' must be greater than or equal to zero.",
	0
	);
	RETURN_THROWS();
	}

	zend_update_property_double(
	this_ce,
	PHP_AMQP_COMPAT_OBJ_P(getThis()),
	ZEND_STRL("connectTimeout"),
	Z_DVAL_P(zdata)
	);
	}

	zend_update_property_long(
	this_ce,
	PHP_AMQP_COMPAT_OBJ_P(getThis()),
	ZEND_STRL("channelMax"),
	INI_INT("amqp.channel_max")
	);

	if (ini_arr && (zdata = zend_hash_str_find(HASH_OF(ini_arr), ZEND_STRL("channel_max"))) != NULL) {
	SEPARATE_ZVAL(zdata);
	convert_to_long(zdata);

	if (!php_amqp_is_valid_channel_max(Z_LVAL_P(zdata))) {
	zend_throw_exception(amqp_connection_exception_class_entry, "Parameter 'channel_max' is out of range.", 0);
	RETURN_THROWS();
	}

	if (Z_LVAL_P(zdata) == 0) {
	zend_update_property_long(
	this_ce,
	PHP_AMQP_COMPAT_OBJ_P(getThis()),
	ZEND_STRL("channelMax"),
	PHP_AMQP_DEFAULT_CHANNEL_MAX
	);
	} else {
	zend_update_property_long(
	this_ce,
	PHP_AMQP_COMPAT_OBJ_P(getThis()),
	ZEND_STRL("channelMax"),
	Z_LVAL_P(zdata)
	);
	}
	}

	zend_update_property_long(
	this_ce,
	PHP_AMQP_COMPAT_OBJ_P(getThis()),
	ZEND_STRL("frameMax"),
	INI_INT("amqp.frame_max")
	);

	if (ini_arr && (zdata = zend_hash_str_find(HASH_OF(ini_arr), ZEND_STRL("frame_max"))) != NULL) {
	SEPARATE_ZVAL(zdata);
	convert_to_long(zdata);
	if (!php_amqp_is_valid_frame_size_max(Z_LVAL_P(zdata))) {
	zend_throw_exception(amqp_connection_exception_class_entry, "Parameter 'frame_max' is out of range.", 0);
	RETURN_THROWS();
	}

	if (Z_LVAL_P(zdata) == 0) {
	zend_update_property_long(
	this_ce,
	PHP_AMQP_COMPAT_OBJ_P(getThis()),
	ZEND_STRL("frameMax"),
	PHP_AMQP_DEFAULT_FRAME_MAX
	);
	} else {
	zend_update_property_long(
	this_ce,
	PHP_AMQP_COMPAT_OBJ_P(getThis()),
	ZEND_STRL("frameMax"),
	Z_LVAL_P(zdata)
	);
	}
	}

	zend_update_property_long(
	this_ce,
	PHP_AMQP_COMPAT_OBJ_P(getThis()),
	ZEND_STRL("heartbeat"),
	INI_INT("amqp.heartbeat")
	);

	if (ini_arr && (zdata = zend_hash_str_find(HASH_OF(ini_arr), ZEND_STRL("heartbeat"))) != NULL) {
	SEPARATE_ZVAL(zdata);
	convert_to_long(zdata);
	if (!php_amqp_is_valid_heartbeat(Z_LVAL_P(zdata))) {
	zend_throw_exception(amqp_connection_exception_class_entry, "Parameter 'heartbeat' is out of range.", 0);
	RETURN_THROWS();
	}

	zend_update_property_long(this_ce, PHP_AMQP_COMPAT_OBJ_P(getThis()), ZEND_STRL("heartbeat"), Z_LVAL_P(zdata));
	}

	zend_update_property_long(
	this_ce,
	PHP_AMQP_COMPAT_OBJ_P(getThis()),
	ZEND_STRL("saslMethod"),
	INI_INT("amqp.sasl_method")
	);

	if (ini_arr && (zdata = zend_hash_str_find(HASH_OF(ini_arr), ZEND_STRL("sasl_method"))) != NULL) {
	SEPARATE_ZVAL(zdata);
	convert_to_long(zdata);
	zend_update_property_long(this_ce, PHP_AMQP_COMPAT_OBJ_P(getThis()), ZEND_STRL("saslMethod"), Z_LVAL_P(zdata));
	}


	PHP_AMQP_EXTRACT_CONNECTION_STR("cacert");
	PHP_AMQP_EXTRACT_CONNECTION_STR("key");
	PHP_AMQP_EXTRACT_CONNECTION_STR("cert");

	PHP_AMQP_EXTRACT_CONNECTION_BOOL("verify");

	/* Pull the connection_name out of the $params array */
	zdata = NULL;
	if (ini_arr && (zdata = zend_hash_str_find(HASH_OF(ini_arr), ZEND_STRL("connection_name"))) != NULL) {
	SEPARATE_ZVAL(zdata);
	convert_to_string(zdata);
	}
	if (zdata && Z_STRLEN_P(zdata) > 0) {
	zend_update_property_string(
	this_ce,
	PHP_AMQP_COMPAT_OBJ_P(getThis()),
	ZEND_STRL("connectionName"),
	Z_STRVAL_P(zdata)
	);
	}
	}
	/* }}} */


	/* {{{ proto amqp::isConnected()
	check amqp connection */
	static PHP_METHOD(amqp_connection_class, isConnected)
	{
	amqp_connection_object *connection;

	PHP_AMQP_NOPARAMS()

	/* Get the connection object out of the store */
	connection = PHP_AMQP_GET_CONNECTION(getThis());

	RETURN_BOOL(connection->connection_resource != NULL && connection->connection_resource->is_connected);
	}
	/* }}} */


	/* {{{ proto amqp::connect()
	create amqp connection */
	static PHP_METHOD(amqp_connection_class, connect)
	{
	amqp_connection_object *connection;

	PHP_AMQP_NOPARAMS()

	/* Get the connection object out of the store */
	connection = PHP_AMQP_GET_CONNECTION(getThis());

	if (connection->connection_resource && connection->connection_resource->is_connected) {
	if (connection->connection_resource->is_persistent) {
	zend_throw_exception(
	amqp_connection_exception_class_entry,
	"Attempt to start transient connection while persistent one already established. Continue.",
	0
	);
	}

	return;
	}

	/* Actually connect this resource to the broker */
	php_amqp_connect(connection, 0, INTERNAL_FUNCTION_PARAM_PASSTHRU);
	}
	/* }}} */


	/* {{{ proto amqp::connect()
	create amqp connection */
	static PHP_METHOD(amqp_connection_class, pconnect)
	{
	amqp_connection_object *connection;

	PHP_AMQP_NOPARAMS()

	/* Get the connection object out of the store */
	connection = PHP_AMQP_GET_CONNECTION(getThis());

	if (connection->connection_resource && connection->connection_resource->is_connected) {

	assert(connection->connection_resource != NULL);
	if (!connection->connection_resource->is_persistent) {
	zend_throw_exception(
	amqp_connection_exception_class_entry,
	"Attempt to start persistent connection while transient one already established. Continue.",
	0
	);
	}

	return;
	}

	/* Actually connect this resource to the broker or use stored connection */
	php_amqp_connect(connection, 1, INTERNAL_FUNCTION_PARAM_PASSTHRU);
	}
	/* }}} */

	#define PERSISTENT_TRANSIENT_EXCEPTION_MESSAGE \
	"Attempted to %s a %s connection while a %s connection is established. Call '%s' instead"

	/* {{{ proto amqp:pdisconnect()
	destroy amqp persistent connection */
	static PHP_METHOD(amqp_connection_class, pdisconnect)
	{
	amqp_connection_object *connection;

	PHP_AMQP_NOPARAMS()

	/* Get the connection object out of the store */
	connection = PHP_AMQP_GET_CONNECTION(getThis());

	if (!connection->connection_resource \|\| !connection->connection_resource->is_connected) {
	return;
	}

	assert(connection->connection_resource != NULL);

	if (!connection->connection_resource->is_persistent) {
	zend_throw_exception_ex(
	amqp_connection_exception_class_entry,
	0,
	PERSISTENT_TRANSIENT_EXCEPTION_MESSAGE,
	"close",
	"persistent",
	"transient",
	"disconnect"
	);
	return;
	}

	php_amqp_disconnect_force(connection->connection_resource);
	}
	/* }}} */


	/* {{{ proto amqp::disconnect()
	destroy amqp connection */
	static PHP_METHOD(amqp_connection_class, disconnect)
	{
	amqp_connection_object *connection;

	PHP_AMQP_NOPARAMS()

	/* Get the connection object out of the store */
	connection = PHP_AMQP_GET_CONNECTION(getThis());

	if (!connection->connection_resource \|\| !connection->connection_resource->is_connected) {
	return;
	}

	if (connection->connection_resource->is_persistent) {
	zend_throw_exception_ex(
	amqp_connection_exception_class_entry,
	0,
	PERSISTENT_TRANSIENT_EXCEPTION_MESSAGE,
	"close",
	"transient",
	"persistent",
	"pdisconnect"
	);
	return;
	}

	assert(connection->connection_resource != NULL);

	php_amqp_disconnect(connection->connection_resource);
	}

	/* }}} */

	/* {{{ proto amqp::reconnect()
	recreate amqp connection */
	static PHP_METHOD(amqp_connection_class, reconnect)
	{
	amqp_connection_object *connection;

	PHP_AMQP_NOPARAMS()

	/* Get the connection object out of the store */
	connection = PHP_AMQP_GET_CONNECTION(getThis());

	if (connection->connection_resource && connection->connection_resource->is_connected) {

	assert(connection->connection_resource != NULL);

	if (connection->connection_resource->is_persistent) {
	zend_throw_exception_ex(
	amqp_connection_exception_class_entry,
	0,
	PERSISTENT_TRANSIENT_EXCEPTION_MESSAGE,
	"reconnect",
	"transient",
	"persistent",
	"preconnect"
	);
	return;
	}

	php_amqp_disconnect(connection->connection_resource);
	}

	php_amqp_connect(connection, 0, INTERNAL_FUNCTION_PARAM_PASSTHRU);
	}
	/* }}} */

	/* {{{ proto amqp::preconnect()
	recreate amqp connection */
	static PHP_METHOD(amqp_connection_class, preconnect)
	{
	amqp_connection_object *connection;

	PHP_AMQP_NOPARAMS()

	/* Get the connection object out of the store */
	connection = PHP_AMQP_GET_CONNECTION(getThis());


	if (connection->connection_resource && connection->connection_resource->is_connected) {

	assert(connection->connection_resource != NULL);

	if (!connection->connection_resource->is_persistent) {
	zend_throw_exception_ex(
	amqp_connection_exception_class_entry,
	0,
	PERSISTENT_TRANSIENT_EXCEPTION_MESSAGE,
	"reconnect",
	"persistent",
	"transient",
	"reconnect"
	);
	return;
	}

	php_amqp_disconnect_force(connection->connection_resource);
	}

	php_amqp_connect(connection, 1, INTERNAL_FUNCTION_PARAM_PASSTHRU);
	}
	/* }}} */


	/* {{{ proto amqp::getLogin()
	get the login */
	static PHP_METHOD(amqp_connection_class, getLogin)
	{
	zval rv;
	PHP_AMQP_NOPARAMS()
	PHP_AMQP_RETURN_THIS_PROP("login");
	}
	/* }}} */


	/* {{{ proto amqp::setLogin(string login)
	set the login */
	static PHP_METHOD(amqp_connection_class, setLogin)
	{
	char *login = NULL;
	size_t login_len = 0;

	/* Get the login from the method params */
	if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &login, &login_len) == FAILURE) {
	RETURN_THROWS();
	}

	/* Validate login length */
	if (login_len > PHP_AMQP_MAX_CREDENTIALS_LENGTH) {
	zend_throw_exception_ex(
	amqp_connection_exception_class_entry,
	0,
	"Parameter 'login' exceeds %d character limit.",
	PHP_AMQP_MAX_CREDENTIALS_LENGTH
	);
	return;
	}

	zend_update_property_stringl(this_ce, PHP_AMQP_COMPAT_OBJ_P(getThis()), ZEND_STRL("login"), login, login_len);
	}
	/* }}} */

	/* {{{ proto amqp::getPassword()
	get the password */
	static PHP_METHOD(amqp_connection_class, getPassword)
	{
	zval rv;
	PHP_AMQP_NOPARAMS()
	PHP_AMQP_RETURN_THIS_PROP("password");
	}
	/* }}} */


	/* {{{ proto amqp::setPassword(string password)
	set the password */
	static PHP_METHOD(amqp_connection_class, setPassword)
	{
	char *password = NULL;
	size_t password_len = 0;

	/* Get the password from the method params */
	if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &password, &password_len) == FAILURE) {
	RETURN_THROWS();
	}

	/* Validate password length */
	if (password_len > PHP_AMQP_MAX_CREDENTIALS_LENGTH) {
	zend_throw_exception_ex(
	amqp_connection_exception_class_entry,
	0,
	"Parameter 'password' exceeds %d character limit.",
	PHP_AMQP_MAX_CREDENTIALS_LENGTH
	);
	return;
	}

	zend_update_property_stringl(
	this_ce,
	PHP_AMQP_COMPAT_OBJ_P(getThis()),
	ZEND_STRL("password"),
	password,
	password_len
	);
	}
	/* }}} */


	/* {{{ proto amqp::getHost()
	get the host */
	static PHP_METHOD(amqp_connection_class, getHost)
	{
	zval rv;
	PHP_AMQP_NOPARAMS()
	PHP_AMQP_RETURN_THIS_PROP("host");
	}
	/* }}} */


	/* {{{ proto amqp::setHost(string host)
	set the host */
	static PHP_METHOD(amqp_connection_class, setHost)
	{
	char *host = NULL;
	size_t host_len = 0;

	/* Get the host from the method params */
	if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &host, &host_len) == FAILURE) {
	RETURN_THROWS();
	}

	/* Validate host length */
	if (host_len > PHP_AMQP_MAX_IDENTIFIER_LENGTH) {
	zend_throw_exception_ex(
	amqp_connection_exception_class_entry,
	0,
	"Parameter 'host' exceeds %d character limit.",
	PHP_AMQP_MAX_IDENTIFIER_LENGTH
	);
	return;
	}

	zend_update_property_stringl(this_ce, PHP_AMQP_COMPAT_OBJ_P(getThis()), ZEND_STRL("host"), host, host_len);
	}
	/* }}} */


	/* {{{ proto amqp::getPort()
	get the port */
	static PHP_METHOD(amqp_connection_class, getPort)
	{
	zval rv;
	PHP_AMQP_NOPARAMS()
	PHP_AMQP_RETURN_THIS_PROP("port");
	}
	/* }}} */


	/* {{{ proto amqp::setPort(mixed port)
	set the port */
	static PHP_METHOD(amqp_connection_class, setPort)
	{
	zend_long port;

	/* Get the port from the method params */
	if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &port) == FAILURE) {
	RETURN_THROWS();
	}

	/* Check the port value */
	if (!php_amqp_is_valid_port(port)) {
	zend_throw_exception_ex(
	amqp_connection_exception_class_entry,
	0,
	"Parameter 'port' must be a valid port number between %d and %d.",
	PHP_AMQP_MIN_PORT,
	PHP_AMQP_MAX_PORT
	);
	return;
	}

	zend_update_property_long(this_ce, PHP_AMQP_COMPAT_OBJ_P(getThis()), ZEND_STRL("port"), port);
	}
	/* }}} */

	/* {{{ proto amqp::getVhost()
	get the vhost */
	static PHP_METHOD(amqp_connection_class, getVhost)
	{
	zval rv;
	PHP_AMQP_NOPARAMS()
	PHP_AMQP_RETURN_THIS_PROP("vhost");
	}
	/* }}} */


	/* {{{ proto amqp::setVhost(string vhost)
	set the vhost */
	static PHP_METHOD(amqp_connection_class, setVhost)
	{
	char *vhost = NULL;
	size_t vhost_len = 0;

	if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &vhost, &vhost_len) == FAILURE) {
	RETURN_THROWS();
	}

	/* Validate vhost length */
	if (vhost_len > PHP_AMQP_MAX_IDENTIFIER_LENGTH) {
	zend_throw_exception_ex(
	amqp_connection_exception_class_entry,
	0,
	"Parameter 'vhost' exceeds %d characters limit.",
	PHP_AMQP_MAX_IDENTIFIER_LENGTH
	);
	return;
	}

	zend_update_property_stringl(this_ce, PHP_AMQP_COMPAT_OBJ_P(getThis()), ZEND_STRL("vhost"), vhost, vhost_len);
	}
	/* }}} */

	/* {{{ proto amqp::getTimeout()
	@deprecated
	get the timeout */
	static PHP_METHOD(amqp_connection_class, getTimeout)
	{
	php_error_docref(
	NULL,
	E_DEPRECATED,
	"AMQPConnection::getTimeout() method is deprecated; use AMQPConnection::getReadTimeout() instead"
	);

	zval rv;
	PHP_AMQP_NOPARAMS()
	PHP_AMQP_RETURN_THIS_PROP("readTimeout");
	}
	/* }}} */

	/* {{{ proto amqp::setTimeout(double timeout)
	@deprecated
	set the timeout */
	static PHP_METHOD(amqp_connection_class, setTimeout)
	{
	amqp_connection_object *connection;
	double read_timeout;

	php_error_docref(
	NULL,
	E_DEPRECATED,
	"AMQPConnection::setTimeout($timeout) method is deprecated; use AMQPConnection::setReadTimeout($timeout) "
	"instead"
	);

	/* Get the timeout from the method params */
	if (zend_parse_parameters(ZEND_NUM_ARGS(), "d", &read_timeout) == FAILURE) {
	RETURN_THROWS();
	}

	/* Validate timeout */
	if (!php_amqp_is_valid_timeout(read_timeout)) {
	zend_throw_exception(
	amqp_connection_exception_class_entry,
	"Parameter 'timeout' must be greater than or equal to zero.",
	0
	);
	return;
	}

	/* Get the connection object out of the store */
	connection = PHP_AMQP_GET_CONNECTION(getThis());

	zend_update_property_double(this_ce, PHP_AMQP_COMPAT_OBJ_P(getThis()), ZEND_STRL("readTimeout"), read_timeout);

	if (connection->connection_resource && connection->connection_resource->is_connected) {
	if (php_amqp_set_resource_read_timeout(connection->connection_resource, read_timeout) == 0) {

	php_amqp_disconnect_force(connection->connection_resource);

	zend_throw_exception(amqp_connection_exception_class_entry, "Could not set read timeout", 0);
	}
	}
	}
	/* }}} */

	/* {{{ proto amqp::getReadTimeout()
	get the read timeout */
	static PHP_METHOD(amqp_connection_class, getReadTimeout)
	{
	zval rv;
	PHP_AMQP_NOPARAMS()
	PHP_AMQP_RETURN_THIS_PROP("readTimeout");
	}
	/* }}} */

	/* {{{ proto amqp::setReadTimeout(double timeout)
	set read timeout */
	static PHP_METHOD(amqp_connection_class, setReadTimeout)
	{
	amqp_connection_object *connection;
	double read_timeout;

	/* Get the timeout from the method params */
	if (zend_parse_parameters(ZEND_NUM_ARGS(), "d", &read_timeout) == FAILURE) {
	RETURN_THROWS();
	}

	/* Validate timeout */
	if (!php_amqp_is_valid_timeout(read_timeout)) {
	zend_throw_exception(
	amqp_connection_exception_class_entry,
	"Parameter 'readTimeout' must be greater than or equal to zero.",
	0
	);
	return;
	}

	/* Get the connection object out of the store */
	connection = PHP_AMQP_GET_CONNECTION(getThis());

	zend_update_property_double(this_ce, PHP_AMQP_COMPAT_OBJ_P(getThis()), ZEND_STRL("readTimeout"), read_timeout);

	if (connection->connection_resource && connection->connection_resource->is_connected) {
	if (php_amqp_set_resource_read_timeout(connection->connection_resource, read_timeout) == 0) {

	php_amqp_disconnect_force(connection->connection_resource);

	zend_throw_exception(amqp_connection_exception_class_entry, "Could not set read timeout", 0);
	}
	}
	}
	/* }}} */

	/* {{{ proto amqp::getWriteTimeout()
	get write timeout */
	static PHP_METHOD(amqp_connection_class, getWriteTimeout)
	{
	zval rv;
	PHP_AMQP_NOPARAMS()
	PHP_AMQP_RETURN_THIS_PROP("writeTimeout");
	}
	/* }}} */

	/* {{{ proto amqp::setWriteTimeout(double timeout)
	set write timeout */
	static PHP_METHOD(amqp_connection_class, setWriteTimeout)
	{
	amqp_connection_object *connection;
	double write_timeout;

	/* Get the timeout from the method params */
	if (zend_parse_parameters(ZEND_NUM_ARGS(), "d", &write_timeout) == FAILURE) {
	RETURN_THROWS();
	}

	/* Validate timeout */
	if (!php_amqp_is_valid_timeout(write_timeout)) {
	zend_throw_exception(
	amqp_connection_exception_class_entry,
	"Parameter 'writeTimeout' must be greater than or equal to zero.",
	0
	);
	return;
	}

	/* Get the connection object out of the store */
	connection = PHP_AMQP_GET_CONNECTION(getThis());

	zend_update_property_double(this_ce, PHP_AMQP_COMPAT_OBJ_P(getThis()), ZEND_STRL("writeTimeout"), write_timeout);

	if (connection->connection_resource && connection->connection_resource->is_connected) {
	if (php_amqp_set_resource_write_timeout(connection->connection_resource, write_timeout) == 0) {

	php_amqp_disconnect_force(connection->connection_resource);

	zend_throw_exception(amqp_connection_exception_class_entry, "Could not set write timeout", 0);
	}
	}
	}
	/* }}} */

	/* {{{ proto amqp::getRpcTimeout()
	get rpc timeout */
	static PHP_METHOD(amqp_connection_class, getConnectTimeout)
	{
	zval rv;
	PHP_AMQP_NOPARAMS()
	PHP_AMQP_RETURN_THIS_PROP("connectTimeout");
	}
	/* }}} */

	/* {{{ proto amqp::getRpcTimeout()
	get rpc timeout */
	static PHP_METHOD(amqp_connection_class, getRpcTimeout)
	{
	zval rv;
	PHP_AMQP_NOPARAMS()
	PHP_AMQP_RETURN_THIS_PROP("rpcTimeout");
	}
	/* }}} */

	/* {{{ proto amqp::setRpcTimeout(double timeout)
	set rpc timeout */
	static PHP_METHOD(amqp_connection_class, setRpcTimeout)
	{
	amqp_connection_object *connection;
	double rpc_timeout;

	/* Get the timeout from the method params */
	if (zend_parse_parameters(ZEND_NUM_ARGS(), "d", &rpc_timeout) == FAILURE) {
	RETURN_THROWS();
	}

	/* Validate timeout */
	if (!php_amqp_is_valid_timeout(rpc_timeout)) {
	zend_throw_exception(
	amqp_connection_exception_class_entry,
	"Parameter 'rpcTimeout' must be greater than or equal to zero.",
	0
	);
	return;
	}

	/* Get the connection object out of the store */
	connection = PHP_AMQP_GET_CONNECTION(getThis());

	zend_update_property_double(this_ce, PHP_AMQP_COMPAT_OBJ_P(getThis()), ZEND_STRL("rpcTimeout"), rpc_timeout);

	if (connection->connection_resource && connection->connection_resource->is_connected) {
	if (php_amqp_set_resource_rpc_timeout(connection->connection_resource, rpc_timeout) == 0) {

	php_amqp_disconnect_force(connection->connection_resource);

	zend_throw_exception(amqp_connection_exception_class_entry, "Could not set connect timeout", 0);
	}
	}
	}
	/* }}} */

	/* {{{ proto amqp::getUsedChannels()
	Get max used channels number */
	static PHP_METHOD(amqp_connection_class, getUsedChannels)
	{
	amqp_connection_object *connection;

	/* Get the timeout from the method params */
	PHP_AMQP_NOPARAMS()

	/* Get the connection object out of the store */
	connection = PHP_AMQP_GET_CONNECTION(getThis());

	if (!connection->connection_resource \|\| !connection->connection_resource->is_connected) {
	php_error_docref(NULL, E_WARNING, "Connection is not connected.");

	RETURN_LONG(0);
	}

	RETURN_LONG(connection->connection_resource->used_slots);
	}
	/* }}} */

	/* {{{ proto amqp::getMaxChannels()
	Get max supported channels number per connection */
	PHP_METHOD(amqp_connection_class, getMaxChannels)
	{
	zval rv;
	amqp_connection_object *connection;

	PHP_AMQP_NOPARAMS()

	/* Get the connection object out of the store */
	connection = PHP_AMQP_GET_CONNECTION(getThis());

	if (connection->connection_resource && connection->connection_resource->is_connected) {
	RETURN_LONG(connection->connection_resource->max_slots);
	}

	PHP_AMQP_RETURN_THIS_PROP("channelMax");
	}
	/* }}} */

	/* {{{ proto amqp::getMaxFrameSize()
	Get max supported frame size per connection in bytes */
	static PHP_METHOD(amqp_connection_class, getMaxFrameSize)
	{
	zval rv;
	amqp_connection_object *connection;

	PHP_AMQP_NOPARAMS()

	/* Get the connection object out of the store */
	connection = PHP_AMQP_GET_CONNECTION(getThis());

	if (connection->connection_resource && connection->connection_resource->is_connected) {
	RETURN_LONG(amqp_get_frame_max(connection->connection_resource->connection_state));
	}

	PHP_AMQP_RETURN_THIS_PROP("frameMax");
	}
	/* }}} */

	/* {{{ proto amqp::getHeartbeatInterval()
	Get number of seconds between heartbeats of the connection in seconds */
	static PHP_METHOD(amqp_connection_class, getHeartbeatInterval)
	{
	zval rv;
	amqp_connection_object *connection;

	PHP_AMQP_NOPARAMS()

	/* Get the connection object out of the store */
	connection = PHP_AMQP_GET_CONNECTION(getThis());

	if (connection->connection_resource != NULL && connection->connection_resource->is_connected != '\0') {
	RETURN_LONG(amqp_get_heartbeat(connection->connection_resource->connection_state));
	}

	PHP_AMQP_RETURN_THIS_PROP("heartbeat");
	}
	/* }}} */

	/* {{{ proto amqp::isPersistent()
	check whether amqp connection is persistent */
	static PHP_METHOD(amqp_connection_class, isPersistent)
	{
	amqp_connection_object *connection;

	PHP_AMQP_NOPARAMS()

	connection = PHP_AMQP_GET_CONNECTION(getThis());

	RETURN_BOOL(connection->connection_resource && connection->connection_resource->is_persistent);
	}
	/* }}} */


	/* {{{ proto amqp::getCACert() */
	static PHP_METHOD(amqp_connection_class, getCACert)
	{
	zval rv;
	PHP_AMQP_NOPARAMS()
	PHP_AMQP_RETURN_THIS_PROP("cacert");
	}
	/* }}} */

	/* {{{ proto amqp::setCACert(string cacert) */
	static PHP_METHOD(amqp_connection_class, setCACert)
	{
	char *str = NULL;
	size_t str_len = 0;

	if (zend_parse_parameters(ZEND_NUM_ARGS(), "s!", &str, &str_len) == FAILURE) {
	RETURN_THROWS();
	}

	if (str == NULL) {
	zend_update_property_null(this_ce, PHP_AMQP_COMPAT_OBJ_P(getThis()), ZEND_STRL("cacert"));
	} else {
	zend_update_property_stringl(this_ce, PHP_AMQP_COMPAT_OBJ_P(getThis()), ZEND_STRL("cacert"), str, str_len);
	}
	}
	/* }}} */

	/* {{{ proto amqp::getCert() */
	static PHP_METHOD(amqp_connection_class, getCert)
	{
	zval rv;
	PHP_AMQP_NOPARAMS()
	PHP_AMQP_RETURN_THIS_PROP("cert");
	}
	/* }}} */

	/* {{{ proto amqp::setCert(string cert) */
	static PHP_METHOD(amqp_connection_class, setCert)
	{
	char *str = NULL;
	size_t str_len = 0;

	if (zend_parse_parameters(ZEND_NUM_ARGS(), "s!", &str, &str_len) == FAILURE) {
	RETURN_THROWS();
	}

	if (str == NULL) {
	zend_update_property_null(this_ce, PHP_AMQP_COMPAT_OBJ_P(getThis()), ZEND_STRL("cert"));
	} else {
	zend_update_property_stringl(this_ce, PHP_AMQP_COMPAT_OBJ_P(getThis()), ZEND_STRL("cert"), str, str_len);
	}
	}
	/* }}} */

	/* {{{ proto amqp::getKey() */
	static PHP_METHOD(amqp_connection_class, getKey)
	{
	zval rv;
	PHP_AMQP_NOPARAMS()
	PHP_AMQP_RETURN_THIS_PROP("key");
	}
	/* }}} */

	/* {{{ proto amqp::setKey(string key) */
	static PHP_METHOD(amqp_connection_class, setKey)
	{
	char *str = NULL;
	size_t str_len = 0;

	if (zend_parse_parameters(ZEND_NUM_ARGS(), "s!", &str, &str_len) == FAILURE) {
	RETURN_THROWS();
	}

	if (str == NULL) {
	zend_update_property_null(this_ce, PHP_AMQP_COMPAT_OBJ_P(getThis()), ZEND_STRL("key"));
	} else {
	zend_update_property_stringl(this_ce, PHP_AMQP_COMPAT_OBJ_P(getThis()), ZEND_STRL("key"), str, str_len);
	}
	}
	/* }}} */


	/* {{{ proto amqp::getVerify() */
	static PHP_METHOD(amqp_connection_class, getVerify)
	{
	zval rv;
	PHP_AMQP_NOPARAMS()
	PHP_AMQP_RETURN_THIS_PROP("verify");
	}
	/* }}} */

	/* {{{ proto amqp::setVerify(bool verify) */
	static PHP_METHOD(amqp_connection_class, setVerify)
	{
	bool verify = 1;

	if (zend_parse_parameters(ZEND_NUM_ARGS(), "b", &verify) == FAILURE) {
	RETURN_THROWS();
	}

	zend_update_property_bool(this_ce, PHP_AMQP_COMPAT_OBJ_P(getThis()), ZEND_STRL("verify"), verify);
	}
	/* }}} */

	/* {{{ proto amqp::getSaslMethod()
	get sasl method */
	static PHP_METHOD(amqp_connection_class, getSaslMethod)
	{
	zval rv;
	PHP_AMQP_NOPARAMS()
	PHP_AMQP_RETURN_THIS_PROP("saslMethod");
	}
	/* }}} */

	/* {{{ proto amqp::setSaslMethod(mixed method)
	set sasl method */
	static PHP_METHOD(amqp_connection_class, setSaslMethod)
	{
	long method;

	/* Get the port from the method params */
	if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &method) == FAILURE) {
	RETURN_THROWS();
	}

	/* Check the method value */
	if (method != AMQP_SASL_METHOD_PLAIN && method != AMQP_SASL_METHOD_EXTERNAL) {
	zend_throw_exception(
	amqp_connection_exception_class_entry,
	"Invalid SASL method given. Method must be AMQP_SASL_METHOD_PLAIN or AMQP_SASL_METHOD_EXTERNAL.",
	0
	);
	return;
	}

	zend_update_property_long(this_ce, PHP_AMQP_COMPAT_OBJ_P(getThis()), ZEND_STRL("saslMethod"), method);
	}
	/* }}} */

	/* {{{ proto amqp::getConnectionName() */
	static PHP_METHOD(amqp_connection_class, getConnectionName)
	{
	zval rv;
	PHP_AMQP_NOPARAMS()
	PHP_AMQP_RETURN_THIS_PROP("connectionName");
	}
	/* }}} */

	/* {{{ proto amqp::setConnectionName(string connectionName) */
	static PHP_METHOD(amqp_connection_class, setConnectionName)
	{
	char *str = NULL;
	size_t str_len = 0;

	if (zend_parse_parameters(ZEND_NUM_ARGS(), "s!", &str, &str_len) == FAILURE) {
	RETURN_THROWS();
	}
	if (str == NULL) {
	zend_update_property_null(this_ce, PHP_AMQP_COMPAT_OBJ_P(getThis()), ZEND_STRL("connectionName"));
	} else {
	zend_update_property_stringl(
	this_ce,
	PHP_AMQP_COMPAT_OBJ_P(getThis()),
	ZEND_STRL("connectionName"),
	str,
	str_len
	);
	}
	}
	/* }}} */

	/* amqp_connection_class ARG_INFO definition */
	ZEND_BEGIN_ARG_INFO_EX(arginfo_amqp_connection_class__construct, ZEND_SEND_BY_VAL, ZEND_RETURN_VALUE, 0)
	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, credentials, IS_ARRAY, 0, "[]")
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_isConnected, ZEND_SEND_BY_VAL, 0, _IS_BOOL, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_connect, ZEND_SEND_BY_VAL, 0, IS_VOID, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_pconnect, ZEND_SEND_BY_VAL, 0, IS_VOID, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_pdisconnect, ZEND_SEND_BY_VAL, 0, IS_VOID, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_disconnect, ZEND_SEND_BY_VAL, 0, IS_VOID, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_reconnect, ZEND_SEND_BY_VAL, 0, IS_VOID, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_preconnect, ZEND_SEND_BY_VAL, 0, IS_VOID, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_getLogin, ZEND_SEND_BY_VAL, 0, IS_STRING, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_setLogin, ZEND_SEND_BY_VAL, 1, IS_VOID, 0)
	ZEND_ARG_TYPE_INFO(0, login, IS_STRING, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_getPassword, ZEND_SEND_BY_VAL, 0, IS_STRING, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_setPassword, ZEND_SEND_BY_VAL, 1, IS_VOID, 0)
	ZEND_ARG_TYPE_INFO(0, password, IS_STRING, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_getHost, ZEND_SEND_BY_VAL, 0, IS_STRING, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_setHost, ZEND_SEND_BY_VAL, 1, IS_VOID, 0)
	ZEND_ARG_TYPE_INFO(0, host, IS_STRING, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_getPort, ZEND_SEND_BY_VAL, 0, IS_LONG, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_setPort, ZEND_SEND_BY_VAL, 1, IS_VOID, 0)
	ZEND_ARG_TYPE_INFO(0, port, IS_LONG, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_getVhost, ZEND_SEND_BY_VAL, 0, IS_STRING, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_setVhost, ZEND_SEND_BY_VAL, 1, IS_VOID, 0)
	ZEND_ARG_TYPE_INFO(0, vhost, IS_STRING, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_getTimeout, ZEND_SEND_BY_VAL, 0, IS_DOUBLE, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_setTimeout, ZEND_SEND_BY_VAL, 1, IS_VOID, 0)
	ZEND_ARG_TYPE_INFO(0, timeout, IS_DOUBLE, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_getReadTimeout, ZEND_SEND_BY_VAL, 0, IS_DOUBLE, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_setReadTimeout, ZEND_SEND_BY_VAL, 1, IS_VOID, 0)
	ZEND_ARG_TYPE_INFO(0, timeout, IS_DOUBLE, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(
	arginfo_amqp_connection_class_getWriteTimeout,
	ZEND_SEND_BY_VAL,
	0,
	IS_DOUBLE,
	0
	)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_setWriteTimeout, ZEND_SEND_BY_VAL, 1, IS_VOID, 0)
	ZEND_ARG_TYPE_INFO(0, timeout, IS_DOUBLE, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(
	arginfo_amqp_connection_class_getConnectTimeout,
	ZEND_SEND_BY_VAL,
	0,
	IS_DOUBLE,
	0
	)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_getRpcTimeout, ZEND_SEND_BY_VAL, 0, IS_DOUBLE, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_setRpcTimeout, ZEND_SEND_BY_VAL, 1, IS_VOID, 0)
	ZEND_ARG_TYPE_INFO(0, timeout, IS_DOUBLE, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_getUsedChannels, ZEND_SEND_BY_VAL, 0, IS_LONG, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_getMaxChannels, ZEND_SEND_BY_VAL, 0, IS_LONG, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_getMaxFrameSize, ZEND_SEND_BY_VAL, 0, IS_LONG, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(
	arginfo_amqp_connection_class_getHeartbeatInterval,
	ZEND_SEND_BY_VAL,
	0,
	IS_LONG,
	0
	)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_isPersistent, ZEND_SEND_BY_VAL, 0, _IS_BOOL, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_getCACert, ZEND_SEND_BY_VAL, 0, IS_STRING, 1)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_setCACert, ZEND_SEND_BY_VAL, 1, IS_VOID, 0)
	ZEND_ARG_TYPE_INFO(0, cacert, IS_STRING, 1)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_getCert, ZEND_SEND_BY_VAL, 0, IS_STRING, 1)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_setCert, ZEND_SEND_BY_VAL, 1, IS_VOID, 0)
	ZEND_ARG_TYPE_INFO(0, cert, IS_STRING, 1)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_getKey, ZEND_SEND_BY_VAL, 0, IS_STRING, 1)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_setKey, ZEND_SEND_BY_VAL, 1, IS_VOID, 0)
	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 1)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_getVerify, ZEND_SEND_BY_VAL, 0, _IS_BOOL, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_setVerify, ZEND_SEND_BY_VAL, 1, IS_VOID, 0)
	ZEND_ARG_TYPE_INFO(0, verify, _IS_BOOL, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_getSaslMethod, ZEND_SEND_BY_VAL, 0, IS_LONG, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_amqp_connection_class_setSaslMethod, ZEND_SEND_BY_VAL, 1, IS_VOID, 0)
	ZEND_ARG_TYPE_INFO(0, saslMethod, IS_LONG, 0)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(
	arginfo_amqp_connection_class_getConnectionName,
	ZEND_SEND_BY_VAL,
	0,
	IS_STRING,
	1
	)
	ZEND_END_ARG_INFO()

	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(
	arginfo_amqp_connection_class_setConnectionName,
	ZEND_SEND_BY_VAL,
	1,
	IS_VOID,
	0
	)
	ZEND_ARG_TYPE_INFO(0, connectionName, IS_STRING, 1)
	ZEND_END_ARG_INFO()


	zend_function_entry amqp_connection_class_functions[] = {
	PHP_ME(amqp_connection_class, __construct, arginfo_amqp_connection_class__construct, ZEND_ACC_PUBLIC)
	PHP_ME(amqp_connection_class, isConnected, arginfo_amqp_connection_class_isConnected, ZEND_ACC_PUBLIC)
	PHP_ME(amqp_connection_class, connect, arginfo_amqp_connection_class_connect, ZEND_ACC_PUBLIC)
	PHP_ME(amqp_connection_class, pconnect, arginfo_amqp_connection_class_pconnect, ZEND_ACC_PUBLIC)
	PHP_ME(amqp_connection_class, pdisconnect, arginfo_amqp_connection_class_pdisconnect, ZEND_ACC_PUBLIC)
	PHP_ME(amqp_connection_class, disconnect, arginfo_amqp_connection_class_disconnect, ZEND_ACC_PUBLIC)
	PHP_ME(amqp_connection_class, reconnect, arginfo_amqp_connection_class_reconnect, ZEND_ACC_PUBLIC)
	PHP_ME(amqp_connection_class, preconnect, arginfo_amqp_connection_class_preconnect, ZEND_ACC_PUBLIC)

	PHP_ME(amqp_connection_class, getLogin, arginfo_amqp_connection_class_getLogin, ZEND_ACC_PUBLIC)
	PHP_ME(amqp_connection_class, setLogin, arginfo_amqp_connection_class_setLogin, ZEND_ACC_PUBLIC)

	PHP_ME(amqp_connection_class, getPassword, arginfo_amqp_connection_class_getPassword, ZEND_ACC_PUBLIC)
	PHP_ME(amqp_connection_class, setPassword, arginfo_amqp_connection_class_setPassword, ZEND_ACC_PUBLIC)

	PHP_ME(amqp_connection_class, getHost, arginfo_amqp_connection_class_getHost, ZEND_ACC_PUBLIC)
	PHP_ME(amqp_connection_class, setHost, arginfo_amqp_connection_class_setHost, ZEND_ACC_PUBLIC)

	PHP_ME(amqp_connection_class, getPort, arginfo_amqp_connection_class_getPort, ZEND_ACC_PUBLIC)
	PHP_ME(amqp_connection_class, setPort, arginfo_amqp_connection_class_setPort, ZEND_ACC_PUBLIC)

	PHP_ME(amqp_connection_class, getVhost, arginfo_amqp_connection_class_getVhost, ZEND_ACC_PUBLIC)
	PHP_ME(amqp_connection_class, setVhost, arginfo_amqp_connection_class_setVhost, ZEND_ACC_PUBLIC)

	PHP_ME(amqp_connection_class, getTimeout, arginfo_amqp_connection_class_getTimeout, ZEND_ACC_PUBLIC)
	PHP_ME(amqp_connection_class, setTimeout, arginfo_amqp_connection_class_setTimeout, ZEND_ACC_PUBLIC)

	PHP_ME(amqp_connection_class, getReadTimeout, arginfo_amqp_connection_class_getReadTimeout, ZEND_ACC_PUBLIC)
	PHP_ME(amqp_connection_class, setReadTimeout, arginfo_amqp_connection_class_setReadTimeout, ZEND_ACC_PUBLIC)

	PHP_ME(amqp_connection_class, getWriteTimeout, arginfo_amqp_connection_class_getWriteTimeout, ZEND_ACC_PUBLIC)
	PHP_ME(amqp_connection_class, setWriteTimeout, arginfo_amqp_connection_class_setWriteTimeout, ZEND_ACC_PUBLIC)

	PHP_ME(amqp_connection_class, getConnectTimeout, arginfo_amqp_connection_class_getConnectTimeout, ZEND_ACC_PUBLIC)
	/** setConnectTimeout intentionally left out */

	PHP_ME(amqp_connection_class, getRpcTimeout, arginfo_amqp_connection_class_getRpcTimeout, ZEND_ACC_PUBLIC)
	PHP_ME(amqp_connection_class, setRpcTimeout, arginfo_amqp_connection_class_setRpcTimeout, ZEND_ACC_PUBLIC)

	PHP_ME(amqp_connection_class, getUsedChannels, arginfo_amqp_connection_class_getUsedChannels, ZEND_ACC_PUBLIC)
	PHP_ME(amqp_connection_class, getMaxChannels, arginfo_amqp_connection_class_getMaxChannels, ZEND_ACC_PUBLIC)
	PHP_ME(amqp_connection_class, isPersistent, arginfo_amqp_connection_class_isPersistent, ZEND_ACC_PUBLIC)
	PHP_ME(amqp_connection_class, getHeartbeatInterval, arginfo_amqp_connection_class_getHeartbeatInterval, ZEND_ACC_PUBLIC)
	PHP_ME(amqp_connection_class, getMaxFrameSize, arginfo_amqp_connection_class_getMaxFrameSize, ZEND_ACC_PUBLIC)

	PHP_ME(amqp_connection_class, getCACert, arginfo_amqp_connection_class_getCACert, ZEND_ACC_PUBLIC)
	PHP_ME(amqp_connection_class, setCACert, arginfo_amqp_connection_class_setCACert, ZEND_ACC_PUBLIC)

	PHP_ME(amqp_connection_class, getCert, arginfo_amqp_connection_class_getCert, ZEND_ACC_PUBLIC)
	PHP_ME(amqp_connection_class, setCert, arginfo_amqp_connection_class_setCert, ZEND_ACC_PUBLIC)

	PHP_ME(amqp_connection_class, getKey, arginfo_amqp_connection_class_getKey, ZEND_ACC_PUBLIC)
	PHP_ME(amqp_connection_class, setKey, arginfo_amqp_connection_class_setKey, ZEND_ACC_PUBLIC)

	PHP_ME(amqp_connection_class, getVerify, arginfo_amqp_connection_class_getVerify, ZEND_ACC_PUBLIC)
	PHP_ME(amqp_connection_class, setVerify, arginfo_amqp_connection_class_setVerify, ZEND_ACC_PUBLIC)

	PHP_ME(amqp_connection_class, getSaslMethod, arginfo_amqp_connection_class_getSaslMethod, ZEND_ACC_PUBLIC)
	PHP_ME(amqp_connection_class, setSaslMethod, arginfo_amqp_connection_class_setSaslMethod, ZEND_ACC_PUBLIC)

	PHP_ME(amqp_connection_class, getConnectionName, arginfo_amqp_connection_class_getConnectionName, ZEND_ACC_PUBLIC)
	PHP_ME(amqp_connection_class, setConnectionName, arginfo_amqp_connection_class_setConnectionName, ZEND_ACC_PUBLIC)

	{NULL, NULL, NULL}
	};

	PHP_MINIT_FUNCTION(amqp_connection)
	{
	zend_class_entry ce;

	INIT_CLASS_ENTRY(ce, "AMQPConnection", amqp_connection_class_functions);
	ce.create_object = amqp_connection_ctor;
	this_ce = zend_register_internal_class(&ce);

	PHP_AMQP_DECLARE_TYPED_PROPERTY(this_ce, "login", ZEND_ACC_PRIVATE, IS_STRING, 0);
	PHP_AMQP_DECLARE_TYPED_PROPERTY(this_ce, "password", ZEND_ACC_PRIVATE, IS_STRING, 0);
	PHP_AMQP_DECLARE_TYPED_PROPERTY(this_ce, "host", ZEND_ACC_PRIVATE, IS_STRING, 0);
	PHP_AMQP_DECLARE_TYPED_PROPERTY(this_ce, "vhost", ZEND_ACC_PRIVATE, IS_STRING, 0);
	PHP_AMQP_DECLARE_TYPED_PROPERTY(this_ce, "port", ZEND_ACC_PRIVATE, IS_LONG, 0);

	PHP_AMQP_DECLARE_TYPED_PROPERTY(this_ce, "readTimeout", ZEND_ACC_PRIVATE, IS_DOUBLE, 0);
	PHP_AMQP_DECLARE_TYPED_PROPERTY(this_ce, "writeTimeout", ZEND_ACC_PRIVATE, IS_DOUBLE, 0);
	PHP_AMQP_DECLARE_TYPED_PROPERTY(this_ce, "connectTimeout", ZEND_ACC_PRIVATE, IS_DOUBLE, 0);
	PHP_AMQP_DECLARE_TYPED_PROPERTY(this_ce, "rpcTimeout", ZEND_ACC_PRIVATE, IS_DOUBLE, 0);

	PHP_AMQP_DECLARE_TYPED_PROPERTY(this_ce, "frameMax", ZEND_ACC_PRIVATE, IS_LONG, 0);
	PHP_AMQP_DECLARE_TYPED_PROPERTY(this_ce, "channelMax", ZEND_ACC_PRIVATE, IS_LONG, 0);
	PHP_AMQP_DECLARE_TYPED_PROPERTY(this_ce, "heartbeat", ZEND_ACC_PRIVATE, IS_LONG, 0);

	PHP_AMQP_DECLARE_TYPED_PROPERTY(this_ce, "cacert", ZEND_ACC_PRIVATE, IS_STRING, 1);
	PHP_AMQP_DECLARE_TYPED_PROPERTY(this_ce, "key", ZEND_ACC_PRIVATE, IS_STRING, 1);
	PHP_AMQP_DECLARE_TYPED_PROPERTY(this_ce, "cert", ZEND_ACC_PRIVATE, IS_STRING, 1);
	PHP_AMQP_DECLARE_TYPED_PROPERTY_WITH_DEFAULT(this_ce, "verify", ZEND_ACC_PRIVATE, _IS_BOOL, 0, ZVAL_TRUE);

	zval default_sasl_method;
	ZVAL_LONG(&default_sasl_method, DEFAULT_SASL_METHOD);
	PHP_AMQP_DECLARE_TYPED_PROPERTY_ZVAL(
	this_ce,
	"saslMethod",
	ZEND_ACC_PRIVATE,
	PHP_AMQP_DECLARE_PROPERTY_TYPE(IS_LONG, 0),
	default_sasl_method
	);

	PHP_AMQP_DECLARE_TYPED_PROPERTY(this_ce, "connectionName", ZEND_ACC_PRIVATE, IS_STRING, 1);

	memcpy(&amqp_connection_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));

	amqp_connection_object_handlers.offset = XtOffsetOf(amqp_connection_object, zo);
	amqp_connection_object_handlers.free_obj = amqp_connection_free;

	return SUCCESS;
	}

File Metadata

Mime Type: text/x-c
Expires: Sun, Nov 15, 12:55 AM (1 d, 16 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 132527
Default Alt Text: amqp_connection.c (66 KB)

amqp_connection.cNo OneTemporaryActions

amqp_connection.cView Options

File Metadata

Event Timeline

amqp_connection.c
No OneTemporary
Actions

amqp_connection.c
View Options