libtransport.git Changeset - d0ead2e24cff

Changeset - d0ead2e24cff

Parent rev.

Child rev.

[Not reviewed]

Merge

0 5 0

Darchigh - 13 years ago 2013-01-22 10:42:29
Darchigh@gmail.com

Merge branch 'master' of http://github.com/hanzz/libtransport

4 files changed with 30 insertions and 24 deletions:

spectrum/src/sample.cfg

spectrum_manager/src/main.cpp

src/logging.cpp

src/userregistry.cpp

0 comments (0 inline, 0 general)

spectrum/src/sample.cfg

➞

Show inline comments

 [service]
 jid = localhost
 password = secret
 server = 127.0.0.1
 port = 5222
 server_mode = 1
 backend_host=localhost
 pidfile=./test.pid
 # < this option doesn't work yet
 #backend_port=10001
 #admin_jid=admin@localhost
 admin_password=test
 #cert=server.pfx #patch to PKCS#12 certificate
 #cert_password=test #password to that certificate if any
 users_per_backend=10
 backend=../..//backends/swiften/spectrum2_swiften_backend
+#backend=../..//backends/swiften/spectrum2_swiften_backend
 #backend=../../backends/twitter/spectrum2_twitter_backend
-#backend=/home/hanzz/code/libtransport/backends/libcommuni/spectrum2_libcommuni_backend
 backend=/home/hanzz/code/libtransport/backends/libcommuni/spectrum2_libcommuni_backend
 protocol=prpl-jabber
 #protocol=prpl-msn
 #protocol=any
 #protocol=prpl-icq
 working_dir=./
 portfile=$jid.port
+portfile=./$jid.port
 irc_server=irc.freenode.org
 [backend]
 #default_avatar=catmelonhead.jpg
 #no_vcard_fetch=true
 [logging]
 #config=logging.cfg # log4cxx/log4j logging configuration file
 #backend_config=/home/hanzz/code/libtransport/spectrum/src/backend-logging.cfg # log4cxx/log4j logging configuration file for backends
 [database]
 type=sqlite3 # or "none" without database backend
 database=users.sqlite
 prefix=twitter
 #type = mysql # or "none" without database backend.......................................................................................................................
 #database = test
 #prefix=
 #user=root
 #password=yourrootsqlpassword
 #encryption_key=hanzzik

spectrum_manager/src/main.cpp

➞

Show inline comments

@@ @@ -93,96 +93,99 @@ int main(int argc, char **argv) @@
+		;
 	try
+	{
 		boost::program_options::positional_options_description p;
 		p.add("command", -1);
 		boost::program_options::store(boost::program_options::command_line_parser(argc, argv).
           options(desc).positional(p).run(), vm);
 		boost::program_options::notify(vm);
 		if(vm.count("help"))
+		{
 			std::cout << desc << "\n";
 			return 1;
+		}
+	}
 	catch (std::runtime_error& e)
+	{
 		std::cout << desc << "\n";
 		return 2;
+	}
 	catch (...)
+	{
 		std::cout << desc << "\n";
 		return 3;
+	}
 	if (!config.load(config_file)) {
 		std::cerr << "Can't load configuration file.\n";
 		return 4;
+	}
 	if (command.empty()) {
 		std::cout << desc << "\n";
 		return 1;
+	}
 	if (command[0] == "start") {
 		return start_instances(&config);
+	}
 	else if (command[0] == "stop") {
 		stop_instances(&config);
+	}
 	else if (command[0] == "status") {
 		return show_status(&config);
+	}
 	else if (command[0] == "list") {
 		std::vector<std::string> list = show_list(&config);
+	}
 	else if (command[0] == "restart") {
 		return restart_instances(&config);
+	}
 	else if (command[0] == "server") {
 		Server server(&config);
 		if (server.start() == false) {
 			std::cerr << "Can't set up server handler.\n";
 			return 1;
+		}
 		while (1) { sleep(10); }
+	}
 	else {
 		if (command.size() < 2) {
 			std::cout << desc << "\n";
 			return 11;
+		}
 		Swift::SimpleEventLoop eventLoop;
 		Swift::BoostNetworkFactories networkFactories(&eventLoop);
 		std::string jid = command[0];
 		command.erase(command.begin());
 		std::string cmd = boost::algorithm::join(command, " ");
 		if (cmd == "start") {
 			return start_instances(&config, jid);
+		}
 		else if (cmd == "stop") {
 			stop_instances(&config, jid);
 			return 0;
+		}
 		else if (cmd == "restart") {
 			return restart_instances(&config, jid);
+		}
 		ask_local_server(&config, networkFactories, jid, cmd);
 // 		std::string message = command;
 // 		m = &message;
 // 		ask_local_server(&config, networkFactories, message);
 		eventLoop.runUntilEvents();
 		struct timeval td_start,td_end;
 		float elapsed = 0;
 		gettimeofday(&td_start, NULL);
 		time_t started = time(NULL);
 		while(get_response().empty()) {
 			eventLoop.runUntilEvents();
+		}

src/logging.cpp

➞

Show inline comments

@@ @@ -46,179 +46,191 @@ @@
 using namespace boost::filesystem;
 namespace Transport {
 namespace Logging {
 #ifdef WITH_LOG4CXX
 using namespace log4cxx;
 static LoggerPtr root;
 class intercept_stream : public std::streambuf{
 public:
     intercept_stream(std::ostream& stream, char const* logger):
       _logger(log4cxx::Logger::getLogger(logger))
+    {
 		stream.rdbuf(this);
+    }
     ~intercept_stream(){
+    }
 protected:
     virtual std::streamsize xsputn(const char *msg, std::streamsize count){
         //Output to log4cxx logger
         std::string s(msg, count - 1); // remove last \n
 		LOG4CXX_INFO(_logger, s);
         return count;
+    }
 	int overflow(int c)
+	{
 		return 0;
+	}
 	int sync()
+	{
 		return 0;
+	}
 private:
     log4cxx::LoggerPtr _logger;
 };
 static intercept_stream* intercepter_cout;
 static intercept_stream* intercepter_cerr;
 static void initLogging(Config *config, std::string key) {
+static void initLogging(Config *config, std::string key, bool only_create_dir = false) {
 	if (CONFIG_STRING(config, key).empty()) {
 		if (only_create_dir) {
 			return;
+		}
 		root = log4cxx::Logger::getRootLogger();
 #ifdef _MSC_VER
 		root->addAppender(new ConsoleAppender(new PatternLayout(L"%d %-5p %c: %m%n")));
 #else
 		root->addAppender(new ConsoleAppender(new PatternLayout("%d %-5p %c: %m%n")));
 #endif
+	}
 	else {
 		log4cxx::helpers::Properties p;
 		log4cxx::helpers::FileInputStream *istream = NULL;
 		try {
 			istream = new log4cxx::helpers::FileInputStream(CONFIG_STRING(config, key));
+		}
 		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) {
 			return;
+		}
 		p.load(istream);
 		LogString pid, jid, id;
 		log4cxx::helpers::Transcoder::decode(boost::lexical_cast<std::string>(getpid()), pid);
 		log4cxx::helpers::Transcoder::decode(CONFIG_STRING(config, "service.jid"), jid);
 		log4cxx::helpers::Transcoder::decode(CONFIG_STRING_DEFAULTED(config, "service.backend_id", ""), id);
 #ifdef _MSC_VER
 		p.setProperty(L"pid", pid);
 		p.setProperty(L"jid", jid);
 		p.setProperty(L"id", id);
 #else
 		p.setProperty("pid", pid);
 		p.setProperty("jid", jid);
 		p.setProperty("id", id);
 #endif
-		std::string dir;
+		std::vector<std::string> dirs;
 		BOOST_FOREACH(const log4cxx::LogString &prop, p.propertyNames()) {
 // 			if (boost::ends_with(prop, ".File")) {
 			if (boost::ends_with(prop, ".File")) {
 				std::string dir;
 				log4cxx::helpers::Transcoder::encode(p.get(prop), dir);
 				boost::replace_all(dir, "${jid}", jid);
 				boost::replace_all(dir, "${pid}", pid);
 				boost::replace_all(dir, "${id}", id);
 				break;
 // 			}
 				dirs.push_back(dir);
+			}
+		}
 		mode_t old_cmask;
 		if (!dir.empty()) {
 		// create directories
 #ifndef WIN32
 		old_cmask = umask(0007);
 #endif
 		BOOST_FOREACH(std::string &dir, dirs) {
 			if (!dir.empty()) {
 				try {
 					Transport::Util::createDirectories(config, boost::filesystem::path(dir).parent_path());
+				}
 				catch (const boost::filesystem::filesystem_error &e) {
 					std::cerr << "Can't create logging directory directory " << boost::filesystem::path(dir).parent_path().string() << ": " << e.what() << ".\n";
+				}
+			}
+		}
 #ifndef WIN32
 		umask(old_cmask);
 #endif
 		if (only_create_dir) {
 			return;
+		}
 		log4cxx::PropertyConfigurator::configure(p);
 		// Change owner of main log file
 #ifndef WIN32
 	BOOST_FOREACH(std::string &dir, dirs) {
 		if (!CONFIG_STRING(config, "service.group").empty() && !CONFIG_STRING(config, "service.user").empty()) {
 			struct group *gr;
 			if ((gr = getgrnam(CONFIG_STRING(config, "service.group").c_str())) == NULL) {
 				std::cerr << "Invalid service.group name " << CONFIG_STRING(config, "service.group") << "\n";
+			}
 			struct passwd *pw;
 			if ((pw = getpwnam(CONFIG_STRING(config, "service.user").c_str())) == NULL) {
 				std::cerr << "Invalid service.user name " << CONFIG_STRING(config, "service.user") << "\n";
+			}
 			chown(dir.c_str(), pw->pw_uid, gr->gr_gid);
+		}
 #endif
 #ifndef WIN32
 		if (!dir.empty()) {
 			umask(old_cmask);
+	}
 #endif
+	}
+}
 void initBackendLogging(Config *config) {
 	initLogging(config, "logging.backend_config");
 	redirect_stderr();
+}
 void initMainLogging(Config *config) {
 	initLogging(config, "logging.config");
 	initLogging(config, "logging.backend_config", true);
+}
 void redirect_stderr() {
 	 intercepter_cerr = new intercept_stream(std::cerr, "cerr");
 	 intercepter_cout = new intercept_stream(std::cout, "cout");
+}
 void shutdownLogging() {
 	delete intercepter_cerr;
 	delete intercepter_cout;
 	log4cxx::LogManager::shutdown();
+}
 #else /* WITH_LOG4CXX */
 void initBackendLogging(Config */*config*/) {
+}
 void initMainLogging(Config */*config*/) {
+}
 void shutdownLogging() {
+}
 void redirect_stderr() {
+}
 #endif /* WITH_LOG4CXX */
+}
+}

src/userregistry.cpp

➞

Show inline comments

 	m_removeTimer = factories->getTimerFactory()->createTimer(1);
 	m_inRemoveLater = false;
+}
 UserRegistry::~UserRegistry() { m_removeTimer->stop(); }
 void UserRegistry::isValidUserPassword(const Swift::JID& user, Swift::ServerFromClientSession *session, const Swift::SafeByteArray& password) {
 	std::vector<std::string> const &x = CONFIG_VECTOR(config,"service.admin_jid");
 	if (std::find(x.begin(), x.end(), user.toBare().toString()) != x.end()) {
 		if (Swift::safeByteArrayToString(password) == CONFIG_STRING(config, "service.admin_password")) {
 			session->handlePasswordValid();
+		}
 		else {
 			session->handlePasswordInvalid();
+		}
 		return;
+	}
 	std::string key = user.toBare().toString();
 	// Users try to connect twice
 	if (users.find(key) != users.end()) {
 		// Kill the first session
 		LOG4CXX_INFO(logger, key << ": Removing previous session and making this one active");
 		Swift::ServerFromClientSession *tmp = users[key].session;
 		users[key].session = session;
 		tmp->handlePasswordInvalid();
+	}
 	LOG4CXX_INFO(logger, key << ": Connecting this user to find if password is valid");
 	users[key].password = Swift::safeByteArrayToString(password);
 	users[key].session = session;
 	onConnectUser(user);
 	return;
+}
 void UserRegistry::stopLogin(const Swift::JID& user, Swift::ServerFromClientSession *session) {
 	std::string key = user.toBare().toString();
 	if (users.find(key) != users.end()) {
 		if (users[key].session == session) {
 			LOG4CXX_INFO(logger, key << ": Stopping login process (user probably disconnected while logging in)");
 			users.erase(key);
+		}
 		else {
 			LOG4CXX_WARN(logger, key << ": Stopping login process (user probably disconnected while logging in), but this is not active session");
+		}
+	}
 	else {
 		LOG4CXX_WARN(logger, key << ": Stopping login process (user probably disconnected while logging in) for invalid user");
+	}
 	// ::removeLater can be called only by libtransport, not by Swift and libtransport
 	// takes care about user disconnecting itself, so don't call our signal.
 	if (!m_inRemoveLater)
 		onDisconnectUser(user);
+}
 void UserRegistry::onPasswordValid(const Swift::JID &user) {
 	std::string key = user.toBare().toString();
 	if (users.find(key) != users.end()) {
 		LOG4CXX_INFO(logger, key << ": Password is valid");
 		users[key].session->handlePasswordValid();
 		users.erase(key);
+	}
 	else {
 		LOG4CXX_INFO(logger, key << ": onPasswordValid called for invalid user");
+	}
+}
 void UserRegistry::onPasswordInvalid(const Swift::JID &user, const std::string &error) {
 	std::string key = user.toBare().toString();
 	if (users.find(key) != users.end()) {
 		LOG4CXX_INFO(logger, key << ": Password is invalid");
+		LOG4CXX_INFO(logger, key << ": Password is invalid or there was an error when connecting the legacy network");
 		users[key].session->handlePasswordInvalid(error);
 		users.erase(key);
+	}
 	else {
 		LOG4CXX_INFO(logger, key << ": onPasswordInvalid called for invalid user");
+	}
+}
 void UserRegistry::handleRemoveTimeout(const Swift::JID &user) {
 	m_inRemoveLater = true;
 	onPasswordInvalid(user);
 	m_inRemoveLater = false;
+}
 void UserRegistry::removeLater(const Swift::JID &user) {
 	m_removeTimer->onTick.connect(boost::bind(&UserRegistry::handleRemoveTimeout, this, user));
 	m_removeTimer->start();
+}
 const std::string UserRegistry::getUserPassword(const std::string &barejid) {
 	if (users.find(barejid) != users.end())
 		return users[barejid].password;
 	return "";
+}
+}

0 comments (0 inline, 0 general)