Use zend_string for DBA first/next key handlers

Girgias · Girgias · commit d71d0cf0bb14 · 2021-11-11T11:12:41.000Z
diff --git a/ext/dba/dba.c b/ext/dba/dba.c
@@ -1020,8 +1020,6 @@ PHP_FUNCTION(dba_key_split)
 /* {{{ Resets the internal key pointer and returns the first key */
 PHP_FUNCTION(dba_firstkey)
 {
-	char *fkey;
-	size_t len;
 	zval *id;
 	dba_info *info = NULL;
 
@@ -1031,12 +1029,10 @@ PHP_FUNCTION(dba_firstkey)
 
 	DBA_FETCH_RESOURCE(info, id);
 
-	fkey = info->hnd->firstkey(info, &len);
+	zend_string *fkey = info->hnd->firstkey(info);
 
 	if (fkey) {
-		RETVAL_STRINGL(fkey, len);
-		efree(fkey);
-		return;
+		RETURN_STR(fkey);
 	}
 
 	RETURN_FALSE;
@@ -1046,8 +1042,6 @@ PHP_FUNCTION(dba_firstkey)
 /* {{{ Returns the next key */
 PHP_FUNCTION(dba_nextkey)
 {
-	char *nkey;
-	size_t len;
 	zval *id;
 	dba_info *info = NULL;
 
@@ -1057,12 +1051,10 @@ PHP_FUNCTION(dba_nextkey)
 
 	DBA_FETCH_RESOURCE(info, id);
 
-	nkey = info->hnd->nextkey(info, &len);
+	zend_string *nkey = info->hnd->nextkey(info);
 
 	if (nkey) {
-		RETVAL_STRINGL(nkey, len);
-		efree(nkey);
-		return;
+		RETURN_STR(nkey);
 	}
 
 	RETURN_FALSE;
diff --git a/ext/dba/dba_cdb.c b/ext/dba/dba_cdb.c
@@ -241,7 +241,7 @@ DBA_FIRSTKEY_FUNC(cdb)
 	CDB_INFO;
 	uint32 klen, dlen;
 	char buf[8];
-	char *key;
+	zend_string *key;
 
 #if DBA_CDB_BUILTIN
 	if (cdb->make)
@@ -262,13 +262,12 @@ DBA_FIRSTKEY_FUNC(cdb)
 	uint32_unpack(buf, &klen);
 	uint32_unpack(buf + 4, &dlen);
 
-	key = safe_emalloc(klen, 1, 1);
-	if (cdb_file_read(cdb->file, key, klen) < klen) {
-		efree(key);
+	key = zend_string_alloc(klen, /* persistent */ false);
+	if (cdb_file_read(cdb->file, ZSTR_VAL(key), klen) < klen) {
+		zend_string_release_ex(key, /* persistent */ false);
 		key = NULL;
 	} else {
-		key[klen] = '\0';
-		if (newlen) *newlen = klen;
+		ZSTR_VAL(key)[klen] = 0;
 	}
 
 	/*       header + klenlen + dlenlen + klen + dlen */
@@ -282,7 +281,7 @@ DBA_NEXTKEY_FUNC(cdb)
 	CDB_INFO;
 	uint32 klen, dlen;
 	char buf[8];
-	char *key;
+	zend_string *key;
 
 #if DBA_CDB_BUILTIN
 	if (cdb->make)
@@ -294,13 +293,12 @@ DBA_NEXTKEY_FUNC(cdb)
 	uint32_unpack(buf, &klen);
 	uint32_unpack(buf + 4, &dlen);
 
-	key = safe_emalloc(klen, 1, 1);
-	if (cdb_file_read(cdb->file, key, klen) < klen) {
-		efree(key);
+	key = zend_string_alloc(klen, /* persistent */ false);
+	if (cdb_file_read(cdb->file, ZSTR_VAL(key), klen) < klen) {
+		zend_string_release_ex(key, /* persistent */ false);
 		key = NULL;
 	} else {
-		key[klen] = '\0';
-		if (newlen) *newlen = klen;
+		ZSTR_VAL(key)[klen] = 0;
 	}
 
 	cdb->pos += 8 + klen + dlen;
diff --git a/ext/dba/dba_db1.c b/ext/dba/dba_db1.c
@@ -146,8 +146,7 @@ DBA_FIRSTKEY_FUNC(db1)
 	memset(&gval, 0, sizeof(gval));
 
 	if (dba->dbp->seq(dba->dbp, &gkey, &gval, R_FIRST) == RET_SUCCESS) {
-		if (newlen) *newlen = gkey.size;
-		return estrndup(gkey.data, gkey.size);
+		return zend_string_init(gkey.data, gkey.size, /* persistent */ false);
 	}
 	return NULL;
 }
@@ -162,8 +161,7 @@ DBA_NEXTKEY_FUNC(db1)
 	memset(&gval, 0, sizeof(gval));
 
 	if (dba->dbp->seq(dba->dbp, &gkey, &gval, R_NEXT) == RET_SUCCESS) {
-		if (newlen) *newlen = gkey.size;
-		return estrndup(gkey.data, gkey.size);
+		return zend_string_init(gkey.data, gkey.size, /* persistent */ false);
 	}
 	return NULL;
 }
diff --git a/ext/dba/dba_db2.c b/ext/dba/dba_db2.c
@@ -159,8 +159,7 @@ DBA_FIRSTKEY_FUNC(db2)
 		return NULL;
 	}
 
-	/* we should introduce something like PARAM_PASSTHRU... */
-	return dba_nextkey_db2(info, newlen);
+	return dba_nextkey_db2(info);
 }
 
 DBA_NEXTKEY_FUNC(db2)
@@ -169,11 +168,11 @@ DBA_NEXTKEY_FUNC(db2)
 	DBT gkey = {0}, gval = {0};
 
 	if (dba->cursor->c_get(dba->cursor, &gkey, &gval, DB_NEXT)
-			|| !gkey.data)
+			|| !gkey.data) {
 		return NULL;
+	}
 
-	if (newlen) *newlen = gkey.size;
-	return estrndup(gkey.data, gkey.size);
+	return zend_string_init(gkey.data, gkey.size, /* persistent */ false);
 }
 
 DBA_OPTIMIZE_FUNC(db2)
diff --git a/ext/dba/dba_db3.c b/ext/dba/dba_db3.c
@@ -193,27 +193,24 @@ DBA_FIRSTKEY_FUNC(db3)
 		return NULL;
 	}
 
-	/* we should introduce something like PARAM_PASSTHRU... */
-	return dba_nextkey_db3(info, newlen);
+	return dba_nextkey_db3(info);
 }
 
 DBA_NEXTKEY_FUNC(db3)
 {
 	dba_db3_data *dba = info->dbf;
 	DBT gkey, gval;
-	char *nkey = NULL;
 
 	memset(&gkey, 0, sizeof(gkey));
 	memset(&gval, 0, sizeof(gval));
 
 	if (dba->cursor->c_get(dba->cursor, &gkey, &gval, DB_NEXT) == 0) {
 		if (gkey.data) {
-			nkey = estrndup(gkey.data, gkey.size);
-			if (newlen) *newlen = gkey.size;
+			return zend_string_init(gkey.data, gkey.size, /* persistent */ false);
 		}
 	}
 
-	return nkey;
+	return NULL;
 }
 
 DBA_OPTIMIZE_FUNC(db3)
diff --git a/ext/dba/dba_db4.c b/ext/dba/dba_db4.c
@@ -237,15 +237,14 @@ DBA_FIRSTKEY_FUNC(db4)
 		return NULL;
 	}
 
-	/* we should introduce something like PARAM_PASSTHRU... */
-	return dba_nextkey_db4(info, newlen);
+	return dba_nextkey_db4(info);
 }
 
 DBA_NEXTKEY_FUNC(db4)
 {
 	dba_db4_data *dba = info->dbf;
 	DBT gkey, gval;
-	char *nkey = NULL;
+	zend_string *key = NULL;
 
 	memset(&gkey, 0, sizeof(gkey));
 	memset(&gval, 0, sizeof(gval));
@@ -256,8 +255,7 @@ DBA_NEXTKEY_FUNC(db4)
 	}
 	if (dba->cursor && dba->cursor->c_get(dba->cursor, &gkey, &gval, DB_NEXT) == 0) {
 		if (gkey.data) {
-			nkey = estrndup(gkey.data, gkey.size);
-			if (newlen) *newlen = gkey.size;
+			key = zend_string_init(gkey.data, gkey.size, /* persistent */ false);
 		}
 		if (info->flags & DBA_PERSISTENT) {
 			if (gkey.data) {
@@ -269,7 +267,7 @@ DBA_NEXTKEY_FUNC(db4)
 		}
 	}
 
-	return nkey;
+	return key;
 }
 
 DBA_OPTIMIZE_FUNC(db4)
diff --git a/ext/dba/dba_dbm.c b/ext/dba/dba_dbm.c
@@ -145,34 +145,34 @@ DBA_FIRSTKEY_FUNC(dbm)
 {
 	dba_dbm_data *dba = info->dbf;
 	datum gkey;
-	char *key = NULL;
+	zend_string *key = NULL;
 
 	gkey = firstkey();
-	if(gkey.dptr) {
-		if(newlen) *newlen = gkey.dsize;
-		key = estrndup(gkey.dptr, gkey.dsize);
+	if (gkey.dptr) {
+		key = zend_string_init(gkey.dptr, gkey.dsize, /* persistent */ false);
 		dba->nextkey = gkey;
-	} else
+	} else {
 		dba->nextkey.dptr = NULL;
+	}
 	return key;
 }
 
 DBA_NEXTKEY_FUNC(dbm)
 {
 	dba_dbm_data *dba = info->dbf;
 	datum gkey;
-	char *nkey = NULL;
+	zend_string *key = NULL;
 
-	if(!dba->nextkey.dptr) return NULL;
+	if (!dba->nextkey.dptr) { return NULL; }
 
 	gkey = nextkey(dba->nextkey);
-	if(gkey.dptr) {
-		if(newlen) *newlen = gkey.dsize;
-		nkey = estrndup(gkey.dptr, gkey.dsize);
+	if (gkey.dptr) {
+		key = zend_string_init(gkey.dptr, gkey.dsize, /* persistent */ false);
 		dba->nextkey = gkey;
-	} else
+	} else {
 		dba->nextkey.dptr = NULL;
-	return nkey;
+	}
+	return key;
 }
 
 DBA_OPTIMIZE_FUNC(dbm)
diff --git a/ext/dba/dba_flatfile.c b/ext/dba/dba_flatfile.c
@@ -132,10 +132,7 @@ DBA_FIRSTKEY_FUNC(flatfile)
 	}
 	dba->nextkey = flatfile_firstkey(dba);
 	if (dba->nextkey.dptr) {
-		if (newlen)  {
-			*newlen = dba->nextkey.dsize;
-		}
-		return estrndup(dba->nextkey.dptr, dba->nextkey.dsize);
+		return zend_string_init(dba->nextkey.dptr, dba->nextkey.dsize, /* persistent */ false);
 	}
 	return NULL;
 }
@@ -153,10 +150,7 @@ DBA_NEXTKEY_FUNC(flatfile)
 	}
 	dba->nextkey = flatfile_nextkey(dba);
 	if (dba->nextkey.dptr) {
-		if (newlen) {
-			*newlen = dba->nextkey.dsize;
-		}
-		return estrndup(dba->nextkey.dptr, dba->nextkey.dsize);
+		return zend_string_init(dba->nextkey.dptr, dba->nextkey.dsize, /* persistent */ false);
 	}
 	return NULL;
 }
diff --git a/ext/dba/dba_gdbm.c b/ext/dba/dba_gdbm.c
@@ -138,16 +138,15 @@ DBA_FIRSTKEY_FUNC(gdbm)
 {
 	dba_gdbm_data *dba = info->dbf;
 	datum gkey;
-	char *key = NULL;
+	zend_string *key = NULL;
 
-	if(dba->nextkey.dptr) {
+	if (dba->nextkey.dptr) {
 		free(dba->nextkey.dptr);
 	}
 
 	gkey = gdbm_firstkey(dba->dbf);
-	if(gkey.dptr) {
-		key = estrndup(gkey.dptr, gkey.dsize);
-		if(newlen) *newlen = gkey.dsize;
+	if (gkey.dptr) {
+		key = zend_string_init(gkey.dptr, gkey.dsize, /* persistent */ false);
 		dba->nextkey = gkey;
 	} else {
 		dba->nextkey.dptr = NULL;
@@ -158,21 +157,20 @@ DBA_FIRSTKEY_FUNC(gdbm)
 DBA_NEXTKEY_FUNC(gdbm)
 {
 	dba_gdbm_data *dba = info->dbf;
-	char *nkey = NULL;
+	zend_string *key = NULL;
 	datum gkey;
 
-	if(!dba->nextkey.dptr) return NULL;
+	if(!dba->nextkey.dptr) { return NULL; }
 
 	gkey = gdbm_nextkey(dba->dbf, dba->nextkey);
 	free(dba->nextkey.dptr);
-	if(gkey.dptr) {
-		nkey = estrndup(gkey.dptr, gkey.dsize);
-		if(newlen) *newlen = gkey.dsize;
+	if (gkey.dptr) {
+		key = zend_string_init(gkey.dptr, gkey.dsize, /* persistent */ false);
 		dba->nextkey = gkey;
 	} else {
 		dba->nextkey.dptr = NULL;
 	}
-	return nkey;
+	return key;
 }
 
 DBA_OPTIMIZE_FUNC(gdbm)
diff --git a/ext/dba/dba_inifile.c b/ext/dba/dba_inifile.c
@@ -148,8 +148,9 @@ DBA_FIRSTKEY_FUNC(inifile)
 
 	if (inifile_firstkey(dba)) {
 		char *result = inifile_key_string(&dba->curr.key);
-		*newlen = strlen(result);
-		return result;
+		zend_string *key = zend_string_init(result, strlen(result), /* persistent */ false);
+		efree(result);
+		return key;
 	} else {
 		return NULL;
 	}
@@ -165,8 +166,9 @@ DBA_NEXTKEY_FUNC(inifile)
 
 	if (inifile_nextkey(dba)) {
 		char *result = inifile_key_string(&dba->curr.key);
-		*newlen = strlen(result);
-		return result;
+		zend_string *key = zend_string_init(result, strlen(result), /* persistent */ false);
+		efree(result);
+		return key;
 	} else {
 		return NULL;
 	}
diff --git a/ext/dba/dba_lmdb.c b/ext/dba/dba_lmdb.c
@@ -250,7 +250,7 @@ DBA_FIRSTKEY_FUNC(lmdb)
 {
 	int rc;
 	MDB_val k, v;
-	char *ret = NULL;
+	zend_string *ret = NULL;
 
 	rc = mdb_txn_begin(LMDB_IT(env), NULL, MDB_RDONLY, &LMDB_IT(txn));
 	if (rc) {
@@ -276,9 +276,8 @@ DBA_FIRSTKEY_FUNC(lmdb)
 		return NULL;
 	}
 
-	if(k.mv_data) {
-		if(newlen) *newlen = k.mv_size;
-		ret = estrndup(k.mv_data, k.mv_size);
+	if (k.mv_data) {
+		ret = zend_string_init(k.mv_data, k.mv_size, /* persistent */ false);
 	}
 
 	mdb_txn_reset(LMDB_IT(txn));
@@ -290,7 +289,7 @@ DBA_NEXTKEY_FUNC(lmdb)
 {
 	int rc;
 	MDB_val k, v;
-	char *ret = NULL;
+	zend_string *ret = NULL;
 
 	rc = mdb_txn_renew(LMDB_IT(txn));
 	if (rc) {
@@ -309,9 +308,8 @@ DBA_NEXTKEY_FUNC(lmdb)
 		return NULL;
 	}
 
-	if(k.mv_data) {
-		if(newlen) *newlen = k.mv_size;
-		ret = estrndup(k.mv_data, k.mv_size);
+	if (k.mv_data) {
+		ret = zend_string_init(k.mv_data, k.mv_size, /* persistent */ false);
 	}
 
 	mdb_txn_reset(LMDB_IT(txn));
diff --git a/ext/dba/dba_ndbm.c b/ext/dba/dba_ndbm.c
diff --git a/ext/dba/dba_qdbm.c b/ext/dba/dba_qdbm.c
diff --git a/ext/dba/dba_tcadb.c b/ext/dba/dba_tcadb.c
diff --git a/ext/dba/php_dba.h b/ext/dba/php_dba.h

Original file line number	Diff line number	Diff line change
`@@ -146,8 +146,7 @@ DBA_FIRSTKEY_FUNC(db1)`
`146`	`146`	`memset(&gval, 0, sizeof(gval));`
`147`	`147`
`148`	`148`	`if (dba->dbp->seq(dba->dbp, &gkey, &gval, R_FIRST) == RET_SUCCESS) {`
`149`		`- if (newlen) *newlen = gkey.size;`
`150`		`- return estrndup(gkey.data, gkey.size);`
	`149`	`+ return zend_string_init(gkey.data, gkey.size, /* persistent */ false);`
`151`	`150`	`}`
`152`	`151`	`return NULL;`
`153`	`152`	`}`
`@@ -162,8 +161,7 @@ DBA_NEXTKEY_FUNC(db1)`
`162`	`161`	`memset(&gval, 0, sizeof(gval));`
`163`	`162`
`164`	`163`	`if (dba->dbp->seq(dba->dbp, &gkey, &gval, R_NEXT) == RET_SUCCESS) {`
`165`		`- if (newlen) *newlen = gkey.size;`
`166`		`- return estrndup(gkey.data, gkey.size);`
	`164`	`+ return zend_string_init(gkey.data, gkey.size, /* persistent */ false);`
`167`	`165`	`}`
`168`	`166`	`return NULL;`
`169`	`167`	`}`
Original file line number	Diff line number	Diff line change
`@@ -159,8 +159,7 @@ DBA_FIRSTKEY_FUNC(db2)`
`159`	`159`	`return NULL;`
`160`	`160`	`}`
`161`	`161`
`162`		`- /* we should introduce something like PARAM_PASSTHRU... */`
`163`		`- return dba_nextkey_db2(info, newlen);`
	`162`	`+ return dba_nextkey_db2(info);`
`164`	`163`	`}`
`165`	`164`
`166`	`165`	`DBA_NEXTKEY_FUNC(db2)`
`@@ -169,11 +168,11 @@ DBA_NEXTKEY_FUNC(db2)`
`169`	`168`	`DBT gkey = {0}, gval = {0};`
`170`	`169`
`171`	`170`	`if (dba->cursor->c_get(dba->cursor, &gkey, &gval, DB_NEXT)`
`172`		`- \|\| !gkey.data)`
	`171`	`+ \|\| !gkey.data) {`
`173`	`172`	`return NULL;`
	`173`	`+ }`
`174`	`174`
`175`		`- if (newlen) *newlen = gkey.size;`
`176`		`- return estrndup(gkey.data, gkey.size);`
	`175`	`+ return zend_string_init(gkey.data, gkey.size, /* persistent */ false);`
`177`	`176`	`}`
`178`	`177`
`179`	`178`	`DBA_OPTIMIZE_FUNC(db2)`
Original file line number	Diff line number	Diff line change
`@@ -193,27 +193,24 @@ DBA_FIRSTKEY_FUNC(db3)`
`193`	`193`	`return NULL;`
`194`	`194`	`}`
`195`	`195`
`196`		`- /* we should introduce something like PARAM_PASSTHRU... */`
`197`		`- return dba_nextkey_db3(info, newlen);`
	`196`	`+ return dba_nextkey_db3(info);`
`198`	`197`	`}`
`199`	`198`
`200`	`199`	`DBA_NEXTKEY_FUNC(db3)`
`201`	`200`	`{`
`202`	`201`	`dba_db3_data *dba = info->dbf;`
`203`	`202`	`DBT gkey, gval;`
`204`		`- char *nkey = NULL;`
`205`	`203`
`206`	`204`	`memset(&gkey, 0, sizeof(gkey));`
`207`	`205`	`memset(&gval, 0, sizeof(gval));`
`208`	`206`
`209`	`207`	`if (dba->cursor->c_get(dba->cursor, &gkey, &gval, DB_NEXT) == 0) {`
`210`	`208`	`if (gkey.data) {`
`211`		`- nkey = estrndup(gkey.data, gkey.size);`
`212`		`- if (newlen) *newlen = gkey.size;`
	`209`	`+ return zend_string_init(gkey.data, gkey.size, /* persistent */ false);`
`213`	`210`	`}`
`214`	`211`	`}`
`215`	`212`
`216`		`- return nkey;`
	`213`	`+ return NULL;`
`217`	`214`	`}`
`218`	`215`
`219`	`216`	`DBA_OPTIMIZE_FUNC(db3)`
Original file line number	Diff line number	Diff line change
`@@ -237,15 +237,14 @@ DBA_FIRSTKEY_FUNC(db4)`
`237`	`237`	`return NULL;`
`238`	`238`	`}`
`239`	`239`
`240`		`- /* we should introduce something like PARAM_PASSTHRU... */`
`241`		`- return dba_nextkey_db4(info, newlen);`
	`240`	`+ return dba_nextkey_db4(info);`
`242`	`241`	`}`
`243`	`242`
`244`	`243`	`DBA_NEXTKEY_FUNC(db4)`
`245`	`244`	`{`
`246`	`245`	`dba_db4_data *dba = info->dbf;`
`247`	`246`	`DBT gkey, gval;`
`248`		`- char *nkey = NULL;`
	`247`	`+ zend_string *key = NULL;`
`249`	`248`
`250`	`249`	`memset(&gkey, 0, sizeof(gkey));`
`251`	`250`	`memset(&gval, 0, sizeof(gval));`
`@@ -256,8 +255,7 @@ DBA_NEXTKEY_FUNC(db4)`
`256`	`255`	`}`
`257`	`256`	`if (dba->cursor && dba->cursor->c_get(dba->cursor, &gkey, &gval, DB_NEXT) == 0) {`
`258`	`257`	`if (gkey.data) {`
`259`		`- nkey = estrndup(gkey.data, gkey.size);`
`260`		`- if (newlen) *newlen = gkey.size;`
	`258`	`+ key = zend_string_init(gkey.data, gkey.size, /* persistent */ false);`
`261`	`259`	`}`
`262`	`260`	`if (info->flags & DBA_PERSISTENT) {`
`263`	`261`	`if (gkey.data) {`
`@@ -269,7 +267,7 @@ DBA_NEXTKEY_FUNC(db4)`
`269`	`267`	`}`
`270`	`268`	`}`
`271`	`269`
`272`		`- return nkey;`
	`270`	`+ return key;`
`273`	`271`	`}`
`274`	`272`
`275`	`273`	`DBA_OPTIMIZE_FUNC(db4)`
Original file line number	Diff line number	Diff line change
`@@ -132,10 +132,7 @@ DBA_FIRSTKEY_FUNC(flatfile)`
`132`	`132`	`}`
`133`	`133`	`dba->nextkey = flatfile_firstkey(dba);`
`134`	`134`	`if (dba->nextkey.dptr) {`
`135`		`- if (newlen) {`
`136`		`- *newlen = dba->nextkey.dsize;`
`137`		`- }`
`138`		`- return estrndup(dba->nextkey.dptr, dba->nextkey.dsize);`
	`135`	`+ return zend_string_init(dba->nextkey.dptr, dba->nextkey.dsize, /* persistent */ false);`
`139`	`136`	`}`
`140`	`137`	`return NULL;`
`141`	`138`	`}`
`@@ -153,10 +150,7 @@ DBA_NEXTKEY_FUNC(flatfile)`
`153`	`150`	`}`
`154`	`151`	`dba->nextkey = flatfile_nextkey(dba);`
`155`	`152`	`if (dba->nextkey.dptr) {`
`156`		`- if (newlen) {`
`157`		`- *newlen = dba->nextkey.dsize;`
`158`		`- }`
`159`		`- return estrndup(dba->nextkey.dptr, dba->nextkey.dsize);`
	`153`	`+ return zend_string_init(dba->nextkey.dptr, dba->nextkey.dsize, /* persistent */ false);`
`160`	`154`	`}`
`161`	`155`	`return NULL;`
`162`	`156`	`}`
Original file line number	Diff line number	Diff line change
`@@ -250,7 +250,7 @@ DBA_FIRSTKEY_FUNC(lmdb)`
`250`	`250`	`{`
`251`	`251`	`int rc;`
`252`	`252`	`MDB_val k, v;`
`253`		`- char *ret = NULL;`
	`253`	`+ zend_string *ret = NULL;`
`254`	`254`
`255`	`255`	`rc = mdb_txn_begin(LMDB_IT(env), NULL, MDB_RDONLY, &LMDB_IT(txn));`
`256`	`256`	`if (rc) {`
`@@ -276,9 +276,8 @@ DBA_FIRSTKEY_FUNC(lmdb)`
`276`	`276`	`return NULL;`
`277`	`277`	`}`
`278`	`278`
`279`		`- if(k.mv_data) {`
`280`		`- if(newlen) *newlen = k.mv_size;`
`281`		`- ret = estrndup(k.mv_data, k.mv_size);`
	`279`	`+ if (k.mv_data) {`
	`280`	`+ ret = zend_string_init(k.mv_data, k.mv_size, /* persistent */ false);`
`282`	`281`	`}`
`283`	`282`
`284`	`283`	`mdb_txn_reset(LMDB_IT(txn));`
`@@ -290,7 +289,7 @@ DBA_NEXTKEY_FUNC(lmdb)`
`290`	`289`	`{`
`291`	`290`	`int rc;`
`292`	`291`	`MDB_val k, v;`
`293`		`- char *ret = NULL;`
	`292`	`+ zend_string *ret = NULL;`
`294`	`293`
`295`	`294`	`rc = mdb_txn_renew(LMDB_IT(txn));`
`296`	`295`	`if (rc) {`
`@@ -309,9 +308,8 @@ DBA_NEXTKEY_FUNC(lmdb)`
`309`	`308`	`return NULL;`
`310`	`309`	`}`
`311`	`310`
`312`		`- if(k.mv_data) {`
`313`		`- if(newlen) *newlen = k.mv_size;`
`314`		`- ret = estrndup(k.mv_data, k.mv_size);`
	`311`	`+ if (k.mv_data) {`
	`312`	`+ ret = zend_string_init(k.mv_data, k.mv_size, /* persistent */ false);`
`315`	`313`	`}`
`316`	`314`
`317`	`315`	`mdb_txn_reset(LMDB_IT(txn));`