src/script/lua_api/l_particles.h


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

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

#ifndef L_PARTICLES_H_
#define L_PARTICLES_H_

#include "lua_api/l_base.h"

class ModApiParticles : public ModApiBase {
private:
	static int l_add_particle(lua_State *L);
	static int l_add_particlespawner(lua_State *L);
	static int l_delete_particlespawner(lua_State *L);

public:
	static void Initialize(lua_State *L, int top);
};


#endif /* L_PARTICLES_H_ */
/*
Minetest-c55
Copyright (C) 2011 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 General Public License as published by
the Free Software Foundation; either version 2 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 General Public License for more details.

You should have received a copy of the GNU 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 "auth.h"
#include <fstream>
#include <jmutexautolock.h>
//#include "main.h" // for g_settings
#include <sstream>
#include "strfnd.h"
#include "log.h"

std::set<std::string> privsToSet(u64 privs)
{
	std::set<std::string> s;
	if(privs & PRIV_INTERACT)
		s.insert("interact");
	if(privs & PRIV_TELEPORT)
		s.insert("teleport");
	if(privs & PRIV_SETTIME)
		s.insert("settime");
	if(privs & PRIV_PRIVS)
		s.insert("privs");
	if(privs & PRIV_SHOUT)
		s.insert("shout");
	if(privs & PRIV_BAN)
		s.insert("ban");
	if(privs & PRIV_GIVE)
		s.insert("give");
	if(privs & PRIV_PASSWORD)
		s.insert("password");
	return s;
}

// Convert a privileges value into a human-readable string,
// with each component separated by a comma.
std::string privsToString(u64 privs)
{
	std::ostringstream os(std::ios_base::binary);
	if(privs & PRIV_INTERACT)
		os<<"interact,";
	if(privs & PRIV_TELEPORT)
		os<<"teleport,";
	if(privs & PRIV_SETTIME)
		os<<"settime,";
	if(privs & PRIV_PRIVS)
		os<<"privs,";
	if(privs & PRIV_SHOUT)
		os<<"shout,";
	if(privs & PRIV_BAN)
		os<<"ban,";
	if(privs & PRIV_GIVE)
		os<<"give,";
	if(privs & PRIV_PASSWORD)
		os<<"password,";
	if(os.tellp())
	{
		// Drop the trailing comma. (Why on earth can't
		// you truncate a C++ stream anyway???)
		std::string tmp = os.str();
		return tmp.substr(0, tmp.length() -1);
	}
	return os.str();
}

// Converts a comma-seperated list of privilege values into a
// privileges value. The reverse of privsToString(). Returns
// PRIV_INVALID if there is anything wrong with the input.
u64 stringToPrivs(std::string str)
{
	u64 privs=0;
	Strfnd f(str);
	while(f.atend() == false)
	{
		std::string s = trim(f.next(","));
		if(s == "build")
			privs |= PRIV_INTERACT;
		else if(s == "interact")
			privs |= PRIV_INTERACT;
		else if(s == "teleport")
			privs |= PRIV_TELEPORT;
		else if(s == "settime")
			privs |= PRIV_SETTIME;
		else if(s == "privs")
			privs |= PRIV_PRIVS;
		else if(s == "shout")
			privs |= PRIV_SHOUT;
		else if(s == "ban")
			privs |= PRIV_BAN;
		else if(s == "give")
			privs |= PRIV_GIVE;
		else if(s == "password")
			privs |= PRIV_PASSWORD;
		else
			return PRIV_INVALID;
	}
	return privs;
}

AuthManager::AuthManager(const std::string &authfilepath):
		m_authfilepath(authfilepath),
		m_modified(false)
{
	m_mutex.Init();
	
	try{
		load();
	}
	catch(SerializationError &e)
	{
		infostream<<"WARNING: AuthManager: creating "
				<<m_authfilepath<<std::endl;
	}
}

AuthManager::~AuthManager()
{
	save();
}

void AuthManager::load()
{
	JMutexAutoLock lock(m_mutex);
	
	infostream<<"AuthManager: loading from "<<m_authfilepath<<std::endl;
	std::ifstream is(m_authfilepath.c_str(), std::ios::binary);
	if(is.good() == false)