Changeset - 1f60d0547cc5
Parent rev.
Child rev.
[Not reviewed]
0 3 0
HanzZ - 13 years ago 2012-03-21 15:46:25
hanzz.k@gmail.com
Changed libtransport-plugin deps to have logging.h used from libpurple backend
3 files changed with 20 insertions and 41 deletions:
backends/libpurple/main.cpp
6
36
plugin/cpp/CMakeLists.txt
4
2
src/config.cpp
10
3
0 comments (0 inline, 0 general)
backends/libpurple/main.cpp
➞
Show inline comments
 
#include "utils.h"
 

			




	
	
	
		
 
#include "glib.h"

			




	
	
	
		
 
#include "purple.h"

			




	
	
	
		
 
#include <algorithm>

			




	
	
	
		
 
#include <iostream>

			




	
	
	
		
 

			




	
	
	
		
 
#include "transport/networkplugin.h"

			




	
	
	
		
 
#include "transport/logging.h"

			




	
	
	
		
 
#include "transport/config.h"

			




	
	
	
		
 
#include "geventloop.h"

			




	
	
	
		
 
#include "log4cxx/logger.h"

			




	
	
	
		
 
#include "log4cxx/consoleappender.h"

			




	
	
	
		
 
#include "log4cxx/patternlayout.h"

			




	
	
	
		
 
#include "log4cxx/propertyconfigurator.h"

			




	
	
	
		
 
#include "log4cxx/helpers/properties.h"

			




	
	
	
		
 
#include "log4cxx/helpers/fileinputstream.h"

			




	
	
	
		
 
#include "log4cxx/helpers/transcoder.h"

			




	
	
	
		
 

			




	
	
	
		
 
// #include "valgrind/memcheck.h"

			




	
	
	
		
 
#include "malloc.h"

			




	
	
	
		
 
#include <algorithm>

			




	
	
	
		
 
#include "errno.h"

			




	
	
	
		
 

			




	
	
	
		
 
#ifdef WITH_LIBEVENT

			




	
	
	
		
 
#include <event.h>

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#ifdef WIN32

			




	
	
	
		
 
#include "win32/win32dep.h"

			




	
	
	
		
 
#define ssize_t SSIZE_T

			




	
	
	
		
 
#include <process.h>

			




	
	
	
		
 
#define getpid _getpid

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
using namespace log4cxx;

			




	
	
	
		
 

			




	
	
	
		
 
static LoggerPtr logger_libpurple = log4cxx::Logger::getLogger("libpurple");

			




	
	
	
		
 
static LoggerPtr logger = log4cxx::Logger::getLogger("backend");

			




	
	
	
		
 
int main_socket;

			




	
	
	
		
 
static int writeInput;

			




	
	
	
		
 

			




	
	
	
		
 
using namespace Transport;

			




	
	
	
		
 

			




	
	
	
		
 
template <class T> T fromString(const std::string &str) {

			




	
	
	
		
 
	T i;

			




	
	
	
		
 
	std::istringstream os(str);

			




	
	
	
		
 
	os >> i;

			




	
	
	
		
 
	return i;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
template <class T> std::string stringOf(T object) {

			




	
	
	
		
 
	std::ostringstream os;

			




	
	
	
		
 
	os << object;

			




	
	
	
		
 
	return (os.str());

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
static void transportDataReceived(gpointer data, gint source, PurpleInputCondition cond);

			




	
	
		
 
@@ -1603,120 +1605,88 @@ static void transportDataReceived(gpointer data, gint source, PurpleInputConditi

			




	
	
	
		
 
		if (writeInput != 0) {

			




	
	
	
		
 
			purple_input_remove(writeInput);

			




	
	
	
		
 
			writeInput = 0;

			




	
	
	
		
 
		}

			




	
	
	
		
 
		np->readyForData();

			




	
	
	
		
 
	}

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
int main(int argc, char **argv) {

			




	
	
	
		
 
	GError *error = NULL;

			




	
	
	
		
 
	GOptionContext *context;

			




	
	
	
		
 
	context = g_option_context_new("config_file_name or profile name");

			




	
	
	
		
 
	g_option_context_add_main_entries(context, options_entries, "");

			




	
	
	
		
 
	if (!g_option_context_parse (context, &argc, &argv, &error)) {

			




	
	
	
		
 
		std::cerr << "option parsing failed: " << error->message << "\n";

			




	
	
	
		
 
		return -1;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	if (argc != 2) {

			




	
	
	
		
 
#ifdef WIN32

			




	
	
	
		
 
		std::cout << "Usage: spectrum.exe <configuration_file.cfg>\n";

			




	
	
	
		
 
#else

			




	
	
	
		
 

			




	
	
	
		
 
#if GLIB_CHECK_VERSION(2,14,0)

			




	
	
	
		
 
	std::cout << g_option_context_get_help(context, FALSE, NULL);

			




	
	
	
		
 
#else

			




	
	
	
		
 
	std::cout << "Usage: spectrum <configuration_file.cfg>\n";

			




	
	
	
		
 
	std::cout << "See \"man spectrum\" for more info.\n";

			




	
	
	
		
 
#endif

			




	
	
	
		
 
		

			




	
	
	
		
 
#endif

			




	
	
	
		
 
	}

			




	
	
	
		
 
	else {

			




	
	
	
		
 
#ifndef WIN32

			




	
	
	
		
 
		signal(SIGPIPE, SIG_IGN);

			




	
	
	
		
 

			




	
	
	
		
 
		if (signal(SIGCHLD, spectrum_sigchld_handler) == SIG_ERR) {

			




	
	
	
		
 
			std::cout << "SIGCHLD handler can't be set\n";

			




	
	
	
		
 
			g_option_context_free(context);

			




	
	
	
		
 
			return -1;

			




	
	
	
		
 
		}

			




	
	
	
		
 
#endif

			




	
	
	
		
 
		keyfile = g_key_file_new ();

			




	
	
	
		
 
		if (!g_key_file_load_from_file (keyfile, argv[1], (GKeyFileFlags) 0, 0)) {

			




	
	
	
		
 
			std::cout << "Can't open " << argv[1] << " configuration file.\n";

			




	
	
	
		
 
			return 1;

			




	
	
	
		
 
		}

			




	
	
	
		
 

			




	
	
	
		
 
		if (KEYFILE_STRING("logging", "backend_config").empty()) {

			




	
	
	
		
 
			LoggerPtr root = log4cxx::Logger::getRootLogger();

			




	
	
	
		
 
#ifndef _MSC_VER

			




	
	
	
		
 
			root->addAppender(new ConsoleAppender(new PatternLayout("%d %-5p %c: %m%n")));

			




	
	
	
		
 
#else

			




	
	
	
		
 
			root->addAppender(new ConsoleAppender(new PatternLayout(L"%d %-5p %c: %m%n")));

			




	
	
	
		
 
#endif

			




	
	
	
		
 
		}

			




	
	
	
		
 
		else {

			




	
	
	
		
 
			log4cxx::helpers::Properties p;

			




	
	
	
		
 
			log4cxx::helpers::FileInputStream *istream = NULL;

			




	
	
	
		
 
			try {

			




	
	
	
		
 
				istream = new log4cxx::helpers::FileInputStream(KEYFILE_STRING("logging", "backend_config"));

			




	
	
	
		
 
			}

			




	
	
	
		
 
			catch(log4cxx::helpers::IOException &ex) {

			




	
	
	
		
 
				std::cerr << "Can't create FileInputStream logger instance: " << ex.what() << "\n";

			




	
	
	
		
 
			}

			




	
	
	
		
 
			catch (...) {

			




	
	
	
		
 
				std::cerr << "Can't create FileInputStream logger instance\n";

			




	
	
	
		
 
			}

			




	
	
	
		
 

			




	
	
	
		
 
			if (!istream) {

			




	
	
	
		
 
		Config config;

			




	
	
	
		
 
		if (!config.load(argv[1])) {

			




	
	
	
		
 
			std::cerr << "Can't open " << argv[1] << " configuration file.\n";

			




	
	
	
		
 
			return 1;

			




	
	
	
		
 
		}

			




	
	
	
		
 

			




	
	
	
		
 
			p.load(istream);

			




	
	
	
		
 
			LogString pid, jid;

			




	
	
	
		
 
			log4cxx::helpers::Transcoder::decode(stringOf(getpid()), pid);

			




	
	
	
		
 
			log4cxx::helpers::Transcoder::decode(KEYFILE_STRING("service", "jid"), jid);

			




	
	
	
		
 
#ifdef _MSC_VER

			




	
	
	
		
 
			p.setProperty(L"pid", pid);

			




	
	
	
		
 
			p.setProperty(L"jid", jid);

			




	
	
	
		
 
#else

			




	
	
	
		
 
			p.setProperty("pid", pid);

			




	
	
	
		
 
			p.setProperty("jid", jid);

			




	
	
	
		
 
#endif

			




	
	
	
		
 
			log4cxx::PropertyConfigurator::configure(p);

			




	
	
	
		
 
		}

			




	
	
	
		
 
		Logging::initBackendLogging(&config);

			




	
	
	
		
 

			




	
	
	
		
 
		initPurple();

			




	
	
	
		
 

			




	
	
	
		
 
		main_socket = create_socket(host, port);

			




	
	
	
		
 
		purple_input_add(main_socket, PURPLE_INPUT_READ, &transportDataReceived, NULL);

			




	
	
	
		
 
		purple_timeout_add_seconds(30, pingTimeout, NULL);

			




	
	
	
		
 

			




	
	
	
		
 
		np = new SpectrumNetworkPlugin();

			




	
	
	
		
 
		bool libev = KEYFILE_STRING("service", "eventloop") == "libev";

			




	
	
	
		
 

			




	
	
	
		
 
		GMainLoop *m_loop;

			




	
	
	
		
 
#ifdef WITH_LIBEVENT

			




	
	
	
		
 
		if (!libev) {

			




	
	
	
		
 
			m_loop = g_main_loop_new(NULL, FALSE);

			




	
	
	
		
 
		}

			




	
	
	
		
 
		else {

			




	
	
	
		
 
			event_init();

			




	
	
	
		
 
		}

			




	
	
	
		
 
#endif

			




	
	
	
		
 
		m_loop = g_main_loop_new(NULL, FALSE);

			




	
	
	
		
 

			




	
	
	
		
 
		if (m_loop) {

			




	
	
	
		
 
			g_main_loop_run(m_loop);

			




	
	
	
		
 
		}

			




	
	
	
		
 
#ifdef WITH_LIBEVENT

			




	
	
	
		
 
		else {

			




	
	
	
		
 
			event_loop(0);

			




	
	
	
		
 
		}

			




	
	
	
		
 
#endif

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	g_option_context_free(context);

			




	
	
	
		
 
	return 0;

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    plugin/cpp/CMakeLists.txt
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
cmake_minimum_required(VERSION 2.6)

			




	
	
	
		
 
FILE(GLOB SRC *.cpp *.h)

			




	
	
	
		
 
FILE(GLOB HEADERS ../include/transport/*.h)

			




	
	
	
		
 

			




	
	
	
		
 
set(EXTRA_SOURCES ${CMAKE_CURRENT_BINARY_DIR}/../../src/memoryusage.cpp)

			




	
	
	
		
 
set(EXTRA_SOURCES ${EXTRA_SOURCES} ${CMAKE_CURRENT_BINARY_DIR}/../../src/logging.cpp)

			




	
	
	
		
 
set(EXTRA_SOURCES ${EXTRA_SOURCES} ${CMAKE_CURRENT_BINARY_DIR}/../../src/config.cpp)

			




	
	
	
		
 
set(EXTRA_SOURCES ${EXTRA_SOURCES} ${CMAKE_CURRENT_BINARY_DIR}/../../include/transport/protocol.pb.cc)

			




	
	
	
		
 

			




	
	
	
		
 
if (NOT WIN32)

			




	
	
	
		
 
	ADD_LIBRARY(transport-plugin SHARED ${HEADERS} ${SRC} ${PROTOBUF_SRC} ${PROTOBUF_HDRS} ${EXTRA_SOURCES})

			




	
	
	
		
 
else()

			




	
	
	
		
 
	ADD_LIBRARY(transport-plugin STATIC ${HEADERS} ${SRC} ${PROTOBUF_SRC} ${PROTOBUF_HDRS} ${EXTRA_SOURCES})

			




	
	
	
		
 
endif()

			




	
	
	
		
 
ADD_DEPENDENCIES(transport-plugin pb)

			




	
	
	
		
 
SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/../../include/transport/protocol.pb.cc PROPERTIES GENERATED 1)

			




	
	
	
		
 

			




	
	
	
		
 
if (CMAKE_COMPILER_IS_GNUCXX)

			




	
	
	
		
 
	ADD_DEFINITIONS(-fPIC)

			




	
	
	
		
 
endif()

			




	
	
	
		
 

			




	
	
	
		
 
if (NOT WIN32)

			




	
	
	
		
 
	TARGET_LINK_LIBRARIES(transport-plugin ${PROTOBUF_LIBRARIES} ${LOG4CXX_LIBRARIES})

			




	
	
	
		
 
	TARGET_LINK_LIBRARIES(transport-plugin ${PROTOBUF_LIBRARIES} ${LOG4CXX_LIBRARIES} ${Boost_LIBRARIES})

			




	
	
	
		
 
else()

			




	
	
	
		
 
	TARGET_LINK_LIBRARIES(transport-plugin ${PROTOBUF_LIBRARIES} ${LOG4CXX_LIBRARIES} ws2_32.lib)

			




	
	
	
		
 
	TARGET_LINK_LIBRARIES(transport-plugin ${PROTOBUF_LIBRARIES} ${LOG4CXX_LIBRARIES} ${Boost_LIBRARIES} ws2_32.lib)

			




	
	
	
		
 
endif() 

			




	
	
	
		
 

			




	
	
	
		
 
SET_TARGET_PROPERTIES(transport-plugin PROPERTIES

			




	
	
	
		
 
      VERSION ${TRANSPORT_VERSION} SOVERSION ${TRANSPORT_VERSION}

			




	
	
	
		
 
)

			




	
	
	
		
 

			




	
	
	
		
 
INSTALL(TARGETS transport-plugin LIBRARY DESTINATION lib ARCHIVE DESTINATION lib COMPONENT libraries)

			




	
	
	
		
 

			




	
	
	
		
 
#CONFIGURE_FILE(transport.pc.in "${CMAKE_CURRENT_BINARY_DIR}/transport.pc")

			




	
	
	
		
 
#INSTALL(FILES "${CMAKE_CURRENT_BINARY_DIR}/transport.pc" DESTINATION lib/pkgconfig)

			




        

    


    
    

    

        

                

                    src/config.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/**

			




	
	
	
		
 
 * libtransport -- C++ library for easy XMPP Transports development

			




	
	
	
		
 
 *

			




	
	
	
		
 
 * Copyright (C) 2011, Jan Kaluza <hanzz.k@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  02111-1301  USA

			




	
	
	
		
 
 */

			




	
	
	
		
 

			




	
	
	
		
 
#include "transport/config.h"

			




	
	
	
		
 
#include "transport/util.h"

			




	
	
	
		
 
#include <fstream>

			




	
	
	
		
 
#ifdef _MSC_VER

			




	
	
	
		
 
#include <direct.h>

			




	
	
	
		
 
#define getcwd _getcwd

			




	
	
	
		
 
#include <windows.h>

			




	
	
	
		
 
#define PATH_MAX MAX_PATH

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
using namespace boost::program_options;

			




	
	
	
		
 

			




	
	
	
		
 
namespace Transport {

			




	
	
	
		
 
int getRandomPort(const std::string &s) {

			




	
	
	
		
 
	unsigned long r = 0;

			




	
	
	
		
 
	BOOST_FOREACH(char c, s) {

			




	
	
	
		
 
		r += (int) c;

			




	
	
	
		
 
	}

			




	
	
	
		
 
	srand(time(NULL) + r);

			




	
	
	
		
 
	return 30000 + rand() % 10000;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
bool Config::load(const std::string &configfile, boost::program_options::options_description &opts, const std::string &jid) {

			




	
	
	
		
 
	std::ifstream ifs(configfile.c_str());

			




	
	
	
		
 
	if (!ifs.is_open())

			




	
	
	
		
 
		return false;

			




	
	
	
		
 

			




	
	
	
		
 
	m_file = configfile;

			




	
	
	
		
 
	bool ret = load(ifs, opts, jid);

			




	
	
	
		
 
	ifs.close();

			




	
	
	
		
 

			




	
	
	
		
 
	char path[PATH_MAX] = "";

			




	
	
	
		
 
	if (m_file.find_first_of("/") != 0) {

			




	
	
	
		
 
		getcwd(path, PATH_MAX);

			




	
	
	
		
 
		m_file = std::string(path) + "/" + m_file;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	return ret;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
bool Config::load(std::istream &ifs, boost::program_options::options_description &opts, const std::string &_jid) {

			




	
	
	
		
 
	m_unregistered.clear();

			




	
	
	
		
 
	opts.add_options()

			




	
	
	
		
 
		("service.jid", value<std::string>()->default_value(""), "Transport Jabber ID")

			




	
	
	
		
 
		("service.server", value<std::string>()->default_value(""), "Server to connect to")

			




	
	
	
		
 
		("service.password", value<std::string>()->default_value(""), "Password used to auth the server")

			




	
	
	
		
 
		("service.port", value<int>()->default_value(0), "Port the server is listening on")

			




	
	
	
		
 
		("service.user", value<std::string>()->default_value(""), "The name of user Spectrum runs as.")

			




	
	
	
		
 
		("service.group", value<std::string>()->default_value(""), "The name of group Spectrum runs as.")

			




	
	
	
		
 
		("service.backend", value<std::string>()->default_value("libpurple_backend"), "Backend")

			




	
	
	
		
 
		("service.protocol", value<std::string>()->default_value(""), "Protocol")

			




	
	
	
		
 
		("service.pidfile", value<std::string>()->default_value("/var/run/spectrum2/$jid.pid"), "Full path to pid file")

			




	
	
	
		
 
		("service.working_dir", value<std::string>()->default_value("/var/lib/spectrum2/$jid"), "Working dir")

			




	
	
	
		
 
		("service.allowed_servers", value<std::string>()->default_value(""), "Only users from these servers can connect")

			




	
	
	
		
 
		("service.server_mode", value<bool>()->default_value(false), "True if Spectrum should behave as server")

			




	
	
	
		
 
		("service.users_per_backend", value<int>()->default_value(100), "Number of users per one legacy network backend")

			




	
	
	
		
 
		("service.backend_host", value<std::string>()->default_value("localhost"), "Host to bind backend server to")

			




	
	
	
		
 
		("service.backend_port", value<std::string>()->default_value("0"), "Port to bind backend server to")

			




	
	
	
		
 
		("service.cert", value<std::string>()->default_value(""), "PKCS#12 Certificate.")

			




	
	
	
		
 
		("service.cert_password", value<std::string>()->default_value(""), "PKCS#12 Certificate password.")

			




	
	
	
		
 
		("service.admin_jid", value<std::string>()->default_value(""), "Administrator jid.")

			




	
	
	
		
 
		("service.admin_password", value<std::string>()->default_value(""), "Administrator password.")

			




	
	
	
		
 
		("service.reuse_old_backends", value<bool>()->default_value(true), "True if Spectrum should use old backends which were full in the past.")

			




	
	
	
		
 
		("service.idle_reconnect_time", value<int>()->default_value(0), "Time in seconds after which idle users are reconnected to let their backend die.")

			




	
	
	
		
 
		("service.memory_collector_time", value<int>()->default_value(0), "Time in seconds after which backend with most memory is set to die.")

			




	
	
	
		
 
		("service.more_resources", value<bool>()->default_value(false), "Allow more resources to be connected in server mode at the same time.")

			




	
	
	
		
 
		("service.enable_privacy_lists", value<bool>()->default_value(true), "")

			




	
	
	
		
 
		("vhosts.vhost", value<std::vector<std::string> >()->multitoken(), "")

			




	
	
	
		
 
		("identity.name", value<std::string>()->default_value("Spectrum 2 Transport"), "Name showed in service discovery.")

			




	
	
	
		
 
		("identity.category", value<std::string>()->default_value("gateway"), "Disco#info identity category. 'gateway' by default.")

			




	
	
	
		
 
		("identity.type", value<std::string>()->default_value(""), "Type of transport ('icq','msn','gg','irc', ...)")

			




	
	
	
		
 
		("registration.enable_public_registration", value<bool>()->default_value(true), "True if users should be able to register.")

			




	
	
	
		
 
		("registration.language", value<std::string>()->default_value("en"), "Default language for registration form")

			




	
	
	
		
 
		("registration.instructions", value<std::string>()->default_value("Enter your legacy network username and password."), "Instructions showed to user in registration form")

			




	
	
	
		
 
		("registration.username_label", value<std::string>()->default_value("Legacy network username:"), "Label for username field")

			




	
	
	
		
 
		("registration.username_mask", value<std::string>()->default_value(""), "Username mask")

			




	
	
	
		
 
		("registration.encoding", value<std::string>()->default_value("utf8"), "Default encoding in registration form")

			




	
	
	
		
 
		("registration.require_local_account", value<bool>()->default_value(false), "True if users have to have a local account to register to this transport from remote servers.")

			




	
	
	
		
 
		("registration.local_username_label", value<std::string>()->default_value("Local username:"), "Label for local usernme field")

			




	
	
	
		
 
		("registration.local_account_server", value<std::string>()->default_value("localhost"), "The server on which the local accounts will be checked for validity")

			




	
	
	
		
 
		("registration.local_account_server_timeout", value<int>()->default_value(10000), "Timeout when checking local user on local_account_server (msecs)")

			




	
	
	
		
 
		("database.type", value<std::string>()->default_value("none"), "Database type.")

			




	
	
	
		
 
		("database.database", value<std::string>()->default_value("/var/lib/spectrum2/$jid/database.sql"), "Database used to store data")

			




	
	
	
		
 
		("database.server", value<std::string>()->default_value("localhost"), "Database server.")

			




	
	
	
		
 
		("database.user", value<std::string>()->default_value(""), "Database user.")

			




	
	
	
		
 
		("database.password", value<std::string>()->default_value(""), "Database Password.")

			




	
	
	
		
 
		("database.port", value<int>()->default_value(0), "Database port.")

			




	
	
	
		
 
		("database.prefix", value<std::string>()->default_value(""), "Prefix of tables in database")

			




	
	
	
		
 
		("database.encryption_key", value<std::string>()->default_value(""), "Encryption key.")

			




	
	
	
		
 
		("logging.config", value<std::string>()->default_value(""), "Path to log4cxx config file which is used for Spectrum 2 instance")

			




	
	
	
		
 
		("logging.backend_config", value<std::string>()->default_value(""), "Path to log4cxx config file which is used for backends")

			




	
	
	
		
 
		("backend.default_avatar", value<std::string>()->default_value(""), "Full path to default avatar")

			




	
	
	
		
 
		("backend.avatars_directory", value<std::string>()->default_value(""), "Path to directory with avatars")

			




	
	
	
		
 
		("backend.no_vcard_fetch", value<bool>()->default_value(false), "True if VCards for buddies should not be fetched. Only avatars will be forwarded.")

			




	
	
	
		
 
	;

			




	
	
	
		
 

			




	
	
	
		
 
	parsed_options parsed = parse_config_file(ifs, opts, true);

			




	
	
	
		
 

			




	
	
	
		
 
	bool found_working = false;

			




	
	
	
		
 
	bool found_pidfile = false;

			




	
	
	
		
 
	bool found_backend_port = false;

			




	
	
	
		
 
	bool found_database = false;

			




	
	
	
		
 
	std::string jid = "";

			




	
	
	
		
 
	BOOST_FOREACH(option &opt, parsed.options) {

			




	
	
	
		
 
		if (opt.string_key == "service.jid") {

			




	
	
	
		
 
			if (_jid.empty()) {

			




	
	
	
		
 
				jid = opt.value[0];

			




	
	
	
		
 
			}

			




	
	
	
		
 
			else {

			




	
	
	
		
 
				opt.value[0] = _jid;

			




	
	
	
		
 
				jid = _jid;

			




	
	
	
		
 
			}

			




	
	
	
		
 
		}

			




	
	
	
		
 
		else if (opt.string_key == "service.backend_port") {

			




	
	
	
		
 
			found_backend_port = true;

			




	
	
	
		
 
			if (opt.value[0] == "0") {

			




	
	
	
		
 
				opt.value[0] = boost::lexical_cast<std::string>(Util::getRandomPort(_jid.empty() ? jid : _jid));

			




	
	
	
		
 
				opt.value[0] = boost::lexical_cast<std::string>(getRandomPort(_jid.empty() ? jid : _jid));

			




	
	
	
		
 
			}

			




	
	
	
		
 
		}

			




	
	
	
		
 
		else if (opt.string_key == "service.working_dir") {

			




	
	
	
		
 
			found_working = true;

			




	
	
	
		
 
		}

			




	
	
	
		
 
		else if (opt.string_key == "service.pidfile") {

			




	
	
	
		
 
			found_pidfile = true;

			




	
	
	
		
 
		}

			




	
	
	
		
 
		else if (opt.string_key == "database.database") {

			




	
	
	
		
 
			found_database = true;

			




	
	
	
		
 
		}

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	if (!found_working) {

			




	
	
	
		
 
		std::vector<std::string> value;

			




	
	
	
		
 
		value.push_back("/var/lib/spectrum2/$jid");

			




	
	
	
		
 
		parsed.options.push_back(boost::program_options::basic_option<char>("service.working_dir", value));

			




	
	
	
		
 
	}

			




	
	
	
		
 
	if (!found_pidfile) {

			




	
	
	
		
 
		std::vector<std::string> value;

			




	
	
	
		
 
		value.push_back("/var/run/spectrum2/$jid.pid");

			




	
	
	
		
 
		parsed.options.push_back(boost::program_options::basic_option<char>("service.pidfile", value));

			




	
	
	
		
 
	}

			




	
	
	
		
 
	if (!found_backend_port) {

			




	
	
	
		
 
		std::vector<std::string> value;

			




	
	
	
		
 
		std::string p = boost::lexical_cast<std::string>(Util::getRandomPort(_jid.empty() ? jid : _jid));

			




	
	
	
		
 
		std::string p = boost::lexical_cast<std::string>(getRandomPort(_jid.empty() ? jid : _jid));

			




	
	
	
		
 
		value.push_back(p);

			




	
	
	
		
 
		parsed.options.push_back(boost::program_options::basic_option<char>("service.backend_port", value));

			




	
	
	
		
 
	}

			




	
	
	
		
 
	if (!found_database) {

			




	
	
	
		
 
		std::vector<std::string> value;

			




	
	
	
		
 
		value.push_back("/var/lib/spectrum2/$jid/database.sql");

			




	
	
	
		
 
		parsed.options.push_back(boost::program_options::basic_option<char>("database.database", value));

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	BOOST_FOREACH(option &opt, parsed.options) {

			




	
	
	
		
 
		if (opt.unregistered) {

			




	
	
	
		
 
			m_unregistered[opt.string_key] = opt.value[0];

			




	
	
	
		
 
		}

			




	
	
	
		
 
		else if (opt.value[0].find("$jid") != std::string::npos) {

			




	
	
	
		
 
			boost::replace_all(opt.value[0], "$jid", jid);

			




	
	
	
		
 
		}

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	store(parsed, m_variables);

			




	
	
	
		
 
	notify(m_variables);

			




	
	
	
		
 

			




	
	
	
		
 
	onConfigReloaded();

			




	
	
	
		
 

			




	
	
	
		
 
	return true;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
bool Config::load(std::istream &ifs) {

			




	
	
	
		
 
	options_description opts("Transport options");

			




	
	
	
		
 
	return load(ifs, opts);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
bool Config::load(const std::string &configfile, const std::string &jid) {

			




	
	
	
		
 
	options_description opts("Transport options");

			




	
	
	
		
 
	return load(configfile, opts, jid);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
bool Config::reload() {

			




	
	
	
		
 
	if (m_file.empty()) {

			




	
	
	
		
 
		return false;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	return load(m_file);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
}

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        Server instance: srv01-1135
    
    
        This site is powered by
            Kallithea,
        which is
        © 2010–2021 by various authors & licensed under GPLv3.
            – Support