aboutsummaryrefslogtreecommitdiff
path: root/src/script/lua_api/l_auth.cpp
blob: 0fc57ba3a71d0d2e00c5bb2292127fc8dd33b1c7 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
/*
Minetest
Copyright (C) 2018 bendeutsch, Ben Deutsch <ben@bendeutsch.de>

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.
*/

#include "lua_api/l_auth.h"
#include "lua_api/l_internal.h"
#include "common/c_converter.h"
#include "common/c_content.h"
#include "cpp_api/s_base.h"
#include "server.h"
#include "environment.h"
#include "database/database.h"
#include <algorithm>

// common start: ensure auth db
AuthDatabase *ModApiAuth::getAuthDb(lua_State *L)
{
	ServerEnvironment *server_environment =
			dynamic_cast<ServerEnvironment *>(getEnv(L));
	if (!server_environment)
		return nullptr;
	return server_environment->getAuthDatabase();
}

void ModApiAuth::pushAuthEntry(lua_State *L, const AuthEntry &authEntry)
{
	lua_newtable(L);
	int table = lua_gettop(L);
	// id
	lua_pushnumber(L, authEntry.id);
	lua_setfield(L, table, "id");
	// name
	lua_pushstring(L, authEntry.name.c_str());
	lua_setfield(L, table, "name");
	// password
	lua_pushstring(L, authEntry.password.c_str());
	lua_setfield(L, table, "password");
	// privileges
	lua_newtable(L);
	int privtable = lua_gettop(L);
	for (const std::string &privs : authEntry.privileges) {
		lua_pushboolean(L, true);
		lua_setfield(L, privtable, privs.c_str());
	}
	lua_setfield(L, table, "privileges");
	// last_login
	lua_pushnumber(L, authEntry.last_login);
	lua_setfield(L, table, "last_login");

	lua_pushvalue(L, table);
}

// auth_read(name)
int ModApiAuth::l_auth_read(lua_State *L)
{
	NO_MAP_LOCK_REQUIRED;
	AuthDatabase *auth_db = getAuthDb(L);
	if (!auth_db)
		return 0;
	AuthEntry authEntry;
	const char *name = luaL_checkstring(L, 1);
	bool success = auth_db->getAuth(std::string(name), authEntry);
	if (!success)
		return 0;

	pushAuthEntry(L, authEntry);
	return 1;
}

// auth_save(table)
int ModApiAuth::l_auth_save(lua_State *L)
{
	NO_MAP_LOCK_REQUIRED;
	AuthDatabase *auth_db = getAuthDb(L);
	if (!auth_db)
		return 0;
	luaL_checktype(L, 1, LUA_TTABLE);
	int table = 1;
	AuthEntry authEntry;
	bool success;
	success = getintfield(L, table, "id", authEntry.id);
	success = success && getstringfield(L, table, "name", authEntry.name);
	success = success && getstringfield(L, table, "password", authEntry.password);
	lua_getfield(L, table, "privileges");
	if (lua_istable(L, -1)) {
		lua_pushnil(L);
		while (lua_next(L, -2)) {
			authEntry.privileges.emplace_back(
					lua_tostring(L, -2)); // the key, not the value
			lua_pop(L, 1);
		}
	} else {
		success = false;
	}
	lua_pop(L, 1); // the table
	success = success && getintfield(L, table, "last_login", authEntry.last_login);

	if (!success) {
		lua_pushboolean(L, false);
		return 1;
	}

	lua_pushboolean(L, auth_db->saveAuth(authEntry));
	return 1;
}

// auth_create(table)
int ModApiAuth::l_auth_create(lua_State *L)
{
	NO_MAP_LOCK_REQUIRED;
	AuthDatabase *auth_db = getAuthDb(L);
	if (!auth_db)
		return 0;
	luaL_checktype(L, 1, LUA_TTABLE);
	int table = 1;
	AuthEntry authEntry;
	bool success;
	// no meaningful id field, we assume
	success = getstringfield(L, table, "name", authEntry.name);
	success = success && getstringfield(L, table, "password", authEntry.password);
	lua_getfield(L, table, "privileges");
	if (lua_istable(L, -1)) {
		lua_pushnil(L);
		while (lua_next(L, -2)) {
			authEntry.privileges.emplace_back(
					lua_tostring(L, -2)); // the key, not the value
			lua_pop(L, 1);
		}
	} else {
		success = false;
	}
	lua_pop(L, 1); // the table
	success = success && getintfield(L, table, "last_login", authEntry.last_login);

	if (!success)
		return 0;

	if (auth_db->createAuth(authEntry)) {
		pushAuthEntry(L, authEntry);
		return 1;
	}

	return 0;
}

// auth_delete(name)
int ModApiAuth::l_auth_delete(lua_State *L)
{
	NO_MAP_LOCK_REQUIRED;
	AuthDatabase *auth_db = getAuthDb(L);
	if (!auth_db)
		return 0;
	std::string name(luaL_checkstring(L, 1));
	lua_pushboolean(L, auth_db->deleteAuth(name));
	return 1;
}

// auth_list_names()
int ModApiAuth::l_auth_list_names(lua_State *L)
{
	NO_MAP_LOCK_REQUIRED;
	AuthDatabase *auth_db = getAuthDb(L);
	if (!auth_db)
		return 0;
	std::vector<std::string> names;
	auth_db->listNames(names);
	lua_createtable(L, names.size(), 0);
	int table = lua_gettop(L);
	int i = 1;
	for (const std::string &name : names) {
		lua_pushstring(L, name.c_str());
		lua_rawseti(L, table, i++);
	}
	return 1;
}

// auth_reload()
int ModApiAuth::l_auth_reload(lua_State *L)
{
	NO_MAP_LOCK_REQUIRED;
	AuthDatabase *auth_db = getAuthDb(L);
	if (auth_db)
		auth_db->reload();
	return 0;
}

void ModApiAuth::Initialize(lua_State *L, int top)
{

	lua_newtable(L);
	int auth_top = lua_gettop(L);

	registerFunction(L, "read", l_auth_read, auth_top);
	registerFunction(L, "save", l_auth_save, auth_top);
	registerFunction(L, "create", l_auth_create, auth_top);
	registerFunction(L, "delete", l_auth_delete, auth_top);
	registerFunction(L, "list_names", l_auth_list_names, auth_top);
	registerFunction(L, "reload", l_auth_reload, auth_top);

	lua_setfield(L, top, "auth");
}
3f> disconnected; std::vector<aabb3f> disconnected_sides; NodeBox() { reset(); } void reset(); void serialize(std::ostream &os, u16 protocol_version) const; void deSerialize(std::istream &is); }; struct MapNode; class NodeMetadata; enum LeavesStyle { LEAVES_FANCY, LEAVES_SIMPLE, LEAVES_OPAQUE, }; enum AutoScale : u8 { AUTOSCALE_DISABLE, AUTOSCALE_ENABLE, AUTOSCALE_FORCE, }; enum WorldAlignMode : u8 { WORLDALIGN_DISABLE, WORLDALIGN_ENABLE, WORLDALIGN_FORCE, WORLDALIGN_FORCE_NODEBOX, }; class TextureSettings { public: LeavesStyle leaves_style; WorldAlignMode world_aligned_mode; AutoScale autoscale_mode; int node_texture_size; bool opaque_water; bool connected_glass; bool use_normal_texture; bool enable_mesh_cache; bool enable_minimap; TextureSettings() = default; void readSettings(); }; enum NodeDrawType { // A basic solid block NDT_NORMAL, // Nothing is drawn NDT_AIRLIKE, // Do not draw face towards same kind of flowing/source liquid NDT_LIQUID, // A very special kind of thing NDT_FLOWINGLIQUID, // Glass-like, don't draw faces towards other glass NDT_GLASSLIKE, // Leaves-like, draw all faces no matter what NDT_ALLFACES, // Enabled -> ndt_allfaces, disabled -> ndt_normal NDT_ALLFACES_OPTIONAL, // Single plane perpendicular to a surface NDT_TORCHLIKE, // Single plane parallel to a surface NDT_SIGNLIKE, // 2 vertical planes in a 'X' shape diagonal to XZ axes. // paramtype2 = "meshoptions" allows various forms, sizes and // vertical and horizontal random offsets. NDT_PLANTLIKE, // Fenceposts that connect to neighbouring fenceposts with horizontal bars NDT_FENCELIKE, // Selects appropriate junction texture to connect like rails to // neighbouring raillikes. NDT_RAILLIKE, // Custom Lua-definable structure of multiple cuboids NDT_NODEBOX, // Glass-like, draw connected frames and all visible faces. // param2 > 0 defines 64 levels of internal liquid // Uses 3 textures, one for frames, second for faces, // optional third is a 'special tile' for the liquid. NDT_GLASSLIKE_FRAMED, // Draw faces slightly rotated and only on neighbouring nodes NDT_FIRELIKE, // Enabled -> ndt_glasslike_framed, disabled -> ndt_glasslike NDT_GLASSLIKE_FRAMED_OPTIONAL, // Uses static meshes NDT_MESH, // Combined plantlike-on-solid NDT_PLANTLIKE_ROOTED, }; // Mesh options for NDT_PLANTLIKE with CPT2_MESHOPTIONS static const u8 MO_MASK_STYLE = 0x07; static const u8 MO_BIT_RANDOM_OFFSET = 0x08; static const u8 MO_BIT_SCALE_SQRT2 = 0x10; static const u8 MO_BIT_RANDOM_OFFSET_Y = 0x20; enum PlantlikeStyle { PLANT_STYLE_CROSS, PLANT_STYLE_CROSS2, PLANT_STYLE_STAR, PLANT_STYLE_HASH, PLANT_STYLE_HASH2, }; enum AlignStyle : u8 { ALIGN_STYLE_NODE, ALIGN_STYLE_WORLD, ALIGN_STYLE_USER_DEFINED, }; /* Stand-alone definition of a TileSpec (basically a server-side TileSpec) */ struct TileDef { std::string name = ""; bool backface_culling = true; // Takes effect only in special cases bool tileable_horizontal = true; bool tileable_vertical = true; //! If true, the tile has its own color. bool has_color = false; //! The color of the tile. video::SColor color = video::SColor(0xFFFFFFFF); AlignStyle align_style = ALIGN_STYLE_NODE; u8 scale = 0; struct TileAnimationParams animation; TileDef() { animation.type = TAT_NONE; } void serialize(std::ostream &os, u16 protocol_version) const; void deSerialize(std::istream &is, u8 contentfeatures_version, NodeDrawType drawtype); }; #define CF_SPECIAL_COUNT 6 struct ContentFeatures { /* Cached stuff */ #ifndef SERVER // 0 1 2 3 4 5 // up down right left back front TileSpec tiles[6]; // Special tiles // - Currently used for flowing liquids TileSpec special_tiles[CF_SPECIAL_COUNT]; u8 solidness; // Used when choosing which face is drawn u8 visual_solidness; // When solidness=0, this tells how it looks like bool backface_culling; #endif // Server-side cached callback existence for fast skipping bool has_on_construct; bool has_on_destruct; bool has_after_destruct; /* Actual data */ // --- GENERAL PROPERTIES --- std::string name; // "" = undefined node ItemGroupList groups; // Same as in itemdef // Type of MapNode::param1 ContentParamType param_type; // Type of MapNode::param2 ContentParamType2 param_type_2; // --- VISUAL PROPERTIES --- enum NodeDrawType drawtype; std::string mesh; #ifndef SERVER scene::IMesh *mesh_ptr[24]; video::SColor minimap_color; #endif float visual_scale; // Misc. scale parameter TileDef tiledef[6]; // These will be drawn over the base tiles. TileDef tiledef_overlay[6]; TileDef tiledef_special[CF_SPECIAL_COUNT]; // eg. flowing liquid // If 255, the node is opaque. // Otherwise it uses texture alpha. u8 alpha; // The color of the node. video::SColor color; std::string palette_name; std::vector<video::SColor> *palette; // Used for waving leaves/plants u8 waving; // for NDT_CONNECTED pairing u8 connect_sides; std::vector<std::string> connects_to; std::vector<content_t> connects_to_ids; // Post effect color, drawn when the camera is inside the node. video::SColor post_effect_color; // Flowing liquid or snow, value = default level u8 leveled; // --- LIGHTING-RELATED --- bool light_propagates; bool sunlight_propagates; // Amount of light the node emits u8 light_source; // --- MAP GENERATION --- // True for all ground-like things like stone and mud, false for eg. trees bool is_ground_content; // --- INTERACTION PROPERTIES --- // This is used for collision detection. // Also for general solidness queries. bool walkable; // Player can point to these bool pointable; // Player can dig these bool diggable; // Player can climb these bool climbable; // Player can build on these bool buildable_to; // Player cannot build to these (placement prediction disabled) bool rightclickable; u32 damage_per_second; // client dig prediction std::string node_dig_prediction; // --- LIQUID PROPERTIES --- // Whether the node is non-liquid, source liquid or flowing liquid enum LiquidType liquid_type; // If the content is liquid, this is the flowing version of the liquid. std::string liquid_alternative_flowing; // If the content is liquid, this is the source version of the liquid. std::string liquid_alternative_source; // Viscosity for fluid flow, ranging from 1 to 7, with // 1 giving almost instantaneous propagation and 7 being // the slowest possible u8 liquid_viscosity; // Is liquid renewable (new liquid source will be created between 2 existing) bool liquid_renewable; // Number of flowing liquids surrounding source u8 liquid_range; u8 drowning; // Liquids flow into and replace node bool floodable; // --- NODEBOXES --- NodeBox node_box; NodeBox selection_box; NodeBox collision_box; // --- SOUND PROPERTIES --- SimpleSoundSpec sound_footstep; SimpleSoundSpec sound_dig; SimpleSoundSpec sound_dug; // --- LEGACY --- // Compatibility with old maps // Set to true if paramtype used to be 'facedir_simple' bool legacy_facedir_simple; // Set to true if wall_mounted used to be set to true bool legacy_wallmounted; /* Methods */ ContentFeatures(); ~ContentFeatures() = default; void reset(); void serialize(std::ostream &os, u16 protocol_version) const; void deSerialize(std::istream &is); /*! * Since vertex alpha is no longer supported, this method * adds opacity directly to the texture pixels. * * \param tiles array of the tile definitions. * \param length length of tiles */ void correctAlpha(TileDef *tiles, int length); /* Some handy methods */ bool isLiquid() const{ return (liquid_type != LIQUID_NONE); } bool sameLiquid(const ContentFeatures &f) const{ if(!isLiquid() || !f.isLiquid()) return false; return (liquid_alternative_flowing == f.liquid_alternative_flowing); } int getGroup(const std::string &group) const { return itemgroup_get(groups, group); } #ifndef SERVER void updateTextures(ITextureSource *tsrc, IShaderSource *shdsrc, scene::IMeshManipulator *meshmanip, Client *client, const TextureSettings &tsettings); #endif }; /*! * @brief This class is for getting the actual properties of nodes from their * content ID. * * @details The nodes on the map are represented by three numbers (see MapNode). * The first number (param0) is the type of a node. All node types have own * properties (see ContentFeatures). This class is for storing and getting the * properties of nodes. * The manager is first filled with registered nodes, then as the game begins, * functions only get `const` pointers to it, to prevent modification of * registered nodes. */ class NodeDefManager { public: /*! * Creates a NodeDefManager, and registers three ContentFeatures: * \ref CONTENT_AIR, \ref CONTENT_UNKNOWN and \ref CONTENT_IGNORE. */ NodeDefManager(); ~NodeDefManager(); /*! * Returns the properties for the given content type. * @param c content type of a node * @return properties of the given content type, or \ref CONTENT_UNKNOWN * if the given content type is not registered. */ inline const ContentFeatures& get(content_t c) const { return c < m_content_features.size() ? m_content_features[c] : m_content_features[CONTENT_UNKNOWN]; } /*! * Returns the properties of the given node. * @param n a map node * @return properties of the given node or @ref CONTENT_UNKNOWN if the * given content type is not registered. */ inline const ContentFeatures& get(const MapNode &n) const { return get(n.getContent()); } /*! * Returns the node properties for a node name. * @param name name of a node * @return properties of the given node or @ref CONTENT_UNKNOWN if * not found */ const ContentFeatures& get(const std::string &name) const; /*! * Returns the content ID for the given name. * @param name a node name * @param[out] result will contain the content ID if found, otherwise * remains unchanged * @return true if the ID was found, false otherwise */ bool getId(const std::string &name, content_t &result) const; /*! * Returns the content ID for the given name. * @param name a node name * @return ID of the node or @ref CONTENT_IGNORE if not found */ content_t getId(const std::string &name) const; /*! * Returns the content IDs of the given node name or node group name. * Group names start with "group:". * @param name a node name or node group name * @param[out] result will be appended with matching IDs * @return true if `name` is a valid node name or a (not necessarily * valid) group name */ bool getIds(const std::string &name, std::vector<content_t> &result) const; /*! * Returns the smallest box in integer node coordinates that * contains all nodes' selection boxes. The returned box might be larger * than the minimal size if the largest node is removed from the manager. */ inline core::aabbox3d<s16> getSelectionBoxIntUnion() const { return m_selection_box_int_union; } /*! * Checks whether a node connects to an adjacent node. * @param from the node to be checked * @param to the adjacent node * @param connect_face a bit field indicating which face of the node is * adjacent to the other node. * Bits: +y (least significant), -y, -z, -x, +z, +x (most significant). * @return true if the node connects, false otherwise */ bool nodeboxConnects(MapNode from, MapNode to, u8 connect_face) const; /*! * Registers a NodeResolver to wait for the registration of * ContentFeatures. Once the node registration finishes, all * listeners are notified. */ void pendNodeResolve(NodeResolver *nr) const; /*! * Stops listening to the NodeDefManager. * @return true if the listener was registered before, false otherwise */ bool cancelNodeResolveCallback(NodeResolver *nr) const; /*! * Registers a new node type with the given name and allocates a new * content ID. * Should not be called with an already existing name. * @param name name of the node, must match with `def.name`. * @param def definition of the registered node type. * @return ID of the registered node or @ref CONTENT_IGNORE if * the function could not allocate an ID. */ content_t set(const std::string &name, const ContentFeatures &def); /*! * Allocates a blank node ID for the given name. * @param name name of a node * @return allocated ID or @ref CONTENT_IGNORE if could not allocate * an ID. */ content_t allocateDummy(const std::string &name); /*! * Removes the given node name from the manager. * The node ID will remain in the manager, but won't be linked to any name. * @param name name to be removed */ void removeNode(const std::string &name); /*! * Regenerates the alias list (a map from names to node IDs). * @param idef the item definition manager containing alias information */ void updateAliases(IItemDefManager *idef); /*! * Reads the used texture pack's override.txt, and replaces the textures * of registered nodes with the ones specified there. * * Format of the input file: in each line * `node_name top|bottom|right|left|front|back|all|*|sides texture_name.png` * * @param override_filepath path to 'texturepack/override.txt' */ void applyTextureOverrides(const std::string &override_filepath); /*! * Only the client uses this. Loads textures and shaders required for * rendering the nodes. * @param gamedef must be a Client. * @param progress_cbk called each time a node is loaded. Arguments: * `progress_cbk_args`, number of loaded ContentFeatures, number of * total ContentFeatures. * @param progress_cbk_args passed to the callback function */ void updateTextures(IGameDef *gamedef, void (*progress_cbk)(void *progress_args, u32 progress, u32 max_progress), void *progress_cbk_args); /*! * Writes the content of this manager to the given output stream. * @param protocol_version serialization version of ContentFeatures */ void serialize(std::ostream &os, u16 protocol_version) const; /*! * Restores the manager from a serialized stream. * This clears the previous state. * @param is input stream containing a serialized NodeDefManager */ void deSerialize(std::istream &is); /*! * Used to indicate that node registration has finished. * @param completed tells whether registration is complete */ inline void setNodeRegistrationStatus(bool completed) { m_node_registration_complete = completed; } /*! * Notifies the registered NodeResolver instances that node registration * has finished, then unregisters all listeners. * Must be called after node registration has finished! */ void runNodeResolveCallbacks(); /*! * Sets the registration completion flag to false and unregisters all * NodeResolver instances listening to the manager. */ void resetNodeResolveState(); /*! * Resolves the IDs to which connecting nodes connect from names. * Must be called after node registration has finished! */ void mapNodeboxConnections(); private: /*! * Resets the manager to its initial state. * See the documentation of the constructor. */ void clear(); /*! * Allocates a new content ID, and returns it. * @return the allocated ID or \ref CONTENT_IGNORE if could not allocate */ content_t allocateId(); /*! * Binds the given content ID and node name. * Registers them in \ref m_name_id_mapping and * \ref m_name_id_mapping_with_aliases. * @param i a content ID * @param name a node name */ void addNameIdMapping(content_t i, std::string name); /*! * Recalculates m_selection_box_int_union based on * m_selection_box_union. */ void fixSelectionBoxIntUnion(); //! Features indexed by ID. std::vector<ContentFeatures> m_content_features; //! A mapping for fast conversion between names and IDs NameIdMapping m_name_id_mapping; /*! * Like @ref m_name_id_mapping, but maps only from names to IDs, and * includes aliases too. Updated by \ref updateAliases(). * Note: Not serialized. */ std::unordered_map<std::string, content_t> m_name_id_mapping_with_aliases; /*! * A mapping from group names to a vector of content types that belong * to it. Necessary for a direct lookup in \ref getIds(). * Note: Not serialized. */ std::unordered_map<std::string, std::vector<content_t>> m_group_to_items; /*! * The next ID that might be free to allocate. * It can be allocated already, because \ref CONTENT_AIR, * \ref CONTENT_UNKNOWN and \ref CONTENT_IGNORE are registered when the * manager is initialized, and new IDs are allocated from 0. */ content_t m_next_id; //! True if all nodes have been registered. bool m_node_registration_complete; /*! * The union of all nodes' selection boxes. * Might be larger if big nodes are removed from the manager. */ aabb3f m_selection_box_union; /*! * The smallest box in integer node coordinates that * contains all nodes' selection boxes. * Might be larger if big nodes are removed from the manager. */ core::aabbox3d<s16> m_selection_box_int_union; /*! * NodeResolver instances to notify once node registration has finished. * Even constant NodeDefManager instances can register listeners. */ mutable std::vector<NodeResolver *> m_pending_resolve_callbacks; }; NodeDefManager *createNodeDefManager(); class NodeResolver { public: NodeResolver(); virtual ~NodeResolver(); virtual void resolveNodeNames() = 0; bool getIdFromNrBacklog(content_t *result_out, const std::string &node_alt, content_t c_fallback, bool error_on_fallback = true); bool getIdsFromNrBacklog(std::vector<content_t> *result_out, bool all_required = false, content_t c_fallback = CONTENT_IGNORE); void nodeResolveInternal(); u32 m_nodenames_idx = 0; u32 m_nnlistsizes_idx = 0; std::vector<std::string> m_nodenames; std::vector<size_t> m_nnlistsizes; const NodeDefManager *m_ndef = nullptr; bool m_resolve_done = false; };