2013-08-11 04:09:45 +02:00
|
|
|
/*
|
|
|
|
Minetest
|
|
|
|
Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2.1 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU Lesser General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU Lesser General Public License along
|
|
|
|
with this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
*/
|
|
|
|
|
2021-04-23 21:37:24 +02:00
|
|
|
#include "irrlichttypes_extrabloated.h"
|
2013-08-11 04:09:45 +02:00
|
|
|
#include "lua_api/l_util.h"
|
|
|
|
#include "lua_api/l_internal.h"
|
2014-12-12 20:49:19 +01:00
|
|
|
#include "lua_api/l_settings.h"
|
2013-08-11 04:09:45 +02:00
|
|
|
#include "common/c_converter.h"
|
|
|
|
#include "common/c_content.h"
|
2014-04-15 19:41:07 +02:00
|
|
|
#include "cpp_api/s_async.h"
|
2014-09-14 23:42:08 +02:00
|
|
|
#include "serialization.h"
|
2016-08-10 12:10:00 +02:00
|
|
|
#include <json/json.h>
|
2022-09-28 15:06:14 +02:00
|
|
|
#include <zstd.h>
|
2014-09-09 21:17:01 +02:00
|
|
|
#include "cpp_api/s_security.h"
|
2014-04-27 23:55:49 +02:00
|
|
|
#include "porting.h"
|
2017-09-26 20:30:14 +02:00
|
|
|
#include "convert_json.h"
|
2016-02-25 09:47:28 +01:00
|
|
|
#include "debug.h"
|
2013-08-11 04:09:45 +02:00
|
|
|
#include "log.h"
|
|
|
|
#include "tool.h"
|
2014-09-12 00:22:05 +02:00
|
|
|
#include "filesys.h"
|
2013-08-11 04:09:45 +02:00
|
|
|
#include "settings.h"
|
2015-04-12 04:49:13 +02:00
|
|
|
#include "util/auth.h"
|
2016-05-28 05:37:28 +02:00
|
|
|
#include "util/base64.h"
|
2014-05-07 04:31:35 +02:00
|
|
|
#include "config.h"
|
|
|
|
#include "version.h"
|
2017-10-30 08:18:18 +01:00
|
|
|
#include "util/hex.h"
|
|
|
|
#include "util/sha1.h"
|
2021-07-29 05:10:10 +02:00
|
|
|
#include "util/png.h"
|
2021-04-23 21:37:24 +02:00
|
|
|
#include <cstdio>
|
2014-05-07 04:31:35 +02:00
|
|
|
|
2013-08-11 04:09:45 +02:00
|
|
|
// log([level,] text)
|
|
|
|
// Writes a line to the logger.
|
2020-04-22 00:07:12 +02:00
|
|
|
// The one-argument version logs to LL_NONE.
|
2015-10-26 00:12:39 +01:00
|
|
|
// The two-argument version accepts a log level.
|
|
|
|
// Either the special case "deprecated" for deprecation notices, or any specified in
|
|
|
|
// Logger::stringToLevel(name).
|
2013-08-11 04:09:45 +02:00
|
|
|
int ModApiUtil::l_log(lua_State *L)
|
|
|
|
{
|
|
|
|
NO_MAP_LOCK_REQUIRED;
|
|
|
|
std::string text;
|
2015-10-13 09:57:44 +02:00
|
|
|
LogLevel level = LL_NONE;
|
2013-08-11 04:09:45 +02:00
|
|
|
if (lua_isnone(L, 2)) {
|
2015-10-13 09:57:44 +02:00
|
|
|
text = luaL_checkstring(L, 1);
|
|
|
|
} else {
|
|
|
|
std::string name = luaL_checkstring(L, 1);
|
2013-08-11 04:09:45 +02:00
|
|
|
text = luaL_checkstring(L, 2);
|
2015-10-13 09:57:44 +02:00
|
|
|
if (name == "deprecated") {
|
2020-02-12 19:17:04 +01:00
|
|
|
log_deprecated(L, text, 2);
|
2014-04-29 17:47:34 +02:00
|
|
|
return 0;
|
|
|
|
}
|
2015-10-13 09:57:44 +02:00
|
|
|
level = Logger::stringToLevel(name);
|
|
|
|
if (level == LL_MAX) {
|
|
|
|
warningstream << "Tried to log at unknown level '" << name
|
|
|
|
<< "'. Defaulting to \"none\"." << std::endl;
|
|
|
|
level = LL_NONE;
|
|
|
|
}
|
2013-08-11 04:09:45 +02:00
|
|
|
}
|
2015-10-13 09:57:44 +02:00
|
|
|
g_logger.log(level, text);
|
2013-08-11 04:09:45 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-10-26 08:45:55 +01:00
|
|
|
// get_us_time()
|
|
|
|
int ModApiUtil::l_get_us_time(lua_State *L)
|
|
|
|
{
|
|
|
|
NO_MAP_LOCK_REQUIRED;
|
|
|
|
lua_pushnumber(L, porting::getTimeUs());
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2013-09-02 02:01:49 +02:00
|
|
|
// parse_json(str[, nullvalue])
|
|
|
|
int ModApiUtil::l_parse_json(lua_State *L)
|
|
|
|
{
|
|
|
|
NO_MAP_LOCK_REQUIRED;
|
|
|
|
|
|
|
|
const char *jsonstr = luaL_checkstring(L, 1);
|
|
|
|
|
|
|
|
// Use passed nullvalue or default to nil
|
|
|
|
int nullindex = 2;
|
|
|
|
if (lua_isnone(L, nullindex)) {
|
|
|
|
lua_pushnil(L);
|
|
|
|
nullindex = lua_gettop(L);
|
|
|
|
}
|
|
|
|
|
|
|
|
Json::Value root;
|
|
|
|
|
|
|
|
{
|
|
|
|
std::istringstream stream(jsonstr);
|
|
|
|
|
2017-09-26 20:30:14 +02:00
|
|
|
Json::CharReaderBuilder builder;
|
|
|
|
builder.settings_["collectComments"] = false;
|
|
|
|
std::string errs;
|
|
|
|
|
|
|
|
if (!Json::parseFromStream(builder, stream, &root, &errs)) {
|
|
|
|
errorstream << "Failed to parse json data " << errs << std::endl;
|
2016-01-28 23:53:58 +01:00
|
|
|
size_t jlen = strlen(jsonstr);
|
|
|
|
if (jlen > 100) {
|
|
|
|
errorstream << "Data (" << jlen
|
|
|
|
<< " bytes) printed to warningstream." << std::endl;
|
|
|
|
warningstream << "data: \"" << jsonstr << "\"" << std::endl;
|
|
|
|
} else {
|
|
|
|
errorstream << "data: \"" << jsonstr << "\"" << std::endl;
|
|
|
|
}
|
2013-09-02 02:01:49 +02:00
|
|
|
lua_pushnil(L);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!push_json_value(L, root, nullindex)) {
|
|
|
|
errorstream << "Failed to parse json data, "
|
|
|
|
<< "depth exceeds lua stack limit" << std::endl;
|
|
|
|
errorstream << "data: \"" << jsonstr << "\"" << std::endl;
|
|
|
|
lua_pushnil(L);
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2013-12-19 00:17:26 +01:00
|
|
|
// write_json(data[, styled]) -> string or nil and error message
|
2013-12-18 22:46:53 +01:00
|
|
|
int ModApiUtil::l_write_json(lua_State *L)
|
|
|
|
{
|
|
|
|
NO_MAP_LOCK_REQUIRED;
|
|
|
|
|
|
|
|
bool styled = false;
|
|
|
|
if (!lua_isnone(L, 2)) {
|
2018-06-30 17:11:38 +02:00
|
|
|
styled = readParam<bool>(L, 2);
|
2013-12-18 22:46:53 +01:00
|
|
|
lua_pop(L, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
Json::Value root;
|
2013-12-19 00:17:26 +01:00
|
|
|
try {
|
2014-01-11 19:47:59 +01:00
|
|
|
read_json_value(L, root, 1);
|
2013-12-19 00:17:26 +01:00
|
|
|
} catch (SerializationError &e) {
|
|
|
|
lua_pushnil(L);
|
|
|
|
lua_pushstring(L, e.what());
|
|
|
|
return 2;
|
|
|
|
}
|
2013-12-18 22:46:53 +01:00
|
|
|
|
|
|
|
std::string out;
|
|
|
|
if (styled) {
|
2017-09-26 20:30:14 +02:00
|
|
|
out = root.toStyledString();
|
2013-12-18 22:46:53 +01:00
|
|
|
} else {
|
2017-09-26 20:30:14 +02:00
|
|
|
out = fastWriteJson(root);
|
2013-12-18 22:46:53 +01:00
|
|
|
}
|
|
|
|
lua_pushlstring(L, out.c_str(), out.size());
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2022-06-03 21:47:04 +02:00
|
|
|
// get_tool_wear_after_use(uses[, initial_wear])
|
|
|
|
int ModApiUtil::l_get_tool_wear_after_use(lua_State *L)
|
|
|
|
{
|
|
|
|
NO_MAP_LOCK_REQUIRED;
|
|
|
|
u32 uses = readParam<int>(L, 1);
|
|
|
|
u16 initial_wear = readParam<int>(L, 2, 0);
|
2022-11-09 17:58:53 +01:00
|
|
|
u32 add_wear = calculateResultWear(uses, initial_wear);
|
|
|
|
lua_pushnumber(L, add_wear);
|
2022-06-03 21:47:04 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2021-10-31 23:33:33 +01:00
|
|
|
// get_dig_params(groups, tool_capabilities[, wear])
|
2013-08-11 04:09:45 +02:00
|
|
|
int ModApiUtil::l_get_dig_params(lua_State *L)
|
|
|
|
{
|
|
|
|
NO_MAP_LOCK_REQUIRED;
|
2016-10-05 09:03:55 +02:00
|
|
|
ItemGroupList groups;
|
2013-08-11 04:09:45 +02:00
|
|
|
read_groups(L, 1, groups);
|
|
|
|
ToolCapabilities tp = read_tool_capabilities(L, 2);
|
2021-10-31 23:33:33 +01:00
|
|
|
if (lua_isnoneornil(L, 3)) {
|
|
|
|
push_dig_params(L, getDigParams(groups, &tp));
|
|
|
|
} else {
|
|
|
|
u16 wear = readParam<int>(L, 3);
|
|
|
|
push_dig_params(L, getDigParams(groups, &tp, wear));
|
|
|
|
}
|
2013-08-11 04:09:45 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2021-10-31 23:33:33 +01:00
|
|
|
// get_hit_params(groups, tool_capabilities[, time_from_last_punch, [, wear]])
|
2013-08-11 04:09:45 +02:00
|
|
|
int ModApiUtil::l_get_hit_params(lua_State *L)
|
|
|
|
{
|
|
|
|
NO_MAP_LOCK_REQUIRED;
|
2017-06-04 21:00:04 +02:00
|
|
|
std::unordered_map<std::string, int> groups;
|
2013-08-11 04:09:45 +02:00
|
|
|
read_groups(L, 1, groups);
|
|
|
|
ToolCapabilities tp = read_tool_capabilities(L, 2);
|
2021-10-31 23:33:33 +01:00
|
|
|
float time_from_last_punch = readParam<float>(L, 3, 1000000);
|
|
|
|
int wear = readParam<int>(L, 4, 0);
|
|
|
|
push_hit_params(L, getHitParams(groups, &tp,
|
|
|
|
time_from_last_punch, wear));
|
2013-08-11 04:09:45 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
Add minetest.check_password_entry callback
Gives a convenient way to check a player's password.
This entirely bypasses the SRP protocol, so should be used
with great care.
This function is not intended to be used
in-game, but solely by external protocols, where no
authentication of the minetest engine is provided, and
also only for protocols, in which the user already gives the
server the plaintext password.
Examples for good use are the classical http form, or irc,
an example for a bad use is a password change dialog inside
formspec.
Users should be aware that they lose the advantages of the SRP
protocol if they enter their passwords for servers outside the
normal entry box, like in in-game formspec menus,
or through irc /msg s,
This patch also fixes an auth.h mistake which has mixed up the
order of params inside the decode_srp_verifier_and_salt function.
Zeno-: Added errorstream message for invalid format when I committed
2016-05-30 15:27:48 +02:00
|
|
|
// check_password_entry(name, entry, password)
|
|
|
|
int ModApiUtil::l_check_password_entry(lua_State *L)
|
|
|
|
{
|
|
|
|
NO_MAP_LOCK_REQUIRED;
|
|
|
|
std::string name = luaL_checkstring(L, 1);
|
|
|
|
std::string entry = luaL_checkstring(L, 2);
|
|
|
|
std::string password = luaL_checkstring(L, 3);
|
|
|
|
|
|
|
|
if (base64_is_valid(entry)) {
|
|
|
|
std::string hash = translate_password(name, password);
|
|
|
|
lua_pushboolean(L, hash == entry);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string salt;
|
|
|
|
std::string verifier;
|
|
|
|
|
|
|
|
if (!decode_srp_verifier_and_salt(entry, &verifier, &salt)) {
|
|
|
|
// invalid format
|
|
|
|
warningstream << "Invalid password format for " << name << std::endl;
|
|
|
|
lua_pushboolean(L, false);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
std::string gen_verifier = generate_srp_verifier(name, password, salt);
|
|
|
|
|
|
|
|
lua_pushboolean(L, gen_verifier == verifier);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2013-08-11 04:09:45 +02:00
|
|
|
// get_password_hash(name, raw_password)
|
|
|
|
int ModApiUtil::l_get_password_hash(lua_State *L)
|
|
|
|
{
|
|
|
|
NO_MAP_LOCK_REQUIRED;
|
|
|
|
std::string name = luaL_checkstring(L, 1);
|
|
|
|
std::string raw_password = luaL_checkstring(L, 2);
|
2016-03-09 03:12:22 +01:00
|
|
|
std::string hash = translate_password(name, raw_password);
|
2013-08-11 04:09:45 +02:00
|
|
|
lua_pushstring(L, hash.c_str());
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2013-09-10 19:24:17 +02:00
|
|
|
// is_yes(arg)
|
2013-09-09 22:50:25 +02:00
|
|
|
int ModApiUtil::l_is_yes(lua_State *L)
|
|
|
|
{
|
|
|
|
NO_MAP_LOCK_REQUIRED;
|
2013-09-10 19:24:17 +02:00
|
|
|
|
|
|
|
lua_getglobal(L, "tostring"); // function to be called
|
|
|
|
lua_pushvalue(L, 1); // 1st argument
|
|
|
|
lua_call(L, 1, 1); // execute function
|
2018-06-30 17:11:38 +02:00
|
|
|
std::string str = readParam<std::string>(L, -1); // get result
|
2013-09-10 19:24:17 +02:00
|
|
|
lua_pop(L, 1);
|
|
|
|
|
2013-09-09 22:50:25 +02:00
|
|
|
bool yes = is_yes(str);
|
|
|
|
lua_pushboolean(L, yes);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2014-05-07 04:31:35 +02:00
|
|
|
// get_builtin_path()
|
2014-04-27 23:55:49 +02:00
|
|
|
int ModApiUtil::l_get_builtin_path(lua_State *L)
|
|
|
|
{
|
2015-10-25 05:45:18 +01:00
|
|
|
NO_MAP_LOCK_REQUIRED;
|
|
|
|
|
2017-06-30 20:14:39 +02:00
|
|
|
std::string path = porting::path_share + DIR_DELIM + "builtin" + DIR_DELIM;
|
2014-04-27 23:55:49 +02:00
|
|
|
lua_pushstring(L, path.c_str());
|
2014-05-07 04:31:35 +02:00
|
|
|
|
2014-04-27 23:55:49 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2021-01-22 16:08:57 +01:00
|
|
|
// get_user_path()
|
|
|
|
int ModApiUtil::l_get_user_path(lua_State *L)
|
|
|
|
{
|
|
|
|
NO_MAP_LOCK_REQUIRED;
|
|
|
|
|
|
|
|
std::string path = porting::path_user;
|
|
|
|
lua_pushstring(L, path.c_str());
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2022-09-28 15:06:14 +02:00
|
|
|
enum LuaCompressMethod
|
|
|
|
{
|
|
|
|
LUA_COMPRESS_METHOD_DEFLATE,
|
|
|
|
LUA_COMPRESS_METHOD_ZSTD,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct EnumString es_LuaCompressMethod[] =
|
|
|
|
{
|
|
|
|
{LUA_COMPRESS_METHOD_DEFLATE, "deflate"},
|
|
|
|
{LUA_COMPRESS_METHOD_ZSTD, "zstd"},
|
|
|
|
{0, nullptr},
|
|
|
|
};
|
|
|
|
|
|
|
|
static LuaCompressMethod get_compress_method(lua_State *L, int index)
|
|
|
|
{
|
|
|
|
if (lua_isnoneornil(L, index))
|
|
|
|
return LUA_COMPRESS_METHOD_DEFLATE;
|
|
|
|
const char *name = luaL_checkstring(L, index);
|
|
|
|
int value;
|
|
|
|
if (!string_to_enum(es_LuaCompressMethod, value, name)) {
|
|
|
|
// Pretend it's deflate if we don't know, for compatibility reasons.
|
|
|
|
log_deprecated(L, "Unknown compression method \"" + std::string(name)
|
|
|
|
+ "\", defaulting to \"deflate\". You should pass a valid value.");
|
|
|
|
return LUA_COMPRESS_METHOD_DEFLATE;
|
|
|
|
}
|
|
|
|
return (LuaCompressMethod) value;
|
|
|
|
}
|
|
|
|
|
2014-09-14 23:42:08 +02:00
|
|
|
// compress(data, method, level)
|
|
|
|
int ModApiUtil::l_compress(lua_State *L)
|
|
|
|
{
|
2015-10-25 05:45:18 +01:00
|
|
|
NO_MAP_LOCK_REQUIRED;
|
|
|
|
|
2014-09-14 23:42:08 +02:00
|
|
|
size_t size;
|
|
|
|
const char *data = luaL_checklstring(L, 1, &size);
|
|
|
|
|
2022-09-28 15:06:14 +02:00
|
|
|
LuaCompressMethod method = get_compress_method(L, 2);
|
2014-09-14 23:42:08 +02:00
|
|
|
|
2021-09-11 21:06:57 +02:00
|
|
|
std::ostringstream os(std::ios_base::binary);
|
2022-09-28 15:06:14 +02:00
|
|
|
|
|
|
|
if (method == LUA_COMPRESS_METHOD_DEFLATE) {
|
|
|
|
int level = -1;
|
|
|
|
if (!lua_isnoneornil(L, 3))
|
|
|
|
level = readParam<int>(L, 3);
|
|
|
|
|
|
|
|
compressZlib(reinterpret_cast<const u8 *>(data), size, os, level);
|
|
|
|
} else if (method == LUA_COMPRESS_METHOD_ZSTD) {
|
|
|
|
int level = ZSTD_CLEVEL_DEFAULT;
|
|
|
|
if (!lua_isnoneornil(L, 3))
|
|
|
|
level = readParam<int>(L, 3);
|
|
|
|
|
|
|
|
compressZstd(reinterpret_cast<const u8 *>(data), size, os, level);
|
|
|
|
}
|
2014-09-14 23:42:08 +02:00
|
|
|
|
|
|
|
std::string out = os.str();
|
|
|
|
|
|
|
|
lua_pushlstring(L, out.data(), out.size());
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// decompress(data, method)
|
|
|
|
int ModApiUtil::l_decompress(lua_State *L)
|
|
|
|
{
|
2015-10-25 05:45:18 +01:00
|
|
|
NO_MAP_LOCK_REQUIRED;
|
|
|
|
|
2014-09-14 23:42:08 +02:00
|
|
|
size_t size;
|
2014-09-10 03:52:07 +02:00
|
|
|
const char *data = luaL_checklstring(L, 1, &size);
|
2014-09-14 23:42:08 +02:00
|
|
|
|
2022-09-28 15:06:14 +02:00
|
|
|
LuaCompressMethod method = get_compress_method(L, 2);
|
|
|
|
|
2021-09-11 21:06:57 +02:00
|
|
|
std::istringstream is(std::string(data, size), std::ios_base::binary);
|
|
|
|
std::ostringstream os(std::ios_base::binary);
|
2022-09-28 15:06:14 +02:00
|
|
|
|
|
|
|
if (method == LUA_COMPRESS_METHOD_DEFLATE) {
|
|
|
|
decompressZlib(is, os);
|
|
|
|
} else if (method == LUA_COMPRESS_METHOD_ZSTD) {
|
|
|
|
decompressZstd(is, os);
|
|
|
|
}
|
2014-09-14 23:42:08 +02:00
|
|
|
|
|
|
|
std::string out = os.str();
|
|
|
|
|
|
|
|
lua_pushlstring(L, out.data(), out.size());
|
|
|
|
return 1;
|
|
|
|
}
|
2014-04-27 23:55:49 +02:00
|
|
|
|
2016-05-28 05:37:28 +02:00
|
|
|
// encode_base64(string)
|
|
|
|
int ModApiUtil::l_encode_base64(lua_State *L)
|
|
|
|
{
|
|
|
|
NO_MAP_LOCK_REQUIRED;
|
|
|
|
|
|
|
|
size_t size;
|
|
|
|
const char *data = luaL_checklstring(L, 1, &size);
|
|
|
|
|
|
|
|
std::string out = base64_encode((const unsigned char *)(data), size);
|
|
|
|
|
|
|
|
lua_pushlstring(L, out.data(), out.size());
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// decode_base64(string)
|
|
|
|
int ModApiUtil::l_decode_base64(lua_State *L)
|
|
|
|
{
|
|
|
|
NO_MAP_LOCK_REQUIRED;
|
|
|
|
|
|
|
|
size_t size;
|
2020-05-20 21:54:52 +02:00
|
|
|
const char *d = luaL_checklstring(L, 1, &size);
|
|
|
|
const std::string data = std::string(d, size);
|
|
|
|
|
|
|
|
if (!base64_is_valid(data))
|
|
|
|
return 0;
|
2016-05-28 05:37:28 +02:00
|
|
|
|
2020-05-20 21:54:52 +02:00
|
|
|
std::string out = base64_decode(data);
|
2016-05-28 05:37:28 +02:00
|
|
|
|
|
|
|
lua_pushlstring(L, out.data(), out.size());
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2014-09-09 21:17:01 +02:00
|
|
|
// mkdir(path)
|
|
|
|
int ModApiUtil::l_mkdir(lua_State *L)
|
|
|
|
{
|
|
|
|
NO_MAP_LOCK_REQUIRED;
|
|
|
|
const char *path = luaL_checkstring(L, 1);
|
2016-12-05 20:59:15 +01:00
|
|
|
CHECK_SECURE_PATH(L, path, true);
|
2014-09-09 21:17:01 +02:00
|
|
|
lua_pushboolean(L, fs::CreateAllDirs(path));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2021-11-10 19:10:20 +01:00
|
|
|
// rmdir(path, recursive)
|
|
|
|
int ModApiUtil::l_rmdir(lua_State *L)
|
|
|
|
{
|
|
|
|
NO_MAP_LOCK_REQUIRED;
|
|
|
|
const char *path = luaL_checkstring(L, 1);
|
|
|
|
CHECK_SECURE_PATH(L, path, true);
|
|
|
|
|
|
|
|
bool recursive = readParam<bool>(L, 2, false);
|
|
|
|
|
|
|
|
if (recursive)
|
|
|
|
lua_pushboolean(L, fs::RecursiveDelete(path));
|
|
|
|
else
|
|
|
|
lua_pushboolean(L, fs::DeleteSingleFileOrEmptyDirectory(path));
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// cpdir(source, destination)
|
|
|
|
int ModApiUtil::l_cpdir(lua_State *L)
|
|
|
|
{
|
|
|
|
NO_MAP_LOCK_REQUIRED;
|
|
|
|
const char *source = luaL_checkstring(L, 1);
|
|
|
|
const char *destination = luaL_checkstring(L, 2);
|
|
|
|
CHECK_SECURE_PATH(L, source, false);
|
|
|
|
CHECK_SECURE_PATH(L, destination, true);
|
|
|
|
|
|
|
|
lua_pushboolean(L, fs::CopyDir(source, destination));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// mpdir(source, destination)
|
|
|
|
int ModApiUtil::l_mvdir(lua_State *L)
|
|
|
|
{
|
|
|
|
NO_MAP_LOCK_REQUIRED;
|
|
|
|
const char *source = luaL_checkstring(L, 1);
|
|
|
|
const char *destination = luaL_checkstring(L, 2);
|
|
|
|
CHECK_SECURE_PATH(L, source, true);
|
|
|
|
CHECK_SECURE_PATH(L, destination, true);
|
|
|
|
|
|
|
|
lua_pushboolean(L, fs::MoveDir(source, destination));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-05-04 20:59:13 +02:00
|
|
|
// get_dir_list(path, is_dir)
|
|
|
|
int ModApiUtil::l_get_dir_list(lua_State *L)
|
|
|
|
{
|
|
|
|
NO_MAP_LOCK_REQUIRED;
|
|
|
|
const char *path = luaL_checkstring(L, 1);
|
2016-12-28 21:22:01 +01:00
|
|
|
bool list_all = !lua_isboolean(L, 2); // if its not a boolean list all
|
2018-06-30 17:11:38 +02:00
|
|
|
bool list_dirs = readParam<bool>(L, 2); // true: list dirs, false: list files
|
2015-05-04 20:59:13 +02:00
|
|
|
|
2016-12-05 20:59:15 +01:00
|
|
|
CHECK_SECURE_PATH(L, path, false);
|
2015-05-04 20:59:13 +02:00
|
|
|
|
|
|
|
std::vector<fs::DirListNode> list = fs::GetDirListing(path);
|
|
|
|
|
|
|
|
int index = 0;
|
|
|
|
lua_newtable(L);
|
|
|
|
|
2017-08-19 22:23:47 +02:00
|
|
|
for (const fs::DirListNode &dln : list) {
|
|
|
|
if (list_all || list_dirs == dln.dir) {
|
|
|
|
lua_pushstring(L, dln.name.c_str());
|
2015-05-04 20:59:13 +02:00
|
|
|
lua_rawseti(L, -2, ++index);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
2014-09-09 21:17:01 +02:00
|
|
|
|
2017-11-07 11:46:06 +01:00
|
|
|
// safe_file_write(path, content)
|
|
|
|
int ModApiUtil::l_safe_file_write(lua_State *L)
|
|
|
|
{
|
|
|
|
NO_MAP_LOCK_REQUIRED;
|
|
|
|
const char *path = luaL_checkstring(L, 1);
|
|
|
|
size_t size;
|
|
|
|
const char *content = luaL_checklstring(L, 2, &size);
|
|
|
|
|
|
|
|
CHECK_SECURE_PATH(L, path, true);
|
|
|
|
|
|
|
|
bool ret = fs::safeWriteToFile(path, std::string(content, size));
|
|
|
|
lua_pushboolean(L, ret);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// request_insecure_environment()
|
2014-09-10 03:52:07 +02:00
|
|
|
int ModApiUtil::l_request_insecure_environment(lua_State *L)
|
|
|
|
{
|
|
|
|
NO_MAP_LOCK_REQUIRED;
|
2016-02-18 22:06:07 +01:00
|
|
|
|
|
|
|
// Just return _G if security is disabled
|
2014-09-10 03:52:07 +02:00
|
|
|
if (!ScriptApiSecurity::isSecure(L)) {
|
|
|
|
lua_getglobal(L, "_G");
|
|
|
|
return 1;
|
|
|
|
}
|
2016-02-18 22:06:07 +01:00
|
|
|
|
2021-12-17 19:04:46 +01:00
|
|
|
if (!ScriptApiSecurity::checkWhitelisted(L, "secure.trusted_mods")) {
|
2016-02-18 22:06:07 +01:00
|
|
|
return 0;
|
2014-09-10 03:52:07 +02:00
|
|
|
}
|
2016-02-18 22:06:07 +01:00
|
|
|
|
|
|
|
// Push insecure environment
|
2015-08-25 07:00:56 +02:00
|
|
|
lua_rawgeti(L, LUA_REGISTRYINDEX, CUSTOM_RIDX_GLOBALS_BACKUP);
|
2014-09-10 03:52:07 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2014-05-07 04:31:35 +02:00
|
|
|
// get_version()
|
|
|
|
int ModApiUtil::l_get_version(lua_State *L)
|
|
|
|
{
|
|
|
|
lua_createtable(L, 0, 3);
|
|
|
|
int table = lua_gettop(L);
|
|
|
|
|
|
|
|
lua_pushstring(L, PROJECT_NAME_C);
|
|
|
|
lua_setfield(L, table, "project");
|
|
|
|
|
|
|
|
lua_pushstring(L, g_version_string);
|
|
|
|
lua_setfield(L, table, "string");
|
|
|
|
|
2017-08-19 22:23:47 +02:00
|
|
|
if (strcmp(g_version_string, g_version_hash) != 0) {
|
2014-05-07 04:31:35 +02:00
|
|
|
lua_pushstring(L, g_version_hash);
|
|
|
|
lua_setfield(L, table, "hash");
|
|
|
|
}
|
|
|
|
|
2022-08-02 21:34:17 +02:00
|
|
|
lua_pushboolean(L, DEVELOPMENT_BUILD);
|
|
|
|
lua_setfield(L, table, "is_dev");
|
2014-05-07 04:31:35 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2017-10-30 08:18:18 +01:00
|
|
|
int ModApiUtil::l_sha1(lua_State *L)
|
|
|
|
{
|
|
|
|
NO_MAP_LOCK_REQUIRED;
|
|
|
|
size_t size;
|
|
|
|
const char *data = luaL_checklstring(L, 1, &size);
|
2018-06-30 17:11:38 +02:00
|
|
|
bool hex = !lua_isboolean(L, 2) || !readParam<bool>(L, 2);
|
2017-10-30 08:18:18 +01:00
|
|
|
|
|
|
|
// Compute actual checksum of data
|
|
|
|
std::string data_sha1;
|
|
|
|
{
|
|
|
|
SHA1 ctx;
|
|
|
|
ctx.addBytes(data, size);
|
|
|
|
unsigned char *data_tmpdigest = ctx.getDigest();
|
|
|
|
data_sha1.assign((char*) data_tmpdigest, 20);
|
|
|
|
free(data_tmpdigest);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (hex) {
|
|
|
|
std::string sha1_hex = hex_encode(data_sha1);
|
|
|
|
lua_pushstring(L, sha1_hex.c_str());
|
|
|
|
} else {
|
|
|
|
lua_pushlstring(L, data_sha1.data(), data_sha1.size());
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
2014-09-10 03:52:07 +02:00
|
|
|
|
2021-04-23 21:37:24 +02:00
|
|
|
// colorspec_to_colorstring(colorspec)
|
|
|
|
int ModApiUtil::l_colorspec_to_colorstring(lua_State *L)
|
|
|
|
{
|
|
|
|
NO_MAP_LOCK_REQUIRED;
|
|
|
|
|
|
|
|
video::SColor color(0);
|
|
|
|
if (read_color(L, 1, &color)) {
|
|
|
|
char colorstring[10];
|
|
|
|
snprintf(colorstring, 10, "#%02X%02X%02X%02X",
|
|
|
|
color.getRed(), color.getGreen(), color.getBlue(), color.getAlpha());
|
|
|
|
lua_pushstring(L, colorstring);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2021-07-29 05:10:10 +02:00
|
|
|
// colorspec_to_bytes(colorspec)
|
|
|
|
int ModApiUtil::l_colorspec_to_bytes(lua_State *L)
|
|
|
|
{
|
|
|
|
NO_MAP_LOCK_REQUIRED;
|
|
|
|
|
|
|
|
video::SColor color(0);
|
|
|
|
if (read_color(L, 1, &color)) {
|
|
|
|
u8 colorbytes[4] = {
|
|
|
|
(u8) color.getRed(),
|
|
|
|
(u8) color.getGreen(),
|
|
|
|
(u8) color.getBlue(),
|
|
|
|
(u8) color.getAlpha(),
|
|
|
|
};
|
|
|
|
lua_pushlstring(L, (const char*) colorbytes, 4);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// encode_png(w, h, data, level)
|
|
|
|
int ModApiUtil::l_encode_png(lua_State *L)
|
|
|
|
{
|
|
|
|
NO_MAP_LOCK_REQUIRED;
|
|
|
|
|
|
|
|
// The args are already pre-validated on the lua side.
|
|
|
|
u32 width = readParam<int>(L, 1);
|
|
|
|
u32 height = readParam<int>(L, 2);
|
|
|
|
const char *data = luaL_checklstring(L, 3, NULL);
|
|
|
|
s32 compression = readParam<int>(L, 4);
|
|
|
|
|
|
|
|
std::string out = encodePNG((const u8*)data, width, height, compression);
|
|
|
|
|
|
|
|
lua_pushlstring(L, out.data(), out.size());
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2021-08-28 12:15:12 +02:00
|
|
|
// get_last_run_mod()
|
|
|
|
int ModApiUtil::l_get_last_run_mod(lua_State *L)
|
|
|
|
{
|
|
|
|
NO_MAP_LOCK_REQUIRED;
|
|
|
|
|
|
|
|
lua_rawgeti(L, LUA_REGISTRYINDEX, CUSTOM_RIDX_CURRENT_MOD_NAME);
|
|
|
|
std::string current_mod = readParam<std::string>(L, -1, "");
|
|
|
|
if (current_mod.empty()) {
|
|
|
|
lua_pop(L, 1);
|
|
|
|
lua_pushstring(L, getScriptApiBase(L)->getOrigin().c_str());
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// set_last_run_mod(modname)
|
|
|
|
int ModApiUtil::l_set_last_run_mod(lua_State *L)
|
|
|
|
{
|
|
|
|
NO_MAP_LOCK_REQUIRED;
|
|
|
|
|
|
|
|
const char *mod = luaL_checkstring(L, 1);
|
|
|
|
getScriptApiBase(L)->setOriginDirect(mod);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-08-11 04:09:45 +02:00
|
|
|
void ModApiUtil::Initialize(lua_State *L, int top)
|
|
|
|
{
|
|
|
|
API_FCT(log);
|
|
|
|
|
2015-10-26 08:45:55 +01:00
|
|
|
API_FCT(get_us_time);
|
|
|
|
|
2013-09-02 02:01:49 +02:00
|
|
|
API_FCT(parse_json);
|
2013-12-18 22:46:53 +01:00
|
|
|
API_FCT(write_json);
|
2013-09-02 02:01:49 +02:00
|
|
|
|
2022-06-03 21:47:04 +02:00
|
|
|
API_FCT(get_tool_wear_after_use);
|
2013-08-11 04:09:45 +02:00
|
|
|
API_FCT(get_dig_params);
|
|
|
|
API_FCT(get_hit_params);
|
|
|
|
|
Add minetest.check_password_entry callback
Gives a convenient way to check a player's password.
This entirely bypasses the SRP protocol, so should be used
with great care.
This function is not intended to be used
in-game, but solely by external protocols, where no
authentication of the minetest engine is provided, and
also only for protocols, in which the user already gives the
server the plaintext password.
Examples for good use are the classical http form, or irc,
an example for a bad use is a password change dialog inside
formspec.
Users should be aware that they lose the advantages of the SRP
protocol if they enter their passwords for servers outside the
normal entry box, like in in-game formspec menus,
or through irc /msg s,
This patch also fixes an auth.h mistake which has mixed up the
order of params inside the decode_srp_verifier_and_salt function.
Zeno-: Added errorstream message for invalid format when I committed
2016-05-30 15:27:48 +02:00
|
|
|
API_FCT(check_password_entry);
|
2013-08-11 04:09:45 +02:00
|
|
|
API_FCT(get_password_hash);
|
2013-09-09 22:50:25 +02:00
|
|
|
|
|
|
|
API_FCT(is_yes);
|
2014-04-27 23:55:49 +02:00
|
|
|
|
|
|
|
API_FCT(get_builtin_path);
|
2021-01-22 16:08:57 +01:00
|
|
|
API_FCT(get_user_path);
|
2014-09-14 23:42:08 +02:00
|
|
|
|
|
|
|
API_FCT(compress);
|
|
|
|
API_FCT(decompress);
|
2014-09-09 21:17:01 +02:00
|
|
|
|
|
|
|
API_FCT(mkdir);
|
2021-11-10 19:10:20 +01:00
|
|
|
API_FCT(rmdir);
|
|
|
|
API_FCT(cpdir);
|
|
|
|
API_FCT(mvdir);
|
2015-05-04 20:59:13 +02:00
|
|
|
API_FCT(get_dir_list);
|
2017-11-07 11:46:06 +01:00
|
|
|
API_FCT(safe_file_write);
|
2014-09-10 03:52:07 +02:00
|
|
|
|
|
|
|
API_FCT(request_insecure_environment);
|
2016-05-28 05:37:28 +02:00
|
|
|
|
|
|
|
API_FCT(encode_base64);
|
|
|
|
API_FCT(decode_base64);
|
2014-05-07 04:31:35 +02:00
|
|
|
|
|
|
|
API_FCT(get_version);
|
2017-10-30 08:18:18 +01:00
|
|
|
API_FCT(sha1);
|
2021-04-23 21:37:24 +02:00
|
|
|
API_FCT(colorspec_to_colorstring);
|
2021-07-29 05:10:10 +02:00
|
|
|
API_FCT(colorspec_to_bytes);
|
|
|
|
|
|
|
|
API_FCT(encode_png);
|
2014-12-12 20:49:19 +01:00
|
|
|
|
2021-08-28 12:15:12 +02:00
|
|
|
API_FCT(get_last_run_mod);
|
|
|
|
API_FCT(set_last_run_mod);
|
|
|
|
|
2014-12-12 20:49:19 +01:00
|
|
|
LuaSettings::create(L, g_settings, g_settings_path);
|
|
|
|
lua_setfield(L, top, "settings");
|
2013-08-11 04:09:45 +02:00
|
|
|
}
|
|
|
|
|
2017-01-21 22:44:37 +01:00
|
|
|
void ModApiUtil::InitializeClient(lua_State *L, int top)
|
|
|
|
{
|
|
|
|
API_FCT(log);
|
|
|
|
|
2017-01-22 11:17:41 +01:00
|
|
|
API_FCT(get_us_time);
|
|
|
|
|
2017-01-21 22:44:37 +01:00
|
|
|
API_FCT(parse_json);
|
|
|
|
API_FCT(write_json);
|
|
|
|
|
|
|
|
API_FCT(is_yes);
|
|
|
|
|
|
|
|
API_FCT(compress);
|
|
|
|
API_FCT(decompress);
|
|
|
|
|
|
|
|
API_FCT(encode_base64);
|
|
|
|
API_FCT(decode_base64);
|
|
|
|
|
|
|
|
API_FCT(get_version);
|
2017-10-30 08:18:18 +01:00
|
|
|
API_FCT(sha1);
|
2021-04-23 21:37:24 +02:00
|
|
|
API_FCT(colorspec_to_colorstring);
|
2021-07-29 05:10:10 +02:00
|
|
|
API_FCT(colorspec_to_bytes);
|
2022-08-02 11:58:08 +02:00
|
|
|
|
|
|
|
LuaSettings::create(L, g_settings, g_settings_path);
|
|
|
|
lua_setfield(L, top, "settings");
|
2017-01-21 22:44:37 +01:00
|
|
|
}
|
|
|
|
|
2014-12-12 20:49:19 +01:00
|
|
|
void ModApiUtil::InitializeAsync(lua_State *L, int top)
|
2013-11-26 18:15:31 +01:00
|
|
|
{
|
2014-12-12 20:49:19 +01:00
|
|
|
API_FCT(log);
|
2013-11-26 18:15:31 +01:00
|
|
|
|
2014-12-12 20:49:19 +01:00
|
|
|
API_FCT(get_us_time);
|
2015-10-26 08:45:55 +01:00
|
|
|
|
2014-12-12 20:49:19 +01:00
|
|
|
API_FCT(parse_json);
|
|
|
|
API_FCT(write_json);
|
2013-11-26 18:15:31 +01:00
|
|
|
|
2014-12-12 20:49:19 +01:00
|
|
|
API_FCT(is_yes);
|
2013-11-26 18:15:31 +01:00
|
|
|
|
2014-12-12 20:49:19 +01:00
|
|
|
API_FCT(get_builtin_path);
|
2021-01-22 16:08:57 +01:00
|
|
|
API_FCT(get_user_path);
|
2014-04-27 23:55:49 +02:00
|
|
|
|
2014-12-12 20:49:19 +01:00
|
|
|
API_FCT(compress);
|
|
|
|
API_FCT(decompress);
|
2014-09-14 23:42:08 +02:00
|
|
|
|
2014-12-12 20:49:19 +01:00
|
|
|
API_FCT(mkdir);
|
2021-11-10 19:10:20 +01:00
|
|
|
API_FCT(rmdir);
|
|
|
|
API_FCT(cpdir);
|
|
|
|
API_FCT(mvdir);
|
2014-12-12 20:49:19 +01:00
|
|
|
API_FCT(get_dir_list);
|
2022-05-02 20:55:04 +02:00
|
|
|
API_FCT(safe_file_write);
|
|
|
|
|
|
|
|
API_FCT(request_insecure_environment);
|
2014-09-09 21:17:01 +02:00
|
|
|
|
2014-12-12 20:49:19 +01:00
|
|
|
API_FCT(encode_base64);
|
|
|
|
API_FCT(decode_base64);
|
2016-05-28 05:37:28 +02:00
|
|
|
|
2014-12-12 20:49:19 +01:00
|
|
|
API_FCT(get_version);
|
2017-10-30 08:18:18 +01:00
|
|
|
API_FCT(sha1);
|
2021-04-23 21:37:24 +02:00
|
|
|
API_FCT(colorspec_to_colorstring);
|
2021-07-29 05:10:10 +02:00
|
|
|
API_FCT(colorspec_to_bytes);
|
2014-05-07 04:31:35 +02:00
|
|
|
|
2022-05-02 20:55:04 +02:00
|
|
|
API_FCT(encode_png);
|
|
|
|
|
2021-08-28 12:15:12 +02:00
|
|
|
API_FCT(get_last_run_mod);
|
|
|
|
API_FCT(set_last_run_mod);
|
|
|
|
|
2014-12-12 20:49:19 +01:00
|
|
|
LuaSettings::create(L, g_settings, g_settings_path);
|
|
|
|
lua_setfield(L, top, "settings");
|
2013-11-26 18:15:31 +01:00
|
|
|
}
|