Use zend_string for DBA fetch handler

ext/dba/dba.c

@@ -979,15 +979,13 @@ PHP_FUNCTION(dba_fetch)
 		}
 	}
 
-	char *val;
-	size_t len = 0;
-	if ((val = info->hnd->fetch(info, ZSTR_VAL(key_str), ZSTR_LEN(key_str), skip, &len)) == NULL) {
+	zend_string *val;
+	if ((val = info->hnd->fetch(info, key_str, skip)) == NULL) {
 		DBA_RELEASE_HT_KEY_CREATION();
 		RETURN_FALSE;
 	}
 	DBA_RELEASE_HT_KEY_CREATION();
-	RETVAL_STRINGL(val, len);
-	efree(val);
+	RETURN_STR(val);
 }
 /* }}} */
 

ext/dba/dba_cdb.c

@@ -145,32 +145,30 @@ DBA_CLOSE_FUNC(cdb)
 DBA_FETCH_FUNC(cdb)
 {
 	CDB_INFO;
+	zend_string *fetched_val = NULL;
 	unsigned int len;
-	char *new_entry = NULL;
 
 #if DBA_CDB_BUILTIN
 	if (cdb->make)
 		return NULL; /* database was opened writeonly */
 #endif
-	if (php_cdb_find(&cdb->c, key, keylen) == 1) {
+	if (php_cdb_find(&cdb->c, ZSTR_VAL(key), ZSTR_LEN(key)) == 1) {
 		while(skip--) {
-			if (php_cdb_findnext(&cdb->c, key, keylen) != 1) {
+			if (php_cdb_findnext(&cdb->c, ZSTR_VAL(key), ZSTR_LEN(key)) != 1) {
 				return NULL;
 			}
 		}
 		len = cdb_datalen(&cdb->c);
-		new_entry = safe_emalloc(len, 1, 1);
+		fetched_val = zend_string_alloc(len, /* persistent */ false);
 
-		if (php_cdb_read(&cdb->c, new_entry, len, cdb_datapos(&cdb->c)) == -1) {
-			efree(new_entry);
+		if (php_cdb_read(&cdb->c, ZSTR_VAL(fetched_val), len, cdb_datapos(&cdb->c)) == -1) {
+			zend_string_release_ex(fetched_val, /* persistent */ false);
 			return NULL;
 		}
-		new_entry[len] = 0;
-		if (newlen)
-			*newlen = len;
+		ZSTR_VAL(fetched_val)[len] = 0;
 	}
 
-	return new_entry;
+	return fetched_val;
 }
 
 DBA_UPDATE_FUNC(cdb)

ext/dba/dba_db1.c

@@ -88,13 +88,12 @@ DBA_FETCH_FUNC(db1)
 	DBT gval;
 	DBT gkey;
 
-	gkey.data = (char *) key;
-	gkey.size = keylen;
+	gkey.data = ZSTR_VAL(key);
+	gkey.size = ZSTR_LEN(key);
 
 	memset(&gval, 0, sizeof(gval));
 	if (dba->dbp->get(dba->dbp, &gkey, &gval, 0) == RET_SUCCESS) {
-		if (newlen) *newlen = gval.size;
-		return estrndup(gval.data, gval.size);
+		return zend_string_init(gval.data, gval.size, /* persistent */ false);
 	}
 	return NULL;
 }

ext/dba/dba_db2.c

@@ -87,15 +87,14 @@ DBA_FETCH_FUNC(db2)
 	DBT gval = {0};
 	DBT gkey = {0};
 
-	gkey.data = (char *) key;
-	gkey.size = keylen;
+	gkey.data = ZSTR_VAL(key);
+	gkey.size = ZSTR_LEN(key);
 
 	if (dba->dbp->get(dba->dbp, NULL, &gkey, &gval, 0)) {
 		return NULL;
 	}
 
-	if (newlen) *newlen = gval.size;
-	return estrndup(gval.data, gval.size);
+	return zend_string_init(gval.data, gval.size, /* persistent */ false);
 }
 
 DBA_UPDATE_FUNC(db2)

ext/dba/dba_db3.c

@@ -117,18 +117,17 @@ DBA_FETCH_FUNC(db3)
 {
 	dba_db3_data *dba = info->dbf;
 	DBT gval;
-	char *new = NULL;
 	DBT gkey;
 
 	memset(&gkey, 0, sizeof(gkey));
-	gkey.data = (char *) key; gkey.size = keylen;
+	gkey.data = ZSTR_VAL(key);
+	gkey.size = ZSTR_LEN(key);
 
 	memset(&gval, 0, sizeof(gval));
 	if (!dba->dbp->get(dba->dbp, NULL, &gkey, &gval, 0)) {
-		if (newlen) *newlen = gval.size;
-		new = estrndup(gval.data, gval.size);
+		return zend_string_init(gval.data, gval.size, /* persistent */ false);
 	}
-	return new;
+	return NULL;
 }
 
 DBA_UPDATE_FUNC(db3)

ext/dba/dba_db4.c

@@ -146,25 +146,24 @@ DBA_FETCH_FUNC(db4)
 {
 	dba_db4_data *dba = info->dbf;
 	DBT gval;
-	char *new = NULL;
 	DBT gkey;
+	zend_string *fetched_value = NULL;
 
 	memset(&gkey, 0, sizeof(gkey));
-	gkey.data = (char *) key;
-	gkey.size = keylen;
+	gkey.data = ZSTR_VAL(key);
+	gkey.size = ZSTR_LEN(key);
 
 	memset(&gval, 0, sizeof(gval));
 	if (info->flags & DBA_PERSISTENT) {
 		gval.flags |= DB_DBT_MALLOC;
 	}
 	if (!dba->dbp->get(dba->dbp, NULL, &gkey, &gval, 0)) {
-		if (newlen) *newlen = gval.size;
-		new = estrndup(gval.data, gval.size);
+		fetched_value = zend_string_init(gval.data, gval.size, /* persistent */ false);
 		if (info->flags & DBA_PERSISTENT) {
 			free(gval.data);
 		}
 	}
-	return new;
+	return fetched_value;
 }
 
 DBA_UPDATE_FUNC(db4)

ext/dba/dba_dbm.c

@@ -85,17 +85,15 @@ DBA_CLOSE_FUNC(dbm)
 DBA_FETCH_FUNC(dbm)
 {
 	datum gval;
-	char *new = NULL;
 	datum gkey;
 
-	gkey.dptr = (char *) key;
-	gkey.dsize = keylen;
+	gkey.dptr = ZSTR_VAL(key);
+	gkey.dsize = ZSTR_LEN(key);
 	gval = fetch(gkey);
-	if(gval.dptr) {
-		if(newlen) *newlen = gval.dsize;
-		new = estrndup(gval.dptr, gval.dsize);
+	if (gval.dptr) {
+		return zend_string_init(gval.dptr, gval.dsize, /* persistent */ false);
 	}
-	return new;
+	return NULL;
 }
 
 DBA_UPDATE_FUNC(dbm)

ext/dba/dba_flatfile.c

@@ -56,21 +56,18 @@ DBA_FETCH_FUNC(flatfile)
 {
 	flatfile *dba = info->dbf;
 	datum gval;
-	char *new = NULL;
 	datum gkey;
+	zend_string *fetched_val = NULL;
 
-	gkey.dptr = (char *) key;
-	gkey.dsize = keylen;
+	gkey.dptr = ZSTR_VAL(key);
+	gkey.dsize = ZSTR_LEN(key);
 
 	gval = flatfile_fetch(dba, gkey);
 	if (gval.dptr) {
-		if (newlen) {
-			*newlen = gval.dsize;
-		}
-		new = estrndup(gval.dptr, gval.dsize);
+		fetched_val = zend_string_init(gval.dptr, gval.dsize, /* persistent */ false);
 		efree(gval.dptr);
 	}
-	return new;
+	return fetched_val;
 }
 
 DBA_UPDATE_FUNC(flatfile)

ext/dba/dba_gdbm.c

@@ -71,18 +71,18 @@ DBA_FETCH_FUNC(gdbm)
 {
 	dba_gdbm_data *dba = info->dbf;
 	datum gval;
-	char *new = NULL;
 	datum gkey;
+	zend_string *fetched_val = NULL;
+
+	gkey.dptr = ZSTR_VAL(key);
+	gkey.dsize = ZSTR_LEN(key);
 
-	gkey.dptr = (char *) key;
-	gkey.dsize = keylen;
 	gval = gdbm_fetch(dba->dbf, gkey);
-	if(gval.dptr) {
-		if(newlen) *newlen = gval.dsize;
-		new = estrndup(gval.dptr, gval.dsize);
+	if (gval.dptr) {
+		fetched_val = zend_string_init(gval.dptr, gval.dsize, /* persistent */ false);
 		free(gval.dptr);
 	}
-	return new;
+	return fetched_val;
 }
 
 DBA_UPDATE_FUNC(gdbm)

ext/dba/dba_inifile.c

@@ -51,17 +51,21 @@ DBA_FETCH_FUNC(inifile)
 	inifile *dba = info->dbf;
 	val_type ini_val;
 	key_type ini_key;
+	zend_string *fetched_val = NULL;
 
 	if (!key) {
 		php_error_docref(NULL, E_WARNING, "No key specified");
 		return 0;
 	}
-	ini_key = inifile_key_split((char*)key); /* keylen not needed here */
+	ini_key = inifile_key_split(ZSTR_VAL(key)); /* keylen not needed here */
 
 	ini_val = inifile_fetch(dba, &ini_key, skip);
-	*newlen = ini_val.value ? strlen(ini_val.value) : 0;
 	inifile_key_free(&ini_key);
-	return ini_val.value;
+	if (ini_val.value) {
+		fetched_val = zend_string_init(ini_val.value, strlen(ini_val.value), /* persistent */ false);
+		inifile_val_free(&ini_val);
+	}
+	return fetched_val;
 }
 
 DBA_UPDATE_FUNC(inifile)

ext/dba/dba_lmdb.c

@@ -108,7 +108,7 @@ DBA_FETCH_FUNC(lmdb)
 {
 	int rc;
 	MDB_val k, v;
-	char *ret = NULL;
+	zend_string *ret = NULL;
 
 	if (LMDB_IT(cur)) {
 		rc = mdb_txn_renew(LMDB_IT(txn));
@@ -116,25 +116,24 @@ DBA_FETCH_FUNC(lmdb)
 		rc = mdb_txn_begin(LMDB_IT(env), NULL, MDB_RDONLY, &LMDB_IT(txn));
 	}
 	if (rc) {
-		php_error_docref1(NULL, key, E_WARNING, "%s", mdb_strerror(rc));
+		php_error_docref(NULL, E_WARNING, "%s", mdb_strerror(rc));
 		return NULL;
 	}
 
-	k.mv_size = keylen;
-	k.mv_data = key;
+	k.mv_size = ZSTR_LEN(key);
+	k.mv_data = ZSTR_VAL(key);
 
 	rc = mdb_get(LMDB_IT(txn), LMDB_IT(dbi), &k, &v);
 	if (rc) {
 		if (MDB_NOTFOUND != rc) {
-			php_error_docref1(NULL, key, E_WARNING, "%s", mdb_strerror(rc));
+			php_error_docref(NULL, E_WARNING, "%s", mdb_strerror(rc));
 		}
 		mdb_txn_abort(LMDB_IT(txn));
 		return NULL;
 	}
 
 	if (v.mv_data) {
-		if(newlen) *newlen = v.mv_size;
-		ret = estrndup(v.mv_data, v.mv_size);
+		ret = zend_string_init(v.mv_data, v.mv_size, /* persistent */ false);
 	}
 
 	if (LMDB_IT(cur)) {

ext/dba/dba_ndbm.c

@@ -66,17 +66,15 @@ DBA_CLOSE_FUNC(ndbm)
 DBA_FETCH_FUNC(ndbm)
 {
 	datum gval;
-	char *new = NULL;
 	datum gkey;
 
-	gkey.dptr = (char *) key;
-	gkey.dsize = keylen;
+	gkey.dptr = ZSTR_VAL(key);
+	gkey.dsize = ZSTR_LEN(key);
 	gval = dbm_fetch(info->dbf, gkey);
-	if(gval.dptr) {
-		if(newlen) *newlen = gval.dsize;
-		new = estrndup(gval.dptr, gval.dsize);
+	if (gval.dptr) {
+		return zend_string_init(gval.dptr, gval.dsize, /* persistent */ false);
 	}
-	return new;
+	return NULL;
 }
 
 DBA_UPDATE_FUNC(ndbm)

ext/dba/dba_qdbm.c

@@ -74,17 +74,17 @@ DBA_CLOSE_FUNC(qdbm)
 DBA_FETCH_FUNC(qdbm)
 {
 	dba_qdbm_data *dba = info->dbf;
-	char *value, *new = NULL;
+	char *value;
 	int value_size;
+	zend_string *fetched_val = NULL;
 
-	value = dpget(dba->dbf, key, keylen, 0, -1, &value_size);
+	value = dpget(dba->dbf, ZSTR_VAL(key), ZSTR_LEN(key), 0, -1, &value_size);
 	if (value) {
-		if (newlen) *newlen = value_size;
-		new = estrndup(value, value_size);
+		fetched_val = zend_string_init(value, value_size, /* persistent */ false);
 		free(value);
 	}
 
-	return new;
+	return fetched_val;
 }
 
 DBA_UPDATE_FUNC(qdbm)

ext/dba/dba_tcadb.c

@@ -84,19 +84,17 @@ DBA_CLOSE_FUNC(tcadb)
 DBA_FETCH_FUNC(tcadb)
 {
 	dba_tcadb_data *dba = info->dbf;
-	char *value, *new = NULL;
+	char *value;
 	int value_size;
+	zend_string *fetched_val = NULL;
 
-	value = tcadbget(dba->tcadb, key, keylen, &value_size);
+	value = tcadbget(dba->tcadb, ZSTR_VAL(key), ZSTR_LEN(key), &value_size);
 	if (value) {
-		if (newlen) {
-			*newlen = value_size;
-		}
-		new = estrndup(value, value_size);
+		fetched_val = zend_string_init(value, value_size, /* persistent */ false);
 		tcfree(value);
 	}
 
-	return new;
+	return fetched_val;
 }
 
 DBA_UPDATE_FUNC(tcadb)

ext/dba/php_dba.h

@@ -73,7 +73,7 @@ typedef struct dba_handler {
 	int flags; /* whether and how dba does locking and other flags*/
 	zend_result (*open)(dba_info *, char **error);
 	void (*close)(dba_info *);
-	char* (*fetch)(dba_info *, char *, size_t, int, size_t *);
+	zend_string* (*fetch)(dba_info *, zend_string *, int);
 	zend_result (*update)(dba_info *, char *, size_t, char *, size_t, int);
 	zend_result (*exists)(dba_info *, char *, size_t);
 	zend_result (*delete)(dba_info *, char *, size_t);
@@ -92,7 +92,7 @@ typedef struct dba_handler {
 #define DBA_CLOSE_FUNC(x) \
 	void dba_close_##x(dba_info *info)
 #define DBA_FETCH_FUNC(x) \
-	char *dba_fetch_##x(dba_info *info, char *key, size_t keylen, int skip, size_t *newlen)
+	zend_string *dba_fetch_##x(dba_info *info, zend_string *key, int skip)
 #define DBA_UPDATE_FUNC(x) \
 	zend_result dba_update_##x(dba_info *info, char *key, size_t keylen, char *val, size_t vallen, int mode)
 #define DBA_EXISTS_FUNC(x) \