Merge branch 'master' of https://git.php.net/push/php-src

* 'master' of https://git.php.net/push/php-src: (6215 commits)
  Extra comma
  Moved proxy object support in ASSIGN_ADD (and family) from VM to slow paths of corresponding operators
  Simplification
  zend_get_property_info_quick() cleanup and optimization
  initialize lineno before calling compile file file in phar
  Use ADDREF instead of DUP, it must be enough.
  Removed old irrelevant comment
  fixed compilation error
  Fix bug #68262: Broken reference across cloned objects
  export functions needed for phpdbg
  Fixed compilation
  Optimized property access handlers. Removed EG(std_property_info).
  Fixed bug #68199 (PDO::pgsqlGetNotify doesn't support NOTIFY payloads)
  Don't make difference between undefined and unaccessible properies when call __get() and family
  Don't make useless CSE
  array_pop/array_shift optimization
  check for zlib headers as well as lib for mysqlnd
  a realpath cache key can be int or float, catching this
  News entry for new curl constants
  News entry for new curl constants
  ...

1 files changed, 688 insertions, 227 deletions

diff --git a/ext/ldap/ldap.c b/ext/ldap/ldap.c
index e95f898c15..f74de699ee 100644
--- a/ext/ldap/ldap.c
+++ b/ext/ldap/ldap.c
@@ -1,8 +1,8 @@
 /*
    +----------------------------------------------------------------------+
-   | PHP Version 5                                                        |
+   | PHP Version 7                                                        |
    +----------------------------------------------------------------------+
-   | Copyright (c) 1997-2013 The PHP Group                                |
+   | Copyright (c) 1997-2014 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        |
@@ -67,17 +67,20 @@
 #include <sasl/sasl.h>
 #endif
 
+#define PHP_LDAP_ESCAPE_FILTER 0x01
+#define PHP_LDAP_ESCAPE_DN     0x02
+
 typedef struct {
 	LDAP *link;
 #if defined(LDAP_API_FEATURE_X_OPENLDAP) && defined(HAVE_3ARG_SETREBINDPROC)
-	zval *rebindproc;
+	zval rebindproc;
 #endif
 } ldap_linkdata;
 
 typedef struct {
 	LDAPMessage *data;
-	BerElement *ber;
-	int id;
+	BerElement  *ber;
+	zval         res;
 } ldap_resultentry;
 
 ZEND_DECLARE_MODULE_GLOBALS(ldap)
@@ -89,30 +92,27 @@ static int le_link, le_result, le_result_entry;
 ZEND_GET_MODULE(ldap)
 #endif
 
-static void _close_ldap_link(zend_rsrc_list_entry *rsrc TSRMLS_DC) /* {{{ */
+static void _close_ldap_link(zend_resource *rsrc TSRMLS_DC) /* {{{ */
 {
 	ldap_linkdata *ld = (ldap_linkdata *)rsrc->ptr;
 
 	ldap_unbind_s(ld->link);
 #if defined(LDAP_API_FEATURE_X_OPENLDAP) && defined(HAVE_3ARG_SETREBINDPROC)
-	if (ld->rebindproc != NULL) {
-		zval_dtor(ld->rebindproc);
-		FREE_ZVAL(ld->rebindproc);
-	}
+	zval_ptr_dtor(&ld->rebindproc);
 #endif
 	efree(ld);
 	LDAPG(num_links)--;
 }
 /* }}} */
 
-static void _free_ldap_result(zend_rsrc_list_entry *rsrc TSRMLS_DC) /* {{{ */
+static void _free_ldap_result(zend_resource *rsrc TSRMLS_DC) /* {{{ */
 {
 	LDAPMessage *result = (LDAPMessage *)rsrc->ptr;
 	ldap_msgfree(result);
 }
 /* }}} */
 
-static void _free_ldap_result_entry(zend_rsrc_list_entry *rsrc TSRMLS_DC) /* {{{ */
+static void _free_ldap_result_entry(zend_resource *rsrc TSRMLS_DC) /* {{{ */
 {
 	ldap_resultentry *entry = (ldap_resultentry *)rsrc->ptr;
 
@@ -120,7 +120,7 @@ static void _free_ldap_result_entry(zend_rsrc_list_entry *rsrc TSRMLS_DC) /* {{{
 		ber_free(entry->ber, 0);
 		entry->ber = NULL;
 	}
-	zend_list_delete(entry->id);
+	zval_ptr_dtor(&entry->res);
 	efree(entry);
 } 
 /* }}} */
@@ -152,6 +152,15 @@ PHP_MINIT_FUNCTION(ldap)
 	REGISTER_LONG_CONSTANT("LDAP_DEREF_FINDING", LDAP_DEREF_FINDING, CONST_PERSISTENT | CONST_CS);
 	REGISTER_LONG_CONSTANT("LDAP_DEREF_ALWAYS", LDAP_DEREF_ALWAYS, CONST_PERSISTENT | CONST_CS);
 
+	/* Constants to be used with ldap_modify_batch() */
+	REGISTER_LONG_CONSTANT("LDAP_MODIFY_BATCH_ADD", LDAP_MODIFY_BATCH_ADD, CONST_PERSISTENT | CONST_CS);
+	REGISTER_LONG_CONSTANT("LDAP_MODIFY_BATCH_REMOVE", LDAP_MODIFY_BATCH_REMOVE, CONST_PERSISTENT | CONST_CS);
+	REGISTER_LONG_CONSTANT("LDAP_MODIFY_BATCH_REMOVE_ALL", LDAP_MODIFY_BATCH_REMOVE_ALL, CONST_PERSISTENT | CONST_CS);
+	REGISTER_LONG_CONSTANT("LDAP_MODIFY_BATCH_REPLACE", LDAP_MODIFY_BATCH_REPLACE, CONST_PERSISTENT | CONST_CS);
+	REGISTER_STRING_CONSTANT("LDAP_MODIFY_BATCH_ATTRIB", LDAP_MODIFY_BATCH_ATTRIB, CONST_PERSISTENT | CONST_CS);
+	REGISTER_STRING_CONSTANT("LDAP_MODIFY_BATCH_MODTYPE", LDAP_MODIFY_BATCH_MODTYPE, CONST_PERSISTENT | CONST_CS);
+	REGISTER_STRING_CONSTANT("LDAP_MODIFY_BATCH_VALUES", LDAP_MODIFY_BATCH_VALUES, CONST_PERSISTENT | CONST_CS);
+
 #if (LDAP_API_VERSION > 2000) || HAVE_NSLDAP || HAVE_ORALDAP
 	/* LDAP options */
 	REGISTER_LONG_CONSTANT("LDAP_OPT_DEREF", LDAP_OPT_DEREF, CONST_PERSISTENT | CONST_CS);
@@ -195,11 +204,14 @@ PHP_MINIT_FUNCTION(ldap)
 	REGISTER_LONG_CONSTANT("GSLC_SSL_TWOWAY_AUTH", GSLC_SSL_TWOWAY_AUTH, CONST_PERSISTENT | CONST_CS);
 #endif
 
+	REGISTER_LONG_CONSTANT("LDAP_ESCAPE_FILTER", PHP_LDAP_ESCAPE_FILTER, CONST_PERSISTENT | CONST_CS);
+	REGISTER_LONG_CONSTANT("LDAP_ESCAPE_DN", PHP_LDAP_ESCAPE_DN, CONST_PERSISTENT | CONST_CS);
+
 	le_link = zend_register_list_destructors_ex(_close_ldap_link, NULL, "ldap link", module_number);
 	le_result = zend_register_list_destructors_ex(_free_ldap_result, NULL, "ldap result", module_number);
 	le_result_entry = zend_register_list_destructors_ex(_free_ldap_result_entry, NULL, "ldap result entry", module_number);
 
-	Z_TYPE(ldap_module_entry) = type;
+	ldap_module_entry.type = type;
 
 	return SUCCESS;
 }
@@ -229,9 +241,9 @@ PHP_MINFO_FUNCTION(ldap)
 	php_info_print_table_row(2, "RCS Version", "$Id$");
 
 	if (LDAPG(max_links) == -1) {
-		snprintf(tmp, 31, "%ld/unlimited", LDAPG(num_links));
+		snprintf(tmp, 31, ZEND_LONG_FMT "/unlimited", LDAPG(num_links));
 	} else {
-		snprintf(tmp, 31, "%ld/%ld", LDAPG(num_links), LDAPG(max_links));
+		snprintf(tmp, 31, ZEND_LONG_FMT "/" ZEND_LONG_FMT, LDAPG(num_links), LDAPG(max_links));
 	}
 	php_info_print_table_row(2, "Total Links", tmp);
 
@@ -282,12 +294,12 @@ PHP_MINFO_FUNCTION(ldap)
 PHP_FUNCTION(ldap_connect)
 {
 	char *host = NULL;
-	int hostlen;
-	long port = 389; /* Default port */
+	size_t hostlen;
+	zend_long port = 389; /* Default port */
 #ifdef HAVE_ORALDAP
 	char *wallet = NULL, *walletpasswd = NULL;
-	int walletlen = 0, walletpasswdlen = 0;
-	long authmode = GSLC_SSL_NO_AUTH;
+	size_t walletlen = 0, walletpasswdlen = 0;
+	zend_long authmode = GSLC_SSL_NO_AUTH;
 	int ssl=0;
 #endif
 	ldap_linkdata *ld;
@@ -312,7 +324,7 @@ PHP_FUNCTION(ldap_connect)
 #endif
 
 	if (LDAPG(max_links) != -1 && LDAPG(num_links) >= LDAPG(max_links)) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Too many open links (%ld)", LDAPG(num_links));
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Too many open links (%pd)", LDAPG(num_links));
 		RETURN_FALSE;
 	}
 
@@ -376,13 +388,30 @@ static int _get_lderrno(LDAP *ldap)
 }
 /* }}} */
 
+/* {{{ _set_lderrno
+ */
+static void _set_lderrno(LDAP *ldap, int lderr)
+{
+#if !HAVE_NSLDAP
+#if LDAP_API_VERSION > 2000 || HAVE_ORALDAP
+	/* New versions of OpenLDAP do it this way */
+	ldap_set_option(ldap, LDAP_OPT_ERROR_NUMBER, &lderr);
+#else
+	ldap->ld_errno = lderr;
+#endif
+#else
+	ldap_set_lderrno(ldap, lderr, NULL, NULL);
+#endif
+}
+/* }}} */
+
 /* {{{ proto bool ldap_bind(resource link [, string dn [, string password]])
    Bind to LDAP directory */
 PHP_FUNCTION(ldap_bind)
 {
 	zval *link;
 	char *ldap_bind_dn = NULL, *ldap_bind_pw = NULL;
-	int ldap_bind_dnlen, ldap_bind_pwlen;
+	size_t ldap_bind_dnlen, ldap_bind_pwlen;
 	ldap_linkdata *ld;
 	int rc;
 
@@ -390,7 +419,19 @@ PHP_FUNCTION(ldap_bind)
 		RETURN_FALSE;
 	}
 
-	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, &link, -1, "ldap link", le_link);
+	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
+
+	if (ldap_bind_dn != NULL && memchr(ldap_bind_dn, '\0', ldap_bind_dnlen) != NULL) {
+		_set_lderrno(ld->link, LDAP_INVALID_CREDENTIALS);
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "DN contains a null byte");
+		RETURN_FALSE;
+	}
+
+	if (ldap_bind_pw != NULL && memchr(ldap_bind_pw, '\0', ldap_bind_pwlen) != NULL) {
+		_set_lderrno(ld->link, LDAP_INVALID_CREDENTIALS);
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Password contains a null byte");
+		RETURN_FALSE;
+	}
 
 	if ((rc = ldap_bind_s(ld->link, ldap_bind_dn, ldap_bind_pw, LDAP_AUTH_SIMPLE)) != LDAP_SUCCESS) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to bind to server: %s", ldap_err2string(rc));
@@ -499,14 +540,14 @@ PHP_FUNCTION(ldap_sasl_bind)
 	char *sasl_authz_id = NULL;
 	char *sasl_authc_id = NULL;
 	char *props = NULL;
-	int rc, dn_len, passwd_len, mech_len, realm_len, authc_id_len, authz_id_len, props_len;
+	size_t rc, dn_len, passwd_len, mech_len, realm_len, authc_id_len, authz_id_len, props_len;
 	php_ldap_bictx *ctx;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|sssssss", &link, &binddn, &dn_len, &passwd, &passwd_len, &sasl_mech, &mech_len, &sasl_realm, &realm_len, &sasl_authc_id, &authc_id_len, &sasl_authz_id, &authz_id_len, &props, &props_len) != SUCCESS) {
 		RETURN_FALSE;
 	}
 
-	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, &link, -1, "ldap link", le_link);
+	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
 
 	ctx = _php_sasl_setdefs(ld->link, sasl_mech, sasl_realm, sasl_authc_id, passwd, sasl_authz_id);
 
@@ -537,9 +578,9 @@ PHP_FUNCTION(ldap_unbind)
 		RETURN_FALSE;
 	}
 
-	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, &link, -1, "ldap link", le_link);
+	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
 
-	zend_list_delete(Z_LVAL_P(link));
+	zend_list_close(Z_RES_P(link));
 	RETURN_TRUE;
 }
 /* }}} */
@@ -587,8 +628,8 @@ static void php_set_opts(LDAP *ldap, int sizelimit, int timelimit, int deref, in
  */
 static void php_ldap_do_search(INTERNAL_FUNCTION_PARAMETERS, int scope)
 {
-	zval *link, *base_dn, **filter, *attrs = NULL, **attr;
-	long attrsonly, sizelimit, timelimit, deref;
+	zval *link, *base_dn, *filter, *attrs = NULL, *attr;
+	zend_long attrsonly, sizelimit, timelimit, deref;
 	char *ldap_base_dn = NULL, *ldap_filter = NULL, **ldap_attrs = NULL; 
 	ldap_linkdata *ld = NULL;
 	LDAPMessage *ldap_res;
@@ -596,7 +637,7 @@ static void php_ldap_do_search(INTERNAL_FUNCTION_PARAMETERS, int scope)
 	int old_ldap_sizelimit = -1, old_ldap_timelimit = -1, old_ldap_deref = -1;	 
 	int num_attribs = 0, ret = 1, i, errno, argcount = ZEND_NUM_ARGS();
 
-	if (zend_parse_parameters(argcount TSRMLS_CC, "zzZ|allll", &link, &base_dn, &filter, &attrs, &attrsonly,
+	if (zend_parse_parameters(argcount TSRMLS_CC, "zzz|allll", &link, &base_dn, &filter, &attrs, &attrsonly,
 		&sizelimit, &timelimit, &deref) == FAILURE) {
 		return;
 	}
@@ -616,7 +657,7 @@ static void php_ldap_do_search(INTERNAL_FUNCTION_PARAMETERS, int scope)
 			ldap_attrs = safe_emalloc((num_attribs+1), sizeof(char *), 0);
 
 			for (i = 0; i<num_attribs; i++) {
-				if (zend_hash_index_find(Z_ARRVAL_P(attrs), i, (void **) &attr) != SUCCESS) {
+				if ((attr = zend_hash_index_find(Z_ARRVAL_P(attrs), i)) == NULL) {
 					php_error_docref(NULL TSRMLS_CC, E_WARNING, "Array initialization wrong");
 					ret = 0;
 					goto cleanup;
@@ -624,7 +665,7 @@ static void php_ldap_do_search(INTERNAL_FUNCTION_PARAMETERS, int scope)
 
 				SEPARATE_ZVAL(attr);
 				convert_to_string_ex(attr);
-				ldap_attrs[i] = Z_STRVAL_PP(attr);
+				ldap_attrs[i] = Z_STRVAL_P(attr);
 			}
 			ldap_attrs[num_attribs] = NULL;
 		default:
@@ -635,7 +676,7 @@ static void php_ldap_do_search(INTERNAL_FUNCTION_PARAMETERS, int scope)
 	if (Z_TYPE_P(link) == IS_ARRAY) {
 		int i, nlinks, nbases, nfilters, *rcs;
 		ldap_linkdata **lds;
-		zval **entry, *resource;
+		zval *entry, resource;
 		
 		nlinks = zend_hash_num_elements(Z_ARRVAL_P(link));
 		if (nlinks == 0) {
@@ -662,18 +703,18 @@ static void php_ldap_do_search(INTERNAL_FUNCTION_PARAMETERS, int scope)
 			}
 		}
 
-		if (Z_TYPE_PP(filter) == IS_ARRAY) {
-			nfilters = zend_hash_num_elements(Z_ARRVAL_PP(filter));
+		if (Z_TYPE_P(filter) == IS_ARRAY) {
+			nfilters = zend_hash_num_elements(Z_ARRVAL_P(filter));
 			if (nfilters != nlinks) {
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Filter must either be a string, or an array with the same number of elements as the links array");
 				ret = 0;
 				goto cleanup;
 			}
-			zend_hash_internal_pointer_reset(Z_ARRVAL_PP(filter));
+			zend_hash_internal_pointer_reset(Z_ARRVAL_P(filter));
 		} else {
 			nfilters = 0; /* this means string, not array */
 			convert_to_string_ex(filter);
-			ldap_filter = Z_STRVAL_PP(filter);
+			ldap_filter = Z_STRVAL_P(filter);
 		}
 
 		lds = safe_emalloc(nlinks, sizeof(ldap_linkdata), 0);
@@ -681,7 +722,7 @@ static void php_ldap_do_search(INTERNAL_FUNCTION_PARAMETERS, int scope)
 		
 		zend_hash_internal_pointer_reset(Z_ARRVAL_P(link));
 		for (i=0; i<nlinks; i++) {
-			zend_hash_get_current_data(Z_ARRVAL_P(link), (void **)&entry);
+			entry = zend_hash_get_current_data(Z_ARRVAL_P(link));
 
 			ld = (ldap_linkdata *) zend_fetch_resource(entry TSRMLS_CC, -1, "ldap link", NULL, 1, le_link);
 			if (ld == NULL) {
@@ -689,21 +730,21 @@ static void php_ldap_do_search(INTERNAL_FUNCTION_PARAMETERS, int scope)
 				goto cleanup_parallel;
 			}
 			if (nbases != 0) { /* base_dn an array? */
-				zend_hash_get_current_data(Z_ARRVAL_P(base_dn), (void **)&entry);
+				entry = zend_hash_get_current_data(Z_ARRVAL_P(base_dn));
 				zend_hash_move_forward(Z_ARRVAL_P(base_dn));
 
 				/* If anything else than string is passed, ldap_base_dn = NULL */
-				if (Z_TYPE_PP(entry) == IS_STRING) {
-					ldap_base_dn = Z_STRVAL_PP(entry);
+				if (Z_TYPE_P(entry) == IS_STRING) {
+					ldap_base_dn = Z_STRVAL_P(entry);
 				} else {
 					ldap_base_dn = NULL;
 				}
 			}
 			if (nfilters != 0) { /* filter an array? */
-				zend_hash_get_current_data(Z_ARRVAL_PP(filter), (void **)&entry);
-				zend_hash_move_forward(Z_ARRVAL_PP(filter));
+				entry = zend_hash_get_current_data(Z_ARRVAL_P(filter));
+				zend_hash_move_forward(Z_ARRVAL_P(filter));
 				convert_to_string_ex(entry);
-				ldap_filter = Z_STRVAL_PP(entry);
+				ldap_filter = Z_STRVAL_P(entry);
 			}
 
 			php_set_opts(ld->link, ldap_sizelimit, ldap_timelimit, ldap_deref, &old_ldap_sizelimit, &old_ldap_timelimit, &old_ldap_deref);
@@ -718,13 +759,12 @@ static void php_ldap_do_search(INTERNAL_FUNCTION_PARAMETERS, int scope)
 
 		/* Collect results from the searches */
 		for (i=0; i<nlinks; i++) {
-			MAKE_STD_ZVAL(resource);
 			if (rcs[i] != -1) {
 				rcs[i] = ldap_result(lds[i]->link, LDAP_RES_ANY, 1 /* LDAP_MSG_ALL */, NULL, &ldap_res);
 			}
 			if (rcs[i] != -1) {
-				ZEND_REGISTER_RESOURCE(resource, ldap_res, le_result);
-				add_next_index_zval(return_value, resource);
+				ZEND_REGISTER_RESOURCE(&resource, ldap_res, le_result);
+				add_next_index_zval(return_value, &resource);
 			} else {
 				add_next_index_bool(return_value, 0);
 			}
@@ -735,14 +775,14 @@ cleanup_parallel:
 		efree(rcs);
 	} else {
 		convert_to_string_ex(filter);
-		ldap_filter = Z_STRVAL_PP(filter);
+		ldap_filter = Z_STRVAL_P(filter);
 
 		/* If anything else than string is passed, ldap_base_dn = NULL */
 		if (Z_TYPE_P(base_dn) == IS_STRING) {
 			ldap_base_dn = Z_STRVAL_P(base_dn);
 		}
 
-		ld = (ldap_linkdata *) zend_fetch_resource(&link TSRMLS_CC, -1, "ldap link", NULL, 1, le_link);
+		ld = (ldap_linkdata *) zend_fetch_resource(link TSRMLS_CC, -1, "ldap link", NULL, 1, le_link);
 		if (ld == NULL) {
 			ret = 0;
 			goto cleanup;
@@ -827,9 +867,9 @@ PHP_FUNCTION(ldap_free_result)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(ldap_result, LDAPMessage *, &result, -1, "ldap result", le_result);
+	ZEND_FETCH_RESOURCE(ldap_result, LDAPMessage *, result, -1, "ldap result", le_result);
 
-	zend_list_delete(Z_LVAL_P(result));  /* Delete list entry */
+	zend_list_close(Z_RES_P(result));  /* Delete list entry */
 	RETVAL_TRUE;
 }
 /* }}} */
@@ -846,8 +886,8 @@ PHP_FUNCTION(ldap_count_entries)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, &link, -1, "ldap link", le_link);
-	ZEND_FETCH_RESOURCE(ldap_result, LDAPMessage *, &result, -1, "ldap result", le_result);
+	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
+	ZEND_FETCH_RESOURCE(ldap_result, LDAPMessage *, result, -1, "ldap result", le_result);
 
 	RETURN_LONG(ldap_count_entries(ld->link, ldap_result));
 }
@@ -866,16 +906,15 @@ PHP_FUNCTION(ldap_first_entry)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, &link, -1, "ldap link", le_link);
-	ZEND_FETCH_RESOURCE(ldap_result, LDAPMessage *, &result, -1, "ldap result", le_result);
+	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
+	ZEND_FETCH_RESOURCE(ldap_result, LDAPMessage *, result, -1, "ldap result", le_result);
 
 	if ((entry = ldap_first_entry(ld->link, ldap_result)) == NULL) {
 		RETVAL_FALSE;
 	} else {
 		resultentry = emalloc(sizeof(ldap_resultentry));
 		ZEND_REGISTER_RESOURCE(return_value, resultentry, le_result_entry);
-		resultentry->id = Z_LVAL_P(result);
-		zend_list_addref(resultentry->id);
+		ZVAL_COPY(&resultentry->res, result);
 		resultentry->data = entry;
 		resultentry->ber = NULL;
 	}
@@ -895,16 +934,15 @@ PHP_FUNCTION(ldap_next_entry)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, &link, -1, "ldap link", le_link);
-	ZEND_FETCH_RESOURCE(resultentry, ldap_resultentry *, &result_entry, -1, "ldap result entry", le_result_entry);
+	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
+	ZEND_FETCH_RESOURCE(resultentry, ldap_resultentry *, result_entry, -1, "ldap result entry", le_result_entry);
 
 	if ((entry_next = ldap_next_entry(ld->link, resultentry->data)) == NULL) {
 		RETVAL_FALSE;
 	} else {
 		resultentry_next = emalloc(sizeof(ldap_resultentry));
 		ZEND_REGISTER_RESOURCE(return_value, resultentry_next, le_result_entry);
-		resultentry_next->id = resultentry->id;
-		zend_list_addref(resultentry->id);
+		ZVAL_COPY(&resultentry_next->res, &resultentry->res);
 		resultentry_next->data = entry_next;
 		resultentry_next->ber = NULL;
 	}
@@ -917,7 +955,7 @@ PHP_FUNCTION(ldap_get_entries)
 {
 	zval *link, *result;
 	LDAPMessage *ldap_result, *ldap_result_entry;
-	zval *tmp1, *tmp2;
+	zval tmp1, tmp2;
 	ldap_linkdata *ld;
 	LDAP *ldap;
 	int num_entries, num_attrib, num_values, i;
@@ -931,8 +969,8 @@ PHP_FUNCTION(ldap_get_entries)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, &link, -1, "ldap link", le_link);
-	ZEND_FETCH_RESOURCE(ldap_result, LDAPMessage *, &result, -1, "ldap result", le_result);
+	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
+	ZEND_FETCH_RESOURCE(ldap_result, LDAPMessage *, result, -1, "ldap result", le_result);
 
 	ldap = ld->link;
 	num_entries = ldap_count_entries(ldap, ldap_result);
@@ -952,8 +990,7 @@ PHP_FUNCTION(ldap_get_entries)
 
 	num_entries = 0;
 	while (ldap_result_entry != NULL) {
-		MAKE_STD_ZVAL(tmp1);
-		array_init(tmp1);
+		array_init(&tmp1);
 
 		num_attrib = 0;
 		attribute = ldap_first_attribute(ldap, ldap_result_entry, &ber);
@@ -962,17 +999,16 @@ PHP_FUNCTION(ldap_get_entries)
 			ldap_value = ldap_get_values_len(ldap, ldap_result_entry, attribute);
 			num_values = ldap_count_values_len(ldap_value);
 
-			MAKE_STD_ZVAL(tmp2);
-			array_init(tmp2);
-			add_assoc_long(tmp2, "count", num_values);
+			array_init(&tmp2);
+			add_assoc_long(&tmp2, "count", num_values);
 			for (i = 0; i < num_values; i++) {
-				add_index_stringl(tmp2, i, ldap_value[i]->bv_val, ldap_value[i]->bv_len, 1);
+				add_index_stringl(&tmp2, i, ldap_value[i]->bv_val, ldap_value[i]->bv_len);
 			}	
 			ldap_value_free_len(ldap_value);
 
 			attr_len = strlen(attribute);
-			zend_hash_update(Z_ARRVAL_P(tmp1), php_strtolower(attribute, attr_len), attr_len+1, (void *) &tmp2, sizeof(zval *), NULL);
-			add_index_string(tmp1, num_attrib, attribute, 1);
+			zend_hash_str_update(Z_ARRVAL(tmp1), php_strtolower(attribute, attr_len), attr_len, &tmp2);
+			add_index_string(&tmp1, num_attrib, attribute);
 
 			num_attrib++;
 #if (LDAP_API_VERSION > 2000) || HAVE_NSLDAP || HAVE_ORALDAP || WINDOWS
@@ -986,16 +1022,16 @@ PHP_FUNCTION(ldap_get_entries)
 		}
 #endif
 
-		add_assoc_long(tmp1, "count", num_attrib);
+		add_assoc_long(&tmp1, "count", num_attrib);
 		dn = ldap_get_dn(ldap, ldap_result_entry);
-		add_assoc_string(tmp1, "dn", dn, 1);
+		add_assoc_string(&tmp1, "dn", dn);
 #if (LDAP_API_VERSION > 2000) || HAVE_NSLDAP || HAVE_ORALDAP || WINDOWS
 		ldap_memfree(dn);
 #else
 		free(dn);
 #endif
 
-		zend_hash_index_update(Z_ARRVAL_P(return_value), num_entries, (void *) &tmp1, sizeof(zval *), NULL);
+		zend_hash_index_update(Z_ARRVAL_P(return_value), num_entries, &tmp1);
 		
 		num_entries++;
 		ldap_result_entry = ldap_next_entry(ldap, ldap_result_entry);
@@ -1014,19 +1050,19 @@ PHP_FUNCTION(ldap_first_attribute)
 	ldap_linkdata *ld;
 	ldap_resultentry *resultentry;
 	char *attribute;
-	long dummy_ber;
+	zend_long dummy_ber;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rr|l", &link, &result_entry, &dummy_ber) != SUCCESS) {
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, &link, -1, "ldap link", le_link);
-	ZEND_FETCH_RESOURCE(resultentry, ldap_resultentry *, &result_entry, -1, "ldap result entry", le_result_entry);
+	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
+	ZEND_FETCH_RESOURCE(resultentry, ldap_resultentry *, result_entry, -1, "ldap result entry", le_result_entry);
 
 	if ((attribute = ldap_first_attribute(ld->link, resultentry->data, &resultentry->ber)) == NULL) {
 		RETURN_FALSE;
 	} else {
-		RETVAL_STRING(attribute, 1);
+		RETVAL_STRING(attribute);
 #if (LDAP_API_VERSION > 2000) || HAVE_NSLDAP || HAVE_ORALDAP || WINDOWS
 		ldap_memfree(attribute);
 #endif
@@ -1042,14 +1078,14 @@ PHP_FUNCTION(ldap_next_attribute)
 	ldap_linkdata *ld;
 	ldap_resultentry *resultentry;
 	char *attribute;
-	long dummy_ber;
+	zend_long dummy_ber;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rr|l", &link, &result_entry, &dummy_ber) != SUCCESS) {
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, &link, -1, "ldap link", le_link);
-	ZEND_FETCH_RESOURCE(resultentry, ldap_resultentry *, &result_entry, -1, "ldap result entry", le_result_entry);
+	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
+	ZEND_FETCH_RESOURCE(resultentry, ldap_resultentry *, result_entry, -1, "ldap result entry", le_result_entry);
 
 	if (resultentry->ber == NULL) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "called before calling ldap_first_attribute() or no attributes found in result entry");
@@ -1065,7 +1101,7 @@ PHP_FUNCTION(ldap_next_attribute)
 #endif
 		RETURN_FALSE;
 	} else {
-		RETVAL_STRING(attribute, 1);
+		RETVAL_STRING(attribute);
 #if (LDAP_API_VERSION > 2000) || HAVE_NSLDAP || HAVE_ORALDAP || WINDOWS
 		ldap_memfree(attribute);
 #endif
@@ -1078,7 +1114,7 @@ PHP_FUNCTION(ldap_next_attribute)
 PHP_FUNCTION(ldap_get_attributes)
 {
 	zval *link, *result_entry;
-	zval *tmp;
+	zval tmp;
 	ldap_linkdata *ld;
 	ldap_resultentry *resultentry;
 	char *attribute;
@@ -1090,8 +1126,8 @@ PHP_FUNCTION(ldap_get_attributes)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, &link, -1, "ldap link", le_link);
-	ZEND_FETCH_RESOURCE(resultentry, ldap_resultentry *, &result_entry, -1, "ldap result entry", le_result_entry);
+	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
+	ZEND_FETCH_RESOURCE(resultentry, ldap_resultentry *, result_entry, -1, "ldap result entry", le_result_entry);
 
 	array_init(return_value);
 	num_attrib = 0;
@@ -1101,16 +1137,15 @@ PHP_FUNCTION(ldap_get_attributes)
 		ldap_value = ldap_get_values_len(ld->link, resultentry->data, attribute);
 		num_values = ldap_count_values_len(ldap_value);
 
-		MAKE_STD_ZVAL(tmp);
-		array_init(tmp);
-		add_assoc_long(tmp, "count", num_values);
+		array_init(&tmp);
+		add_assoc_long(&tmp, "count", num_values);
 		for (i = 0; i < num_values; i++) {
-			add_index_stringl(tmp, i, ldap_value[i]->bv_val, ldap_value[i]->bv_len, 1);
+			add_index_stringl(&tmp, i, ldap_value[i]->bv_val, ldap_value[i]->bv_len);
 		}
 		ldap_value_free_len(ldap_value);
 
-		zend_hash_update(Z_ARRVAL_P(return_value), attribute, strlen(attribute)+1, (void *) &tmp, sizeof(zval *), NULL);
-		add_index_string(return_value, num_attrib, attribute, 1);
+		zend_hash_str_update(Z_ARRVAL_P(return_value), attribute, strlen(attribute), &tmp);
+		add_index_string(return_value, num_attrib, attribute);
 
 		num_attrib++;
 #if (LDAP_API_VERSION > 2000) || HAVE_NSLDAP || HAVE_ORALDAP || WINDOWS
@@ -1137,14 +1172,15 @@ PHP_FUNCTION(ldap_get_values_len)
 	ldap_resultentry *resultentry;
 	char *attr;
 	struct berval **ldap_value_len;
-	int i, num_values, attr_len;
+	int i, num_values;
+	size_t attr_len;
 	
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrs", &link, &result_entry, &attr, &attr_len) != SUCCESS) {
 		return;
 	}
 	
-	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, &link, -1, "ldap link", le_link);
-	ZEND_FETCH_RESOURCE(resultentry, ldap_resultentry *, &result_entry, -1, "ldap result entry", le_result_entry);
+	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
+	ZEND_FETCH_RESOURCE(resultentry, ldap_resultentry *, result_entry, -1, "ldap result entry", le_result_entry);
 
 	if ((ldap_value_len = ldap_get_values_len(ld->link, resultentry->data, attr)) == NULL) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot get the value(s) of attribute %s", ldap_err2string(_get_lderrno(ld->link)));
@@ -1155,7 +1191,7 @@ PHP_FUNCTION(ldap_get_values_len)
 	array_init(return_value);
 	
 	for (i=0; i<num_values; i++) {
-		add_next_index_stringl(return_value, ldap_value_len[i]->bv_val, ldap_value_len[i]->bv_len, 1);
+		add_next_index_stringl(return_value, ldap_value_len[i]->bv_val, ldap_value_len[i]->bv_len);
 	}
 	
 	add_assoc_long(return_value, "count", num_values);
@@ -1177,12 +1213,12 @@ PHP_FUNCTION(ldap_get_dn)
 		return;
 	}
 	
-	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, &link, -1, "ldap link", le_link);
-	ZEND_FETCH_RESOURCE(resultentry, ldap_resultentry *, &result_entry, -1, "ldap result entry", le_result_entry);
+	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
+	ZEND_FETCH_RESOURCE(resultentry, ldap_resultentry *, result_entry, -1, "ldap result entry", le_result_entry);
 
 	text = ldap_get_dn(ld->link, resultentry->data);
 	if (text != NULL) {
-		RETVAL_STRING(text, 1);
+		RETVAL_STRING(text);
 #if (LDAP_API_VERSION > 2000) || HAVE_NSLDAP || HAVE_ORALDAP || WINDOWS
 		ldap_memfree(text);
 #else
@@ -1198,9 +1234,10 @@ PHP_FUNCTION(ldap_get_dn)
    Splits DN into its component parts */
 PHP_FUNCTION(ldap_explode_dn)
 {
-	long with_attrib;
+	zend_long with_attrib;
 	char *dn, **ldap_value;
-	int i, count, dn_len;
+	int i, count;
+	size_t dn_len;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl", &dn, &dn_len, &with_attrib) != SUCCESS) {
 		return;
@@ -1219,7 +1256,7 @@ PHP_FUNCTION(ldap_explode_dn)
 
 	add_assoc_long(return_value, "count", count);
 	for (i = 0; i<count; i++) {
-		add_index_string(return_value, i, ldap_value[i], 1);
+		add_index_string(return_value, i, ldap_value[i]);
 	}
 
 	ldap_value_free(ldap_value);
@@ -1231,7 +1268,7 @@ PHP_FUNCTION(ldap_explode_dn)
 PHP_FUNCTION(ldap_dn2ufn)
 {
 	char *dn, *ufn;
-	int dn_len;
+	size_t dn_len;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &dn, &dn_len) != SUCCESS) {
 		return;
@@ -1240,7 +1277,7 @@ PHP_FUNCTION(ldap_dn2ufn)
 	ufn = ldap_dn2ufn(dn);
 	
 	if (ufn != NULL) {
-		RETVAL_STRING(ufn, 1);
+		RETVAL_STRING(ufn);
 #if (LDAP_API_VERSION > 2000) || HAVE_NSLDAP || HAVE_ORALDAP || WINDOWS
 		ldap_memfree(ufn);
 #endif
@@ -1257,21 +1294,22 @@ PHP_FUNCTION(ldap_dn2ufn)
  */
 static void php_ldap_do_modify(INTERNAL_FUNCTION_PARAMETERS, int oper)
 {
-	zval *link, *entry, **value, **ivalue;
+	zval *link, *entry, *value, *ivalue;
 	ldap_linkdata *ld;
 	char *dn;
 	LDAPMod **ldap_mods;
-	int i, j, num_attribs, num_values, dn_len;
+	int i, j, num_attribs, num_values;
+	size_t dn_len;
 	int *num_berval;
-	char *attribute;
-	ulong index;
+	zend_string *attribute;
+	zend_ulong index;
 	int is_full_add=0; /* flag for full add operation so ldap_mod_add can be put back into oper, gerrit THomson */
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsa", &link, &dn, &dn_len, &entry) != SUCCESS) {
 		return;
 	}	
 
-	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, &link, -1, "ldap link", le_link);
+	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
 
 	num_attribs = zend_hash_num_elements(Z_ARRVAL_P(entry));
 	ldap_mods = safe_emalloc((num_attribs+1), sizeof(LDAPMod *), 0);
@@ -1291,7 +1329,7 @@ static void php_ldap_do_modify(INTERNAL_FUNCTION_PARAMETERS, int oper)
 		ldap_mods[i]->mod_type = NULL;
 
 		if (zend_hash_get_current_key(Z_ARRVAL_P(entry), &attribute, &index, 0) == HASH_KEY_IS_STRING) {
-			ldap_mods[i]->mod_type = estrdup(attribute);
+			ldap_mods[i]->mod_type = estrndup(attribute->val, attribute->len);
 		} else {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown attribute in the data");
 			/* Free allocated memory */
@@ -1307,26 +1345,26 @@ static void php_ldap_do_modify(INTERNAL_FUNCTION_PARAMETERS, int oper)
 			RETURN_FALSE;
 		}
 
-		zend_hash_get_current_data(Z_ARRVAL_P(entry), (void **)&value);
+		value = zend_hash_get_current_data(Z_ARRVAL_P(entry));
 
-		if (Z_TYPE_PP(value) != IS_ARRAY) {
+		if (Z_TYPE_P(value) != IS_ARRAY) {
 			num_values = 1;
 		} else {
-			num_values = zend_hash_num_elements(Z_ARRVAL_PP(value));
+			num_values = zend_hash_num_elements(Z_ARRVAL_P(value));
 		}
 		
 		num_berval[i] = num_values;
 		ldap_mods[i]->mod_bvalues = safe_emalloc((num_values + 1), sizeof(struct berval *), 0);
 
 /* allow for arrays with one element, no allowance for arrays with none but probably not required, gerrit thomson. */
-		if ((num_values == 1) && (Z_TYPE_PP(value) != IS_ARRAY)) {
+		if ((num_values == 1) && (Z_TYPE_P(value) != IS_ARRAY)) {
 			convert_to_string_ex(value);
 			ldap_mods[i]->mod_bvalues[0] = (struct berval *) emalloc (sizeof(struct berval));
-			ldap_mods[i]->mod_bvalues[0]->bv_len = Z_STRLEN_PP(value);
-			ldap_mods[i]->mod_bvalues[0]->bv_val = Z_STRVAL_PP(value);
+			ldap_mods[i]->mod_bvalues[0]->bv_len = Z_STRLEN_P(value);
+			ldap_mods[i]->mod_bvalues[0]->bv_val = Z_STRVAL_P(value);
 		} else {	
 			for (j = 0; j < num_values; j++) {
-				if (zend_hash_index_find(Z_ARRVAL_PP(value), j, (void **) &ivalue) != SUCCESS) {
+				if ((ivalue = zend_hash_index_find(Z_ARRVAL_P(value), j)) == NULL) {
 					php_error_docref(NULL TSRMLS_CC, E_WARNING, "Value array must have consecutive indices 0, 1, ...");
 					num_berval[i] = j;
 					num_attribs = i + 1;
@@ -1335,8 +1373,8 @@ static void php_ldap_do_modify(INTERNAL_FUNCTION_PARAMETERS, int oper)
 				}
 				convert_to_string_ex(ivalue);
 				ldap_mods[i]->mod_bvalues[j] = (struct berval *) emalloc (sizeof(struct berval));
-				ldap_mods[i]->mod_bvalues[j]->bv_len = Z_STRLEN_PP(ivalue);
-				ldap_mods[i]->mod_bvalues[j]->bv_val = Z_STRVAL_PP(ivalue);
+				ldap_mods[i]->mod_bvalues[j]->bv_len = Z_STRLEN_P(ivalue);
+				ldap_mods[i]->mod_bvalues[j]->bv_val = Z_STRVAL_P(ivalue);
 			}
 		}
 		ldap_mods[i]->mod_bvalues[num_values] = NULL;
@@ -1415,13 +1453,14 @@ PHP_FUNCTION(ldap_delete)
 	zval *link;
 	ldap_linkdata *ld;
 	char *dn;
-	int rc, dn_len;
+	int rc;
+	size_t dn_len;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &link, &dn, &dn_len) != SUCCESS) {
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, &link, -1, "ldap link", le_link);
+	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
 
 	if ((rc = ldap_delete_s(ld->link, dn)) != LDAP_SUCCESS) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Delete: %s", ldap_err2string(rc));
@@ -1432,6 +1471,345 @@ PHP_FUNCTION(ldap_delete)
 }
 /* }}} */
 
+/* {{{ _ldap_str_equal_to_const
+ */
+static int _ldap_str_equal_to_const(const char *str, uint str_len, const char *cstr)
+{
+	int i;
+
+	if (strlen(cstr) != str_len)
+		return 0;
+
+	for (i = 0; i < str_len; ++i) {
+		if (str[i] != cstr[i]) {
+			return 0;
+		}
+	}
+
+	return 1;
+}
+/* }}} */
+
+/* {{{ _ldap_strlen_max
+ */
+static int _ldap_strlen_max(const char *str, uint max_len)
+{
+	int i;
+
+	for (i = 0; i < max_len; ++i) {
+		if (str[i] == '\0') {
+			return i;
+		}
+	}
+
+	return max_len;
+}
+/* }}} */
+
+/* {{{ _ldap_hash_fetch
+ */
+static void _ldap_hash_fetch(zval *hashTbl, const char *key, zval **out)
+{
+	*out = zend_hash_str_find(Z_ARRVAL_P(hashTbl), key, strlen(key));
+}
+/* }}} */
+
+/* {{{ proto bool ldap_modify_batch(resource link, string dn, array modifs)
+   Perform multiple modifications as part of one operation */
+PHP_FUNCTION(ldap_modify_batch)
+{
+	ldap_linkdata *ld;
+	zval *link, *mods, *mod, *modinfo, *modval;
+	zval *attrib, *modtype, *vals;
+	zval *fetched;
+	char *dn;
+	size_t dn_len;
+	int i, j, k;
+	int num_mods, num_modprops, num_modvals;
+	LDAPMod **ldap_mods;
+	uint oper;
+
+	/*
+	$mods = array(
+		array(
+			"attrib" => "unicodePwd",
+			"modtype" => LDAP_MODIFY_BATCH_REMOVE,
+			"values" => array($oldpw)
+		),
+		array(
+			"attrib" => "unicodePwd",
+			"modtype" => LDAP_MODIFY_BATCH_ADD,
+			"values" => array($newpw)
+		),
+		array(
+			"attrib" => "userPrincipalName",
+			"modtype" => LDAP_MODIFY_BATCH_REPLACE,
+			"values" => array("janitor@corp.contoso.com")
+		),
+		array(
+			"attrib" => "userCert",
+			"modtype" => LDAP_MODIFY_BATCH_REMOVE_ALL
+		)
+	);
+	*/
+
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsa", &link, &dn, &dn_len, &mods) != SUCCESS) {
+		return;
+	}
+
+	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
+
+	/* perform validation */
+	{
+		zend_string *modkey;
+		zend_long modtype;
+
+		/* to store the wrongly-typed keys */
+		zend_ulong tmpUlong;
+
+		/* make sure the DN contains no NUL bytes */
+		if (_ldap_strlen_max(dn, dn_len) != dn_len) {
+			php_error_docref(NULL TSRMLS_CC, E_WARNING, "DN must not contain NUL bytes");
+			RETURN_FALSE;
+		}
+
+		/* make sure the top level is a normal array */
+		zend_hash_internal_pointer_reset(Z_ARRVAL_P(mods));
+		if (zend_hash_get_current_key_type(Z_ARRVAL_P(mods)) != HASH_KEY_IS_LONG) {
+			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Modifications array must not be string-indexed");
+			RETURN_FALSE;
+		}
+
+		num_mods = zend_hash_num_elements(Z_ARRVAL_P(mods));
+
+		for (i = 0; i < num_mods; i++) {
+			/* is the numbering consecutive? */
+			if ((fetched = zend_hash_index_find(Z_ARRVAL_P(mods), i)) == NULL) {
+				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Modifications array must have consecutive indices 0, 1, ...");
+				RETURN_FALSE;
+			}
+			mod = fetched;
+
+			/* is it an array? */
+			if (Z_TYPE_P(mod) != IS_ARRAY) {
+				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Each entry of modifications array must be an array itself");
+				RETURN_FALSE;
+			}
+
+			/* for the modification hashtable... */
+			zend_hash_internal_pointer_reset(Z_ARRVAL_P(mod));
+			num_modprops = zend_hash_num_elements(Z_ARRVAL_P(mod));
+
+			for (j = 0; j < num_modprops; j++) {
+				/* are the keys strings? */
+				if (zend_hash_get_current_key(Z_ARRVAL_P(mod), &modkey, &tmpUlong, 0) != HASH_KEY_IS_STRING) {
+					php_error_docref(NULL TSRMLS_CC, E_WARNING, "Each entry of modifications array must be string-indexed");
+					RETURN_FALSE;
+				}
+
+				/* is this a valid entry? */
+				if (
+					!_ldap_str_equal_to_const(modkey->val, modkey->len, LDAP_MODIFY_BATCH_ATTRIB) &&
+					!_ldap_str_equal_to_const(modkey->val, modkey->len, LDAP_MODIFY_BATCH_MODTYPE) &&
+					!_ldap_str_equal_to_const(modkey->val, modkey->len, LDAP_MODIFY_BATCH_VALUES)
+				) {
+					php_error_docref(NULL TSRMLS_CC, E_WARNING, "The only allowed keys in entries of the modifications array are '" LDAP_MODIFY_BATCH_ATTRIB "', '" LDAP_MODIFY_BATCH_MODTYPE "' and '" LDAP_MODIFY_BATCH_VALUES "'");
+					RETURN_FALSE;
+				}
+
+				fetched = zend_hash_get_current_data(Z_ARRVAL_P(mod));
+				modinfo = fetched;
+
+				/* does the value type match the key? */
+				if (_ldap_str_equal_to_const(modkey->val, modkey->len, LDAP_MODIFY_BATCH_ATTRIB)) {
+					if (Z_TYPE_P(modinfo) != IS_STRING) {
+						php_error_docref(NULL TSRMLS_CC, E_WARNING, "A '" LDAP_MODIFY_BATCH_ATTRIB "' value must be a string");
+						RETURN_FALSE;
+					}
+
+					if (Z_STRLEN_P(modinfo) != _ldap_strlen_max(Z_STRVAL_P(modinfo), Z_STRLEN_P(modinfo))) {
+						php_error_docref(NULL TSRMLS_CC, E_WARNING, "A '" LDAP_MODIFY_BATCH_ATTRIB "' value must not contain NUL bytes");
+						RETURN_FALSE;
+					}
+				}
+				else if (_ldap_str_equal_to_const(modkey->val, modkey->len, LDAP_MODIFY_BATCH_MODTYPE)) {
+					if (Z_TYPE_P(modinfo) != IS_LONG) {
+						php_error_docref(NULL TSRMLS_CC, E_WARNING, "A '" LDAP_MODIFY_BATCH_MODTYPE "' value must be a long");
+						RETURN_FALSE;
+					}
+
+					/* is the value in range? */
+					modtype = Z_LVAL_P(modinfo);
+					if (
+						modtype != LDAP_MODIFY_BATCH_ADD &&
+						modtype != LDAP_MODIFY_BATCH_REMOVE &&
+						modtype != LDAP_MODIFY_BATCH_REPLACE &&
+						modtype != LDAP_MODIFY_BATCH_REMOVE_ALL
+					) {
+						php_error_docref(NULL TSRMLS_CC, E_WARNING, "The '" LDAP_MODIFY_BATCH_MODTYPE "' value must match one of the LDAP_MODIFY_BATCH_* constants");
+						RETURN_FALSE;
+					}
+
+					/* if it's REMOVE_ALL, there must not be a values array; otherwise, there must */
+					if (modtype == LDAP_MODIFY_BATCH_REMOVE_ALL) {
+						if (zend_hash_str_exists(Z_ARRVAL_P(mod), LDAP_MODIFY_BATCH_VALUES, strlen(LDAP_MODIFY_BATCH_VALUES))) {
+							php_error_docref(NULL TSRMLS_CC, E_WARNING, "If '" LDAP_MODIFY_BATCH_MODTYPE "' is LDAP_MODIFY_BATCH_REMOVE_ALL, a '" LDAP_MODIFY_BATCH_VALUES "' array must not be provided");
+							RETURN_FALSE;
+						}
+					}
+					else {
+						if (!zend_hash_str_exists(Z_ARRVAL_P(mod), LDAP_MODIFY_BATCH_VALUES, strlen(LDAP_MODIFY_BATCH_VALUES))) {
+							php_error_docref(NULL TSRMLS_CC, E_WARNING, "If '" LDAP_MODIFY_BATCH_MODTYPE "' is not LDAP_MODIFY_BATCH_REMOVE_ALL, a '" LDAP_MODIFY_BATCH_VALUES "' array must be provided");
+							RETURN_FALSE;
+						}
+					}
+				}
+				else if (_ldap_str_equal_to_const(modkey->val, modkey->len, LDAP_MODIFY_BATCH_VALUES)) {
+					if (Z_TYPE_P(modinfo) != IS_ARRAY) {
+						php_error_docref(NULL TSRMLS_CC, E_WARNING, "A '" LDAP_MODIFY_BATCH_VALUES "' value must be an array");
+						RETURN_FALSE;
+					}
+
+					/* is the array not empty? */
+					zend_hash_internal_pointer_reset(Z_ARRVAL_P(modinfo));
+					num_modvals = zend_hash_num_elements(Z_ARRVAL_P(modinfo));
+					if (num_modvals == 0) {
+						php_error_docref(NULL TSRMLS_CC, E_WARNING, "A '" LDAP_MODIFY_BATCH_VALUES "' array must have at least one element");
+						RETURN_FALSE;
+					}
+
+					/* are its keys integers? */
+					if (zend_hash_get_current_key_type(Z_ARRVAL_P(modinfo)) != HASH_KEY_IS_LONG) {
+						php_error_docref(NULL TSRMLS_CC, E_WARNING, "A '" LDAP_MODIFY_BATCH_VALUES "' array must not be string-indexed");
+						RETURN_FALSE;
+					}
+
+					/* are the keys consecutive? */
+					for (k = 0; k < num_modvals; k++) {
+						if ((fetched = zend_hash_index_find(Z_ARRVAL_P(modinfo), k)) == NULL) {
+							php_error_docref(NULL TSRMLS_CC, E_WARNING, "A '" LDAP_MODIFY_BATCH_VALUES "' array must have consecutive indices 0, 1, ...");
+							RETURN_FALSE;
+						}
+						modval = fetched;
+
+						/* is the data element a string? */
+						if (Z_TYPE_P(modval) != IS_STRING) {
+							php_error_docref(NULL TSRMLS_CC, E_WARNING, "Each element of a '" LDAP_MODIFY_BATCH_VALUES "' array must be a string");
+							RETURN_FALSE;
+						}
+					}
+				}
+
+				zend_hash_move_forward(Z_ARRVAL_P(mod));
+			}
+		}
+	}
+	/* validation was successful */
+
+	/* allocate array of modifications */
+	ldap_mods = safe_emalloc((num_mods+1), sizeof(LDAPMod *), 0);
+
+	/* for each modification */
+	for (i = 0; i < num_mods; i++) {
+		/* allocate the modification struct */
+		ldap_mods[i] = safe_emalloc(1, sizeof(LDAPMod), 0);
+
+		/* fetch the relevant data */
+		fetched = zend_hash_index_find(Z_ARRVAL_P(mods), i);
+		mod = fetched;
+
+		_ldap_hash_fetch(mod, LDAP_MODIFY_BATCH_ATTRIB, &attrib);
+		_ldap_hash_fetch(mod, LDAP_MODIFY_BATCH_MODTYPE, &modtype);
+		_ldap_hash_fetch(mod, LDAP_MODIFY_BATCH_VALUES, &vals);
+
+		/* map the modification type */
+		switch (Z_LVAL_P(modtype)) {
+			case LDAP_MODIFY_BATCH_ADD:
+				oper = LDAP_MOD_ADD;
+				break;
+			case LDAP_MODIFY_BATCH_REMOVE:
+			case LDAP_MODIFY_BATCH_REMOVE_ALL:
+				oper = LDAP_MOD_DELETE;
+				break;
+			case LDAP_MODIFY_BATCH_REPLACE:
+				oper = LDAP_MOD_REPLACE;
+				break;
+			default:
+				php_error_docref(NULL TSRMLS_CC, E_ERROR, "Unknown and uncaught modification type.");
+				RETURN_FALSE;
+		}
+
+		/* fill in the basic info */
+		ldap_mods[i]->mod_op = oper | LDAP_MOD_BVALUES;
+		ldap_mods[i]->mod_type = estrndup(Z_STRVAL_P(attrib), Z_STRLEN_P(attrib));
+
+		if (Z_LVAL_P(modtype) == LDAP_MODIFY_BATCH_REMOVE_ALL) {
+			/* no values */
+			ldap_mods[i]->mod_bvalues = NULL;
+		}
+		else {
+			/* allocate space for the values as part of this modification */
+			num_modvals = zend_hash_num_elements(Z_ARRVAL_P(vals));
+			ldap_mods[i]->mod_bvalues = safe_emalloc((num_modvals+1), sizeof(struct berval *), 0);
+
+			/* for each value */
+			for (j = 0; j < num_modvals; j++) {
+				/* fetch it */
+				fetched = zend_hash_index_find(Z_ARRVAL_P(vals), j);
+				modval = fetched;
+
+				/* allocate the data struct */
+				ldap_mods[i]->mod_bvalues[j] = safe_emalloc(1, sizeof(struct berval), 0);
+
+				/* fill it */
+				ldap_mods[i]->mod_bvalues[j]->bv_len = Z_STRLEN_P(modval);
+				ldap_mods[i]->mod_bvalues[j]->bv_val = estrndup(Z_STRVAL_P(modval), Z_STRLEN_P(modval));
+			}
+
+			/* NULL-terminate values */
+			ldap_mods[i]->mod_bvalues[num_modvals] = NULL;
+		}
+	}
+
+	/* NULL-terminate modifications */
+	ldap_mods[num_mods] = NULL;
+
+	/* perform (finally) */
+	if ((i = ldap_modify_ext_s(ld->link, dn, ldap_mods, NULL, NULL)) != LDAP_SUCCESS) {
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Batch Modify: %s", ldap_err2string(i));
+		RETVAL_FALSE;
+	} else RETVAL_TRUE;
+
+	/* clean up */
+	{
+		for (i = 0; i < num_mods; i++) {
+			/* attribute */
+			efree(ldap_mods[i]->mod_type);
+
+			if (ldap_mods[i]->mod_bvalues != NULL) {
+				/* each BER value */
+				for (j = 0; ldap_mods[i]->mod_bvalues[j] != NULL; j++) {
+					/* free the data bytes */
+					efree(ldap_mods[i]->mod_bvalues[j]->bv_val);
+
+					/* free the bvalue struct */
+					efree(ldap_mods[i]->mod_bvalues[j]);
+				}
+
+				/* the BER value array */
+				efree(ldap_mods[i]->mod_bvalues);
+			}
+
+			/* the modification */
+			efree(ldap_mods[i]);
+		}
+
+		/* the modifications array */
+		efree(ldap_mods);
+	}
+}
+/* }}} */
+
 /* {{{ proto int ldap_errno(resource link)
    Get the current ldap error number */
 PHP_FUNCTION(ldap_errno)
@@ -1443,7 +1821,7 @@ PHP_FUNCTION(ldap_errno)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, &link, -1, "ldap link", le_link);
+	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
 
 	RETURN_LONG(_get_lderrno(ld->link));
 }
@@ -1453,13 +1831,13 @@ PHP_FUNCTION(ldap_errno)
    Convert error number to error string */
 PHP_FUNCTION(ldap_err2str)
 {
-	long perrno;
+	zend_long perrno;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &perrno) != SUCCESS) {
 		return;
 	}
 
-	RETURN_STRING(ldap_err2string(perrno), 1);
+	RETURN_STRING(ldap_err2string(perrno));
 }
 /* }}} */
 
@@ -1475,11 +1853,11 @@ PHP_FUNCTION(ldap_error)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, &link, -1, "ldap link", le_link);
+	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
 
 	ld_errno = _get_lderrno(ld->link);
 
-	RETURN_STRING(ldap_err2string(ld_errno), 1);
+	RETURN_STRING(ldap_err2string(ld_errno));
 }
 /* }}} */
 
@@ -1489,7 +1867,7 @@ PHP_FUNCTION(ldap_compare)
 {
 	zval *link;
 	char *dn, *attr, *value;
-	int dn_len, attr_len, value_len;
+	size_t dn_len, attr_len, value_len;
 	ldap_linkdata *ld;
 	int errno;
 
@@ -1497,7 +1875,7 @@ PHP_FUNCTION(ldap_compare)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, &link, -1, "ldap link", le_link);
+	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
 
 	errno = ldap_compare_s(ld->link, dn, attr, value);
 
@@ -1523,16 +1901,16 @@ PHP_FUNCTION(ldap_sort)
 	zval *link, *result;
 	ldap_linkdata *ld;
 	char *sortfilter;
-	int sflen;
-	zend_rsrc_list_entry *le;
+	size_t sflen;
+	zend_resource *le;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrs", &link, &result, &sortfilter, &sflen) != SUCCESS) {
 		RETURN_FALSE;
 	}
 
-	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, &link, -1, "ldap link", le_link);
+	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
 
-	if (zend_hash_index_find(&EG(regular_list), Z_LVAL_P(result), (void **) &le) != SUCCESS || le->type != le_result) {
+	if ((le = zend_hash_index_find_ptr(&EG(regular_list), Z_RES_HANDLE_P(result))) == NULL || le->type != le_result) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Supplied resource is not a valid ldap result resource");
 		RETURN_FALSE;
 	}
@@ -1553,13 +1931,13 @@ PHP_FUNCTION(ldap_get_option)
 {
 	zval *link, *retval;
 	ldap_linkdata *ld;
-	long option;
+	zend_long option;
 	
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlz", &link, &option, &retval) != SUCCESS) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlz/", &link, &option, &retval) != SUCCESS) {
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, &link, -1, "ldap link", le_link);
+	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
 
 	switch (option) {
 	/* options with int value */
@@ -1578,7 +1956,7 @@ PHP_FUNCTION(ldap_get_option)
 			if (ldap_get_option(ld->link, option, &val)) {
 				RETURN_FALSE;
 			}
-			zval_dtor(retval);
+			zval_ptr_dtor(retval);
 			ZVAL_LONG(retval, val);
 		} break;
 #ifdef LDAP_OPT_NETWORK_TIMEOUT
@@ -1595,7 +1973,7 @@ PHP_FUNCTION(ldap_get_option)
 			if (!timeout) {
 				RETURN_FALSE;
 			}
-			zval_dtor(retval);
+			zval_ptr_dtor(retval);
 			ZVAL_LONG(retval, timeout->tv_sec);
 			ldap_memfree(timeout);
 		} break;
@@ -1607,7 +1985,7 @@ PHP_FUNCTION(ldap_get_option)
 			if (ldap_get_option(ld->link, LDAP_X_OPT_CONNECT_TIMEOUT, &timeout)) {
 				RETURN_FALSE;
 			}			
-			zval_dtor(retval);
+			zval_ptr_dtor(retval);
 			ZVAL_LONG(retval, (timeout / 1000));
 		} break;
 #endif
@@ -1634,8 +2012,8 @@ PHP_FUNCTION(ldap_get_option)
 				}
 				RETURN_FALSE;
 			}
-			zval_dtor(retval);
-			ZVAL_STRING(retval, val, 1);
+			zval_ptr_dtor(retval);
+			ZVAL_STRING(retval, val);
 			ldap_memfree(val);
 		} break;
 /* options not implemented
@@ -1655,19 +2033,19 @@ PHP_FUNCTION(ldap_get_option)
    Set the value of various session-wide parameters */
 PHP_FUNCTION(ldap_set_option) 
 {
-	zval *link, **newval;
+	zval *link, *newval;
 	ldap_linkdata *ld;
 	LDAP *ldap;
-	long option;
+	zend_long option;
 	
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zlZ", &link, &option, &newval) != SUCCESS) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zlz", &link, &option, &newval) != SUCCESS) {
 		return;
 	}
 
 	if (Z_TYPE_P(link) == IS_NULL) {
 		ldap = NULL;
 	} else {
-		ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, &link, -1, "ldap link", le_link);
+		ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
 		ldap = ld->link;
 	}
 
@@ -1685,7 +2063,7 @@ PHP_FUNCTION(ldap_set_option)
 			int val;
 
 			convert_to_long_ex(newval);
-			val = Z_LVAL_PP(newval);
+			val = Z_LVAL_P(newval);
 			if (ldap_set_option(ldap, option, &val)) {
 				RETURN_FALSE;
 			}
@@ -1696,7 +2074,7 @@ PHP_FUNCTION(ldap_set_option)
 			struct timeval timeout;
 
 			convert_to_long_ex(newval);
-			timeout.tv_sec = Z_LVAL_PP(newval);
+			timeout.tv_sec = Z_LVAL_P(newval);
 			timeout.tv_usec = 0;
 			if (ldap_set_option(ldap, LDAP_OPT_NETWORK_TIMEOUT, (void *) &timeout)) {
 				RETURN_FALSE;
@@ -1708,7 +2086,7 @@ PHP_FUNCTION(ldap_set_option)
 			int timeout;
 
 			convert_to_long_ex(newval);
-			timeout = 1000 * Z_LVAL_PP(newval); /* Convert to milliseconds */
+			timeout = 1000 * Z_LVAL_P(newval); /* Convert to milliseconds */
 			if (ldap_set_option(ldap, LDAP_X_OPT_CONNECT_TIMEOUT, &timeout)) {
 				RETURN_FALSE;
 			}			
@@ -1731,7 +2109,7 @@ PHP_FUNCTION(ldap_set_option)
 		{
 			char *val;
 			convert_to_string_ex(newval);
-			val = Z_STRVAL_PP(newval);
+			val = Z_STRVAL_P(newval);
 			if (ldap_set_option(ldap, option, val)) {
 				RETURN_FALSE;
 			}
@@ -1744,7 +2122,7 @@ PHP_FUNCTION(ldap_set_option)
 		{
 			void *val;
 			convert_to_boolean_ex(newval);
-			val = Z_LVAL_PP(newval)
+			val = Z_TYPE_P(newval) == IS_TRUE
 				? LDAP_OPT_ON : LDAP_OPT_OFF;
 			if (ldap_set_option(ldap, option, val)) {
 				RETURN_FALSE;
@@ -1755,51 +2133,49 @@ PHP_FUNCTION(ldap_set_option)
 	case LDAP_OPT_CLIENT_CONTROLS:
 		{
 			LDAPControl *ctrl, **ctrls, **ctrlp;
-			zval **ctrlval, **val;
+			zval *ctrlval, *val;
 			int ncontrols;
 			char error=0;
 
-			if ((Z_TYPE_PP(newval) != IS_ARRAY) || !(ncontrols = zend_hash_num_elements(Z_ARRVAL_PP(newval)))) {
+			if ((Z_TYPE_P(newval) != IS_ARRAY) || !(ncontrols = zend_hash_num_elements(Z_ARRVAL_P(newval)))) {
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Expected non-empty array value for this option");
 				RETURN_FALSE;
 			}
 			ctrls = safe_emalloc((1 + ncontrols), sizeof(*ctrls), 0);
 			*ctrls = NULL;
 			ctrlp = ctrls;
-			zend_hash_internal_pointer_reset(Z_ARRVAL_PP(newval));
-			while (zend_hash_get_current_data(Z_ARRVAL_PP(newval), (void**)&ctrlval) == SUCCESS) {
-				if (Z_TYPE_PP(ctrlval) != IS_ARRAY) {
+			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(newval), ctrlval) {
+				if (Z_TYPE_P(ctrlval) != IS_ARRAY) {
 					php_error_docref(NULL TSRMLS_CC, E_WARNING, "The array value must contain only arrays, where each array is a control");
 					error = 1;
 					break;
 				}
-				if (zend_hash_find(Z_ARRVAL_PP(ctrlval), "oid", sizeof("oid"), (void **) &val) != SUCCESS) {
+				if ((val = zend_hash_str_find(Z_ARRVAL_P(ctrlval), "oid", sizeof("oid") - 1)) == NULL) {
 					php_error_docref(NULL TSRMLS_CC, E_WARNING, "Control must have an oid key");
 					error = 1;
 					break;
 				}
 				ctrl = *ctrlp = emalloc(sizeof(**ctrlp));
 				convert_to_string_ex(val);
-				ctrl->ldctl_oid = Z_STRVAL_PP(val);
-				if (zend_hash_find(Z_ARRVAL_PP(ctrlval), "value", sizeof("value"), (void **) &val) == SUCCESS) {
+				ctrl->ldctl_oid = Z_STRVAL_P(val);
+				if ((val = zend_hash_str_find(Z_ARRVAL_P(ctrlval), "value", sizeof("value") - 1)) != NULL) {
 					convert_to_string_ex(val);
-					ctrl->ldctl_value.bv_val = Z_STRVAL_PP(val);
-					ctrl->ldctl_value.bv_len = Z_STRLEN_PP(val);
+					ctrl->ldctl_value.bv_val = Z_STRVAL_P(val);
+					ctrl->ldctl_value.bv_len = Z_STRLEN_P(val);
 				} else {
 					ctrl->ldctl_value.bv_val = NULL;
 					ctrl->ldctl_value.bv_len = 0;
 				}
-				if (zend_hash_find(Z_ARRVAL_PP(ctrlval), "iscritical", sizeof("iscritical"), (void **) &val) == SUCCESS) {
+				if ((val = zend_hash_str_find(Z_ARRVAL_P(ctrlval), "iscritical", sizeof("iscritical") - 1)) != NULL) {
 					convert_to_boolean_ex(val);
-					ctrl->ldctl_iscritical = Z_BVAL_PP(val);
+					ctrl->ldctl_iscritical = Z_TYPE_P(val) == IS_TRUE;
 				} else {
 					ctrl->ldctl_iscritical = 0;
 				}
 				
 				++ctrlp;
 				*ctrlp = NULL;
-				zend_hash_move_forward(Z_ARRVAL_PP(newval));
-			}
+			} ZEND_HASH_FOREACH_END();
 			if (!error) {
 				error = ldap_set_option(ldap, option, ctrls);
 			}
@@ -1832,12 +2208,12 @@ PHP_FUNCTION(ldap_parse_result)
 	char *lmatcheddn, *lerrmsg;
 	int rc, lerrcode, myargcount = ZEND_NUM_ARGS();
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrz|zzz", &link, &result, &errcode, &matcheddn, &errmsg, &referrals) != SUCCESS) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrz/|z/z/z/", &link, &result, &errcode, &matcheddn, &errmsg, &referrals) != SUCCESS) {
 		return; 
 	}
 
-	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, &link, -1, "ldap link", le_link);
-	ZEND_FETCH_RESOURCE(ldap_result, LDAPMessage *, &result, -1, "ldap result", le_result);
+	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
+	ZEND_FETCH_RESOURCE(ldap_result, LDAPMessage *, result, -1, "ldap result", le_result);
 
 	rc = ldap_parse_result(ld->link, ldap_result, &lerrcode,
 				myargcount > 3 ? &lmatcheddn : NULL,
@@ -1850,36 +2226,36 @@ PHP_FUNCTION(ldap_parse_result)
 		RETURN_FALSE;
 	}
 
-	zval_dtor(errcode);
+	zval_ptr_dtor(errcode);
 	ZVAL_LONG(errcode, lerrcode);
 
 	/* Reverse -> fall through */
 	switch (myargcount) {
 		case 6:
-			zval_dtor(referrals);
+			zval_ptr_dtor(referrals);
 			array_init(referrals);
 			if (lreferrals != NULL) {
 				refp = lreferrals;
 				while (*refp) {
-					add_next_index_string(referrals, *refp, 1);
+					add_next_index_string(referrals, *refp);
 					refp++;
 				}
 				ldap_value_free(lreferrals);
 			}
 		case 5:
-			zval_dtor(errmsg);
+			zval_ptr_dtor(errmsg);
 			if (lerrmsg == NULL) {
 				ZVAL_EMPTY_STRING(errmsg);
 			} else {
-				ZVAL_STRING(errmsg, lerrmsg, 1);
+				ZVAL_STRING(errmsg, lerrmsg);
 				ldap_memfree(lerrmsg);
 			}
 		case 4: 
-			zval_dtor(matcheddn);
+			zval_ptr_dtor(matcheddn);
 			if (lmatcheddn == NULL) {
 				ZVAL_EMPTY_STRING(matcheddn);
 			} else {
-				ZVAL_STRING(matcheddn, lmatcheddn, 1);
+				ZVAL_STRING(matcheddn, lmatcheddn);
 				ldap_memfree(lmatcheddn);
 			}
 	}
@@ -1901,16 +2277,15 @@ PHP_FUNCTION(ldap_first_reference)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, &link, -1, "ldap link", le_link);
-	ZEND_FETCH_RESOURCE(ldap_result, LDAPMessage *, &result, -1, "ldap result", le_result);
+	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
+	ZEND_FETCH_RESOURCE(ldap_result, LDAPMessage *, result, -1, "ldap result", le_result);
 
 	if ((entry = ldap_first_reference(ld->link, ldap_result)) == NULL) {
 		RETVAL_FALSE;
 	} else {
 		resultentry = emalloc(sizeof(ldap_resultentry));
 		ZEND_REGISTER_RESOURCE(return_value, resultentry, le_result_entry);
-		resultentry->id = Z_LVAL_P(result);
-		zend_list_addref(resultentry->id);
+		ZVAL_COPY(&resultentry->res, result);
 		resultentry->data = entry;
 		resultentry->ber = NULL;
 	}
@@ -1930,16 +2305,15 @@ PHP_FUNCTION(ldap_next_reference)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, &link, -1, "ldap link", le_link);
-	ZEND_FETCH_RESOURCE(resultentry, ldap_resultentry *, &result_entry, -1, "ldap result entry", le_result_entry);
+	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
+	ZEND_FETCH_RESOURCE(resultentry, ldap_resultentry *, result_entry, -1, "ldap result entry", le_result_entry);
 
 	if ((entry_next = ldap_next_reference(ld->link, resultentry->data)) == NULL) {
 		RETVAL_FALSE;
 	} else {
 		resultentry_next = emalloc(sizeof(ldap_resultentry));
 		ZEND_REGISTER_RESOURCE(return_value, resultentry_next, le_result_entry);
-		resultentry_next->id = resultentry->id;
-		zend_list_addref(resultentry->id);
+		ZVAL_COPY(&resultentry_next->res, &resultentry->res);
 		resultentry_next->data = entry_next;
 		resultentry_next->ber = NULL;
 	}
@@ -1956,23 +2330,23 @@ PHP_FUNCTION(ldap_parse_reference)
 	ldap_resultentry *resultentry;
 	char **lreferrals, **refp;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrz", &link, &result_entry, &referrals) != SUCCESS) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrz/", &link, &result_entry, &referrals) != SUCCESS) {
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, &link, -1, "ldap link", le_link);
-	ZEND_FETCH_RESOURCE(resultentry, ldap_resultentry *, &result_entry, -1, "ldap result entry", le_result_entry);
+	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
+	ZEND_FETCH_RESOURCE(resultentry, ldap_resultentry *, result_entry, -1, "ldap result entry", le_result_entry);
 
 	if (ldap_parse_reference(ld->link, resultentry->data, &lreferrals, NULL /* &serverctrls */, 0) != LDAP_SUCCESS) {
 		RETURN_FALSE;
 	}
 
-	zval_dtor(referrals);
+	zval_ptr_dtor(referrals);
 	array_init(referrals);
 	if (lreferrals != NULL) {
 		refp = lreferrals;
 		while (*refp) {
-			add_next_index_string(referrals, *refp, 1);
+			add_next_index_string(referrals, *refp);
 			refp++;
 		}
 		ldap_value_free(lreferrals);
@@ -1990,14 +2364,14 @@ PHP_FUNCTION(ldap_rename)
 	ldap_linkdata *ld;
 	int rc;
 	char *dn, *newrdn, *newparent;
-	int dn_len, newrdn_len, newparent_len;
+	size_t dn_len, newrdn_len, newparent_len;
 	zend_bool deleteoldrdn;
 	
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsssb", &link, &dn, &dn_len, &newrdn, &newrdn_len, &newparent, &newparent_len, &deleteoldrdn) != SUCCESS) {
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, &link, -1, "ldap link", le_link);
+	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
 
 	if (newparent_len == 0) {
 		newparent = NULL;
@@ -2034,7 +2408,7 @@ PHP_FUNCTION(ldap_start_tls)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, &link, -1, "ldap link", le_link);
+	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
 
 	if (((rc = ldap_set_option(ld->link, LDAP_OPT_PROTOCOL_VERSION, &protocol)) != LDAP_SUCCESS) ||
 		((rc = ldap_start_tls_s(ld->link, NULL, NULL)) != LDAP_SUCCESS)
@@ -2056,35 +2430,31 @@ int _ldap_rebind_proc(LDAP *ldap, const char *url, ber_tag_t req, ber_int_t msgi
 {
 	ldap_linkdata *ld;
 	int retval;
-	zval *cb_url;
-	zval **cb_args[2];
-	zval *cb_retval;
+	zval cb_args[2];
+	zval cb_retval;
 	zval *cb_link = (zval *) params;
 	TSRMLS_FETCH();
 
-	ld = (ldap_linkdata *) zend_fetch_resource(&cb_link TSRMLS_CC, -1, "ldap link", NULL, 1, le_link);
+	ld = (ldap_linkdata *) zend_fetch_resource(cb_link TSRMLS_CC, -1, "ldap link", NULL, 1, le_link);
 
 	/* link exists and callback set? */
-	if (ld == NULL || ld->rebindproc == NULL) {
+	if (ld == NULL || Z_ISUNDEF(ld->rebindproc)) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Link not found or no callback set");
 		return LDAP_OTHER;
 	}
 
 	/* callback */
-	MAKE_STD_ZVAL(cb_url);
-	ZVAL_STRING(cb_url, estrdup(url), 0);
-	cb_args[0] = &cb_link;
-	cb_args[1] = &cb_url;
-	if (call_user_function_ex(EG(function_table), NULL, ld->rebindproc, &cb_retval, 2, cb_args, 0, NULL TSRMLS_CC) == SUCCESS && cb_retval) {
+	ZVAL_COPY_VALUE(&cb_args[0], cb_link);
+	ZVAL_STRING(&cb_args[1], url);
+	if (call_user_function_ex(EG(function_table), NULL, &ld->rebindproc, &cb_retval, 2, cb_args, 0, NULL TSRMLS_CC) == SUCCESS && !Z_ISUNDEF(cb_retval)) {
 		convert_to_long_ex(&cb_retval);
-		retval = Z_LVAL_P(cb_retval);
+		retval = Z_LVAL(cb_retval);
 		zval_ptr_dtor(&cb_retval);
 	} else {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "rebind_proc PHP callback failed");
 		retval = LDAP_OTHER;
 	}
-	zval_dtor(cb_url);
-	FREE_ZVAL(cb_url);
+	zval_ptr_dtor(&cb_args[1]);
 	return retval;
 }
 /* }}} */
@@ -2095,20 +2465,19 @@ PHP_FUNCTION(ldap_set_rebind_proc)
 {
 	zval *link, *callback;
 	ldap_linkdata *ld;
-	char *callback_name;
+	zend_string *callback_name;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz", &link, &callback) != SUCCESS) {
 		RETURN_FALSE;
 	}
 
-	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, &link, -1, "ldap link", le_link);
+	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
 
 	if (Z_TYPE_P(callback) == IS_STRING && Z_STRLEN_P(callback) == 0) {
 		/* unregister rebind procedure */
-		if (ld->rebindproc != NULL) {
-			zval_dtor(ld->rebindproc);
-			FREE_ZVAL(ld->rebindproc);
-			ld->rebindproc = NULL;
+		if (!Z_ISUNDEF(ld->rebindproc)) {
+			zval_ptr_dtor(&ld->rebindproc);
+			ZVAL_UNDEF(&ld->rebindproc);
 			ldap_set_rebind_proc(ld->link, NULL, NULL);
 		}
 		RETURN_TRUE;
@@ -2116,27 +2485,104 @@ PHP_FUNCTION(ldap_set_rebind_proc)
 
 	/* callable? */
 	if (!zend_is_callable(callback, 0, &callback_name TSRMLS_CC)) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Two arguments expected for '%s' to be a valid callback", callback_name);
-		efree(callback_name);
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Two arguments expected for '%s' to be a valid callback", callback_name->val);
+		zend_string_release(callback_name);
 		RETURN_FALSE;
 	}
-	efree(callback_name);
+	zend_string_release(callback_name);
 
 	/* register rebind procedure */
-	if (ld->rebindproc == NULL) {
+	if (Z_ISUNDEF(ld->rebindproc)) {
 		ldap_set_rebind_proc(ld->link, _ldap_rebind_proc, (void *) link);
 	} else {
-		zval_dtor(ld->rebindproc);
+		zval_ptr_dtor(&ld->rebindproc);
 	}
 
-	ALLOC_ZVAL(ld->rebindproc);
-	*ld->rebindproc = *callback;
-	zval_copy_ctor(ld->rebindproc);
+	ZVAL_COPY(&ld->rebindproc, callback);
 	RETURN_TRUE;
 }
 /* }}} */
 #endif
 
+static void php_ldap_do_escape(const zend_bool *map, const char *value, size_t valuelen, char **result, size_t *resultlen)
+{
+	char hex[] = "0123456789abcdef";
+	int i, p = 0;
+	size_t len = 0;
+
+	for (i = 0; i < valuelen; i++) {
+		len += (map[(unsigned char) value[i]]) ? 3 : 1;
+	}
+
+	(*result) = (char *) safe_emalloc(1, len, 1);
+	(*resultlen) = len;
+
+	for (i = 0; i < valuelen; i++) {
+		unsigned char v = (unsigned char) value[i];
+
+		if (map[v]) {
+			(*result)[p++] = '\\';
+			(*result)[p++] = hex[v >> 4];
+			(*result)[p++] = hex[v & 0x0f];
+		} else {
+			(*result)[p++] = v;
+		}
+	}
+
+	(*result)[p++] = '\0';
+}
+
+static void php_ldap_escape_map_set_chars(zend_bool *map, const char *chars, const int charslen, char escape)
+{
+	int i = 0;
+	while (i < charslen) {
+		map[(unsigned char) chars[i++]] = escape;
+	}
+}
+
+PHP_FUNCTION(ldap_escape)
+{
+	char *value, *ignores, *result;
+	size_t valuelen = 0, ignoreslen = 0;
+	int i;
+	size_t resultlen;
+	zend_long flags = 0;
+	zend_bool map[256] = {0}, havecharlist = 0;
+
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|sl", &value, &valuelen, &ignores, &ignoreslen, &flags) != SUCCESS) {
+		return;
+	}
+
+	if (!valuelen) {
+		RETURN_EMPTY_STRING();
+	}
+
+	if (flags & PHP_LDAP_ESCAPE_FILTER) {
+		havecharlist = 1;
+		php_ldap_escape_map_set_chars(map, "\\*()\0", sizeof("\\*()\0") - 1, 1);
+	}
+
+	if (flags & PHP_LDAP_ESCAPE_DN) {
+		havecharlist = 1;
+		php_ldap_escape_map_set_chars(map, "\\,=+<>;\"#", sizeof("\\,=+<>;\"#") - 1, 1);
+	}
+
+	if (!havecharlist) {
+		for (i = 0; i < 256; i++) {
+			map[i] = 1;
+		}
+	}
+
+	if (ignoreslen) {
+		php_ldap_escape_map_set_chars(map, ignores, ignoreslen, 0);
+	}
+
+	php_ldap_do_escape(map, value, valuelen, &result, &resultlen);
+
+	RETVAL_STRINGL(result, resultlen);
+	efree(result);
+}
+
 #ifdef STR_TRANSLATION
 /* {{{ php_ldap_do_translate
  */
@@ -2160,7 +2606,7 @@ static void php_ldap_do_translate(INTERNAL_FUNCTION_PARAMETERS, int way)
 	}
 
 	if (result == LDAP_SUCCESS) {
-		RETVAL_STRINGL(value, value_len, 1);
+		RETVAL_STRINGL(value, value_len);
 		free(value);
 	} else {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Conversion from iso-8859-1 to t61 failed: %s", ldap_err2string(result));
@@ -2191,11 +2637,11 @@ PHP_FUNCTION(ldap_8859_to_t61)
    Inject paged results control*/
 PHP_FUNCTION(ldap_control_paged_result) 
 {
-	long pagesize;
+	zend_long pagesize;
 	zend_bool iscritical;
 	zval *link;
 	char *cookie = NULL;
-	int cookie_len = 0;
+	size_t cookie_len = 0;
 	struct berval lcookie = { 0, NULL };
 	ldap_linkdata *ld;
 	LDAP *ldap;
@@ -2210,7 +2656,7 @@ PHP_FUNCTION(ldap_control_paged_result)
 	if (Z_TYPE_P(link) == IS_NULL) {
 		ldap = NULL;
 	} else {
-		ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, &link, -1, "ldap link", le_link);
+		ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
 		ldap = ld->link;
 	}
 
@@ -2262,9 +2708,9 @@ PHP_FUNCTION(ldap_control_paged_result)
 		/* return a PHP control object */
 		array_init(return_value);
 
-		add_assoc_string(return_value, "oid", ctrl.ldctl_oid, 1);
+		add_assoc_string(return_value, "oid", ctrl.ldctl_oid);
 		if (ctrl.ldctl_value.bv_len) {
-			add_assoc_stringl(return_value, "value", ctrl.ldctl_value.bv_val, ctrl.ldctl_value.bv_len, 1);
+			add_assoc_stringl(return_value, "value", ctrl.ldctl_value.bv_val, ctrl.ldctl_value.bv_len);
 		}
 		if (ctrl.ldctl_iscritical) {
 			add_assoc_bool(return_value, "iscritical", ctrl.ldctl_iscritical);
@@ -2293,12 +2739,12 @@ PHP_FUNCTION(ldap_control_paged_result_response)
 	ber_tag_t tag;
 	int rc, lerrcode, myargcount = ZEND_NUM_ARGS();
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rr|zz", &link, &result, &cookie, &estimated) != SUCCESS) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rr|z/z/", &link, &result, &cookie, &estimated) != SUCCESS) {
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, &link, -1, "ldap link", le_link);
-	ZEND_FETCH_RESOURCE(ldap_result, LDAPMessage *, &result, -1, "ldap result", le_result);
+	ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
+	ZEND_FETCH_RESOURCE(ldap_result, LDAPMessage *, result, -1, "ldap result", le_result);
 
 	rc = ldap_parse_result(ld->link,
 				ldap_result,
@@ -2359,11 +2805,11 @@ PHP_FUNCTION(ldap_control_paged_result_response)
 		ZVAL_LONG(estimated, lestimated);
 	}
 
-	zval_dtor(cookie);
+	zval_ptr_dtor(cookie);
  	if (lcookie.bv_len == 0) {
 		ZVAL_EMPTY_STRING(cookie);
  	} else {
-		ZVAL_STRINGL(cookie, lcookie.bv_val, lcookie.bv_len, 1);
+		ZVAL_STRINGL(cookie, lcookie.bv_val, lcookie.bv_len);
  	}
  	ldap_memfree(lcookie.bv_val);
 
@@ -2516,6 +2962,12 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_ldap_modify, 0, 0, 3)
 	ZEND_ARG_INFO(0, entry)
 ZEND_END_ARG_INFO()
 
+ZEND_BEGIN_ARG_INFO_EX(arginfo_ldap_modify_batch, 0, 0, 3)
+	ZEND_ARG_INFO(0, link_identifier)
+	ZEND_ARG_INFO(0, dn)
+	ZEND_ARG_ARRAY_INFO(0, modifications_info, 0)
+ZEND_END_ARG_INFO()
+
 ZEND_BEGIN_ARG_INFO_EX(arginfo_ldap_mod_add, 0, 0, 3)
 	ZEND_ARG_INFO(0, link_identifier)
 	ZEND_ARG_INFO(0, dn)
@@ -2626,6 +3078,12 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_ldap_set_rebind_proc, 0, 0, 2)
 ZEND_END_ARG_INFO()
 #endif
 
+ZEND_BEGIN_ARG_INFO_EX(arginfo_ldap_escape, 0, 0, 1)
+	ZEND_ARG_INFO(0, value)
+	ZEND_ARG_INFO(0, ignore)
+	ZEND_ARG_INFO(0, flags)
+ZEND_END_ARG_INFO()
+
 #ifdef STR_TRANSLATION
 ZEND_BEGIN_ARG_INFO_EX(arginfo_ldap_t61_to_8859, 0, 0, 1)
 	ZEND_ARG_INFO(0, value)
@@ -2669,6 +3127,7 @@ const zend_function_entry ldap_functions[] = {
 	PHP_FE(ldap_dn2ufn,									arginfo_ldap_dn2ufn)
 	PHP_FE(ldap_add,									arginfo_ldap_add)
 	PHP_FE(ldap_delete,									arginfo_ldap_delete)
+	PHP_FE(ldap_modify_batch,							arginfo_ldap_modify_batch)
 	PHP_FALIAS(ldap_modify,		ldap_mod_replace,		arginfo_ldap_modify)
 
 /* additional functions for attribute based modifications, Gerrit Thomson */
@@ -2704,6 +3163,8 @@ const zend_function_entry ldap_functions[] = {
 	PHP_FE(ldap_set_rebind_proc,						arginfo_ldap_set_rebind_proc)
 #endif
 
+	PHP_FE(ldap_escape,									arginfo_ldap_escape)
+
 #ifdef STR_TRANSLATION
 	PHP_FE(ldap_t61_to_8859,							arginfo_ldap_t61_to_8859)
 	PHP_FE(ldap_8859_to_t61,							arginfo_ldap_8859_to_t61)