X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fscript%2Flua_api%2Fl_noise.cpp;h=e3e76191f841adefef4693f7695a751a80fec007;hb=b4106ca58f723a64bcaec619b7f5c686f5e4abb2;hp=43dd320235f52b0947599c05dc3b5ca7137930cf;hpb=54f1267c2c87daea769966c694777a2e5977f870;p=dragonfireclient.git

diff --git a/src/script/lua_api/l_noise.cpp b/src/script/lua_api/l_noise.cpp
index 43dd32023..e3e76191f 100644
--- a/src/script/lua_api/l_noise.cpp
+++ b/src/script/lua_api/l_noise.cpp
@@ -22,6 +22,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "common/c_converter.h"
 #include "common/c_content.h"
 #include "log.h"
+#include "porting.h"
+#include "util/numeric.h"
 
 ///////////////////////////////////////
 /*
@@ -133,7 +135,7 @@ void LuaPerlinNoise::Register(lua_State *L)
 
 
 const char LuaPerlinNoise::className[] = "PerlinNoise";
-const luaL_reg LuaPerlinNoise::methods[] = {
+const luaL_Reg LuaPerlinNoise::methods[] = {
 	luamethod(LuaPerlinNoise, get2d),
 	luamethod(LuaPerlinNoise, get3d),
 	{0,0}
@@ -144,7 +146,7 @@ const luaL_reg LuaPerlinNoise::methods[] = {
   LuaPerlinNoiseMap
 */
 
-LuaPerlinNoiseMap::LuaPerlinNoiseMap(NoiseParams *params, int seed, v3s16 size)
+LuaPerlinNoiseMap::LuaPerlinNoiseMap(NoiseParams *params, s32 seed, v3s16 size)
 {
 	m_is3d = size.Z > 1;
 	np = *params;
@@ -391,7 +393,7 @@ void LuaPerlinNoiseMap::Register(lua_State *L)
 
 
 const char LuaPerlinNoiseMap::className[] = "PerlinNoiseMap";
-const luaL_reg LuaPerlinNoiseMap::methods[] = {
+const luaL_Reg LuaPerlinNoiseMap::methods[] = {
 	luamethod(LuaPerlinNoiseMap, get2dMap),
 	luamethod(LuaPerlinNoiseMap, get2dMap_flat),
 	luamethod(LuaPerlinNoiseMap, calc2dMap),
@@ -440,7 +442,7 @@ int LuaPseudoRandom::create_object(lua_State *L)
 {
 	NO_MAP_LOCK_REQUIRED;
 
-	int seed = luaL_checknumber(L, 1);
+	u64 seed = luaL_checknumber(L, 1);
 	LuaPseudoRandom *o = new LuaPseudoRandom(seed);
 	*(void **)(lua_newuserdata(L, sizeof(void *))) = o;
 	luaL_getmetatable(L, className);
@@ -496,7 +498,7 @@ void LuaPseudoRandom::Register(lua_State *L)
 
 
 const char LuaPseudoRandom::className[] = "PseudoRandom";
-const luaL_reg LuaPseudoRandom::methods[] = {
+const luaL_Reg LuaPseudoRandom::methods[] = {
 	luamethod(LuaPseudoRandom, next),
 	{0,0}
 };
@@ -537,8 +539,8 @@ int LuaPcgRandom::create_object(lua_State *L)
 {
 	NO_MAP_LOCK_REQUIRED;
 
-	lua_Integer seed = luaL_checknumber(L, 1);
-	LuaPcgRandom *o  = lua_isnumber(L, 2) ?
+	u64 seed = luaL_checknumber(L, 1);
+	LuaPcgRandom *o = lua_isnumber(L, 2) ?
 		new LuaPcgRandom(seed, lua_tointeger(L, 2)) :
 		new LuaPcgRandom(seed);
 	*(void **)(lua_newuserdata(L, sizeof(void *))) = o;
@@ -595,8 +597,121 @@ void LuaPcgRandom::Register(lua_State *L)
 
 
 const char LuaPcgRandom::className[] = "PcgRandom";
-const luaL_reg LuaPcgRandom::methods[] = {
+const luaL_Reg LuaPcgRandom::methods[] = {
 	luamethod(LuaPcgRandom, next),
 	luamethod(LuaPcgRandom, rand_normal_dist),
 	{0,0}
 };
+
+///////////////////////////////////////
+/*
+	LuaSecureRandom
+*/
+
+bool LuaSecureRandom::fillRandBuf()
+{
+	return porting::secure_rand_fill_buf(m_rand_buf, RAND_BUF_SIZE);
+}
+
+int LuaSecureRandom::l_next_bytes(lua_State *L)
+{
+	NO_MAP_LOCK_REQUIRED;
+
+	LuaSecureRandom *o = checkobject(L, 1);
+	u32 count = lua_isnumber(L, 2) ? lua_tointeger(L, 2) : 1;
+
+	// Limit count
+	count = MYMIN(RAND_BUF_SIZE, count);
+
+	// Find out whether we can pass directly from our array, or have to do some gluing
+	size_t count_remaining = RAND_BUF_SIZE - o->m_rand_idx;
+	if (count_remaining >= count) {
+		lua_pushlstring(L, o->m_rand_buf + o->m_rand_idx, count);
+		o->m_rand_idx += count;
+	} else {
+		char output_buf[RAND_BUF_SIZE];
+
+		// Copy over with what we have left from our current buffer
+		memcpy(output_buf, o->m_rand_buf + o->m_rand_idx, count_remaining);
+
+		// Refill buffer and copy over the remainder of what was requested
+		o->fillRandBuf();
+		memcpy(output_buf + count_remaining, o->m_rand_buf, count - count_remaining);
+
+		// Update index
+		o->m_rand_idx = count - count_remaining;
+
+		lua_pushlstring(L, output_buf, count);
+	}
+
+	return 1;
+}
+
+
+int LuaSecureRandom::create_object(lua_State *L)
+{
+	LuaSecureRandom *o = new LuaSecureRandom();
+
+	// Fail and return nil if we can't securely fill the buffer
+	if (!o->fillRandBuf()) {
+		delete o;
+		return 0;
+	}
+
+	*(void **)(lua_newuserdata(L, sizeof(void *))) = o;
+	luaL_getmetatable(L, className);
+	lua_setmetatable(L, -2);
+	return 1;
+}
+
+
+int LuaSecureRandom::gc_object(lua_State *L)
+{
+	LuaSecureRandom *o = *(LuaSecureRandom **)(lua_touserdata(L, 1));
+	delete o;
+	return 0;
+}
+
+
+LuaSecureRandom *LuaSecureRandom::checkobject(lua_State *L, int narg)
+{
+	luaL_checktype(L, narg, LUA_TUSERDATA);
+	void *ud = luaL_checkudata(L, narg, className);
+	if (!ud)
+		luaL_typerror(L, narg, className);
+	return *(LuaSecureRandom **)ud;
+}
+
+
+void LuaSecureRandom::Register(lua_State *L)
+{
+	lua_newtable(L);
+	int methodtable = lua_gettop(L);
+	luaL_newmetatable(L, className);
+	int metatable = lua_gettop(L);
+
+	lua_pushliteral(L, "__metatable");
+	lua_pushvalue(L, methodtable);
+	lua_settable(L, metatable);
+
+	lua_pushliteral(L, "__index");
+	lua_pushvalue(L, methodtable);
+	lua_settable(L, metatable);
+
+	lua_pushliteral(L, "__gc");
+	lua_pushcfunction(L, gc_object);
+	lua_settable(L, metatable);
+
+	lua_pop(L, 1);
+
+	luaL_openlib(L, 0, methods, 0);
+	lua_pop(L, 1);
+
+	lua_register(L, className, create_object);
+}
+
+const char LuaSecureRandom::className[] = "SecureRandom";
+const luaL_Reg LuaSecureRandom::methods[] = {
+	luamethod(LuaSecureRandom, next_bytes),
+	{0,0}
+};