libtransport.git Changeset - 858ac82b1966

Changeset - 858ac82b1966

Parent rev.

Child rev.

[Not reviewed]

Merge

0 8 6

Jan Kaluza - 14 years ago 2012-01-18 09:39:47
hanzz.k@gmail.com

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

6 files changed with 80 insertions and 35 deletions:

backends/libpurple/main.cpp

include/Swiften/Server/ServerStanzaChannel.cpp

include/Swiften/Server/ServerStanzaChannel.h

include/transport/pqxxbackend.h

spectrum/src/main.cpp

src/pqxxbackend.cpp

0 comments (0 inline, 0 general)

backends/libpurple/main.cpp

➞

Show inline comments

@@ @@ -521,197 +521,199 @@ class SpectrumNetworkPlugin : public NetworkPlugin { @@
 		void getProtocolAndName(const std::string &legacyName, std::string &name, std::string &protocol) {
 			name = legacyName;
 			protocol = KEYFILE_STRING("service", "protocol");
 			if (protocol == "any") {
 				protocol = name.substr(0, name.find("."));
 				name = name.substr(name.find(".") + 1);
+			}
+		}
 		void setDefaultAvatar(PurpleAccount *account, const std::string &legacyName) {
 			char* contents;
 			gsize length;
 			gboolean ret = false;
 			if (!KEYFILE_STRING("backend", "avatars_directory").empty()) {
 				std::string f = KEYFILE_STRING("backend", "avatars_directory") + "/" + legacyName;
 				ret = g_file_get_contents (f.c_str(), &contents, &length, NULL);
+			}
 			if (!KEYFILE_STRING("backend", "default_avatar").empty() && !ret) {
 				ret = g_file_get_contents (KEYFILE_STRING("backend", "default_avatar").c_str(),
 											&contents, &length, NULL);
+			}
 			if (ret) {
 				purple_buddy_icons_set_account_icon(account, (guchar *) contents, length);
+			}
+		}
 		void setDefaultAccountOptions(PurpleAccount *account) {
 			int i = 0;
 			gchar **keys = g_key_file_get_keys (keyfile, "purple", NULL, NULL);
 			while (keys && keys[i] != NULL) {
 				std::string key = keys[i];
 				if (key == "fb_api_key" || key == "fb_api_secret") {
 					purple_account_set_bool(account, "auth_fb", TRUE);
+				}
 				PurplePlugin *plugin = purple_find_prpl(purple_account_get_protocol_id(account));
 				PurplePluginProtocolInfo *prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(plugin);
 				bool found = false;
 				for (GList *l = prpl_info->protocol_options; l != NULL; l = l->next) {
 					PurpleAccountOption *option = (PurpleAccountOption *) l->data;
 					PurplePrefType type = purple_account_option_get_type(option);
 					std::string key2(purple_account_option_get_setting(option));
 					if (key != key2) {
 						continue;
+					}
 					found = true;
 					switch (type) {
 						case PURPLE_PREF_BOOLEAN:
 							purple_account_set_bool(account, key.c_str(), fromString<bool>(KEYFILE_STRING("purple", key)));
 							break;
 						case PURPLE_PREF_INT:
 							purple_account_set_int(account, key.c_str(), fromString<int>(KEYFILE_STRING("purple", key)));
 							break;
 						case PURPLE_PREF_STRING:
 						case PURPLE_PREF_STRING_LIST:
 							purple_account_set_string(account, key.c_str(), KEYFILE_STRING("purple", key).c_str());
 							break;
 						default:
 							continue;
+					}
 					break;
+				}
 				if (!found) {
 					purple_account_set_string(account, key.c_str(), KEYFILE_STRING("purple", key).c_str());
+				}
 				i++;
+			}
 			g_strfreev (keys);
+		}
 		void handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) {
 			PurpleAccount *account = NULL;
 			std::string name;
 			std::string protocol;
 			getProtocolAndName(legacyName, name, protocol);
 			if (password.empty()) {
 				LOG4CXX_INFO(logger,  name.c_str() << ": Empty password");
 				np->handleDisconnected(user, 0, "Empty password.");
 				return;
+			}
 			if (!purple_find_prpl(protocol.c_str())) {
 				LOG4CXX_INFO(logger,  name.c_str() << ": Invalid protocol '" << protocol << "'");
 				np->handleDisconnected(user, 0, "Invalid protocol " + protocol);
 				return;
+			}
-			LOG4CXX_INFO(logger,  "Creating account with name '" << name.c_str() << "' and protocol '" << protocol << "'");
 			if (purple_accounts_find(name.c_str(), protocol.c_str()) != NULL) {
 				LOG4CXX_INFO(logger, "Using previously created account with name '" << name.c_str() << "' and protocol '" << protocol << "'");
 				account = purple_accounts_find(name.c_str(), protocol.c_str());
+			}
 			else {
 				LOG4CXX_INFO(logger, "Creating account with name '" << name.c_str() << "' and protocol '" << protocol << "'");
 				account = purple_account_new(name.c_str(), protocol.c_str());
 				purple_accounts_add(account);
+			}
 			m_sessions[user] = account;
 			m_accounts[account] = user;
 			// Default avatar
 			setDefaultAvatar(account, legacyName);
 			purple_account_set_password(account, password.c_str());
 			purple_account_set_bool(account, "custom_smileys", FALSE);
 			purple_account_set_bool(account, "direct_connect", FALSE);
 			setDefaultAccountOptions(account);
 			purple_account_set_enabled(account, "spectrum", TRUE);
 			if (KEYFILE_BOOL("service", "enable_privacy_lists")) {
 				purple_account_set_privacy_type(account, PURPLE_PRIVACY_DENY_USERS);
+			}
 			const PurpleStatusType *status_type = purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_AVAILABLE);
 			if (status_type != NULL) {
 				purple_account_set_status(account, purple_status_type_get_id(status_type), TRUE, NULL);
+			}
+		}
 		void handleLogoutRequest(const std::string &user, const std::string &legacyName) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 // 				VALGRIND_DO_LEAK_CHECK;
 				m_sessions.erase(user);
 				purple_account_disconnect(account);
 				purple_account_set_enabled(account, "spectrum", FALSE);
 				g_free(account->ui_data);
 				account->ui_data = NULL;
 				m_accounts.erase(account);
 				purple_accounts_delete(account);
 //
 // 				// Remove conversations.
 // 				// This has to be called before m_account->ui_data = NULL;, because it uses
 // 				// ui_data to call SpectrumMessageHandler::purpleConversationDestroyed() callback.
 // 				GList *iter;
 // 				for (iter = purple_get_conversations(); iter; ) {
 // 					PurpleConversation *conv = (PurpleConversation*) iter->data;
 // 					iter = iter->next;
 // 					if (purple_conversation_get_account(conv) == account)
 // 						purple_conversation_destroy(conv);
 // 				}
 //
 // 				g_free(account->ui_data);
 // 				account->ui_data = NULL;
 // 				m_accounts.erase(account);
 //
 // 				purple_notify_close_with_handle(account);
 // 				purple_request_close_with_handle(account);
 //
 // 				purple_accounts_remove(account);
 //
 // 				GSList *buddies = purple_find_buddies(account, NULL);
 // 				while(buddies) {
 // 					PurpleBuddy *b = (PurpleBuddy *) buddies->data;
 // 					purple_blist_remove_buddy(b);
 // 					buddies = g_slist_delete_link(buddies, buddies);
 // 				}
 //
 // 				/* Remove any open conversation for this account */
 // 				for (GList *it = purple_get_conversations(); it; ) {
 // 					PurpleConversation *conv = (PurpleConversation *) it->data;
 // 					it = it->next;
 // 					if (purple_conversation_get_account(conv) == account)
 // 						purple_conversation_destroy(conv);
 // 				}
 //
 // 				/* Remove this account's pounces */
 // 					// purple_pounce_destroy_all_by_account(account);
 //
 // 				/* This will cause the deletion of an old buddy icon. */
 // 				purple_buddy_icons_set_account_icon(account, NULL, 0);
 //
 // 				purple_account_destroy(account);
 				// force returning of memory chunks allocated by libxml2 to kernel
 #ifndef WIN32
 				malloc_trim(0);
 #endif
 // 				VALGRIND_DO_LEAK_CHECK;
+			}
+		}
 		void handleStatusChangeRequest(const std::string &user, int status, const std::string &statusMessage) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				int st;
 				switch(status) {
 			status = pbnetwork::STATUS_ONLINE;
 			break;
+		}
 		case PURPLE_STATUS_AWAY: {
 			status = pbnetwork::STATUS_AWAY;
 			break;
+		}
 		case PURPLE_STATUS_UNAVAILABLE: {
 			status = pbnetwork::STATUS_DND;
 			break;
+		}
 		case PURPLE_STATUS_EXTENDED_AWAY: {
 			status = pbnetwork::STATUS_XA;
 			break;
+		}
 		case PURPLE_STATUS_OFFLINE: {
 			status = pbnetwork::STATUS_NONE;
 			break;
+		}
 		default:
 			status = pbnetwork::STATUS_ONLINE;
 			break;
+	}
 	const char *message = purple_status_get_attr_string(stat, "message");
 	if (message != NULL) {
 		char *stripped = purple_markup_strip_html(message);
 		statusMessage = std::string(stripped);
 		g_free(stripped);
+	}
 	else
 		statusMessage = "";
 	return true;
+}
 static std::string getIconHash(PurpleBuddy *m_buddy) {
 	char *avatarHash = NULL;
 	PurpleBuddyIcon *icon = purple_buddy_icons_find(purple_buddy_get_account(m_buddy), purple_buddy_get_name(m_buddy));
 	if (icon) {
 		avatarHash = purple_buddy_icon_get_full_path(icon);
 		purple_buddy_icon_unref(icon);
+	}
 	if (avatarHash) {
 		// Check if it's patched libpurple which saves icons to directories
 		char *hash = strrchr(avatarHash,'/');
 		std::string h;
 		if (hash) {
 			char *dot;
 			hash++;
 			dot = strchr(hash, '.');
 			if (dot)
 				*dot = '\0';
 			std::string ret(hash);
 			g_free(avatarHash);
 			return ret;
+		}
 		else {
 			std::string ret(avatarHash);
 			g_free(avatarHash);
 			return ret;
+		}
+	}
 	return "";
+}
 static std::vector<std::string> getGroups(PurpleBuddy *m_buddy) {
 	std::vector<std::string> groups;
 	if (purple_buddy_get_name(m_buddy)) {
 		GSList *buddies = purple_find_buddies(purple_buddy_get_account(m_buddy), purple_buddy_get_name(m_buddy));
 		while(buddies) {
 			PurpleGroup *g = purple_buddy_get_group((PurpleBuddy *) buddies->data);
 			buddies = g_slist_delete_link(buddies, buddies);
 			if(g && purple_group_get_name(g)) {
 				groups.push_back(purple_group_get_name(g));
+			}
+		}
+	}
 	if (groups.empty()) {
 		groups.push_back("Buddies");
+	}
 	return groups;
+}
 static void buddyListNewNode(PurpleBlistNode *node) {
 	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))
 		return;
 	PurpleBuddy *buddy = (PurpleBuddy *) node;
 	PurpleAccount *account = purple_buddy_get_account(buddy);
 	LOG4CXX_INFO(logger, "Buddy updated " << np->m_accounts[account] << " " << purple_buddy_get_name(buddy) << " " << getAlias(buddy));
 	// Status
 	pbnetwork::StatusType status = pbnetwork::STATUS_NONE;
 	std::string message;
 	getStatus(buddy, status, message);
 	// Tooltip
 	PurplePlugin *prpl = purple_find_prpl(purple_account_get_protocol_id(account));
 	PurplePluginProtocolInfo *prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);
 	bool blocked = false;
 	if (KEYFILE_BOOL("service", "enable_privacy_lists")) {
 		if (prpl_info && prpl_info->tooltip_text) {
 			PurpleNotifyUserInfo *user_info = purple_notify_user_info_new();
 			prpl_info->tooltip_text(buddy, user_info, true);
 			GList *entries = purple_notify_user_info_get_entries(user_info);
 			while (entries) {
 				PurpleNotifyUserInfoEntry *entry = (PurpleNotifyUserInfoEntry *)(entries->data);
 				if (purple_notify_user_info_entry_get_label(entry) && purple_notify_user_info_entry_get_value(entry)) {
 					std::string label = purple_notify_user_info_entry_get_label(entry);
 					if (label == "Blocked" ) {
 						if (std::string(purple_notify_user_info_entry_get_value(entry)) == "Yes") {
 							blocked = true;
 							break;
+						}
+					}
+				}
 				entries = entries->next;
+			}
 			purple_notify_user_info_destroy(user_info);
+		}
 		if (!blocked) {
 			blocked = purple_privacy_check(account, purple_buddy_get_name(buddy)) == false;
+		}
 		else {
 			bool purpleBlocked = purple_privacy_check(account, purple_buddy_get_name(buddy)) == false;
 			if (blocked != purpleBlocked) {
 				purple_privacy_deny(account, purple_buddy_get_name(buddy), FALSE, FALSE);
+			}
+		}
+	}
 	np->handleBuddyChanged(np->m_accounts[account], purple_buddy_get_name(buddy), getAlias(buddy), getGroups(buddy), status, message, getIconHash(buddy),
 		blocked
 	);
+}
 static void buddyListUpdate(PurpleBuddyList *list, PurpleBlistNode *node) {
 	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))
 		return;
 	buddyListNewNode(node);
+}
 static void buddyPrivacyChanged(PurpleBlistNode *node, void *data) {
 	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))
 		return;
 	buddyListUpdate(NULL, node);
+}
 static void NodeRemoved(PurpleBlistNode *node, void *data) {
 	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))
 		return;
 // 	PurpleBuddy *buddy = (PurpleBuddy *) node;
+}
 static PurpleBlistUiOps blistUiOps =
+{
 	NULL,
 	buddyListNewNode,
 	NULL,
 	buddyListUpdate,
 	NULL, //NodeRemoved,
 	NULL,
 	NULL,
 	NULL, // buddyListAddBuddy,
 	NULL,
 	NULL,
 	NULL, //buddyListSaveNode,
 	NULL, //buddyListRemoveNode,
 	NULL, //buddyListSaveAccount,
 	NULL
 };
 static void conv_write_im(PurpleConversation *conv, const char *who, const char *msg, PurpleMessageFlags flags, time_t mtime) {
 	// Don't forwards our own messages.
 	if (flags & PURPLE_MESSAGE_SEND || flags & PURPLE_MESSAGE_SYSTEM)
 		return;
 	PurpleAccount *account = purple_conversation_get_account(conv);
 // 	char *striped = purple_markup_strip_html(message);
 // 	std::string msg = striped;
 // 	g_free(striped);
 	std::string w = purple_normalize(account, who);
 	size_t pos = w.find("/");

include/Swiften/Server/ServerStanzaChannel.cpp

➞

Show inline comments

 /*
  * Copyright (c) 2010 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 #include "Swiften/Server/ServerStanzaChannel.h"
 #include "Swiften/Base/Error.h"
 #include <iostream>
 #include <boost/bind.hpp>
 namespace Swift {
 namespace {
 // 	struct PriorityLessThan {
 // 		bool operator()(const ServerSession* s1, const ServerSession* s2) const {
 // 			return s1->getPriority() < s2->getPriority();
 // 		}
 // 	};
 	struct HasJID {
 		HasJID(const JID& jid) : jid(jid) {}
 		bool operator()(const boost::shared_ptr<ServerFromClientSession> session) const {
 			return session->getRemoteJID().equals(jid, JID::WithResource);
+		}
 		JID jid;
 	};
+}
 void ServerStanzaChannel::addSession(boost::shared_ptr<ServerFromClientSession> session) {
 	sessions[session->getRemoteJID().toBare().toString()].push_back(session);
 	session->onSessionFinished.connect(boost::bind(&ServerStanzaChannel::handleSessionFinished, this, _1, session));
 	session->onElementReceived.connect(boost::bind(&ServerStanzaChannel::handleElement, this, _1, session));
 	session->onDataRead.connect(boost::bind(&ServerStanzaChannel::handleDataRead, this, _1, session));
+}
 void ServerStanzaChannel::removeSession(boost::shared_ptr<ServerFromClientSession> session) {
 	session->onSessionFinished.disconnect(boost::bind(&ServerStanzaChannel::handleSessionFinished, this, _1, session));
 	session->onElementReceived.disconnect(boost::bind(&ServerStanzaChannel::handleElement, this, _1, session));
 	session->onDataRead.disconnect(boost::bind(&ServerStanzaChannel::handleDataRead, this, _1, session));
 	std::list<boost::shared_ptr<ServerFromClientSession> > &lst = sessions[session->getRemoteJID().toBare().toString()];
 	lst.erase(std::remove(lst.begin(), lst.end(), session), lst.end());
+}
 void ServerStanzaChannel::sendIQ(boost::shared_ptr<IQ> iq) {
 	send(iq);
+}
 void ServerStanzaChannel::sendMessage(boost::shared_ptr<Message> message) {
 	send(message);
+}
 void ServerStanzaChannel::sendPresence(boost::shared_ptr<Presence> presence) {
 	send(presence);
+}
 void ServerStanzaChannel::handleDataRead(const SafeByteArray &data, const boost::shared_ptr<ServerFromClientSession> &session) {
 	if (safeByteArrayToString(data).find("</stream:stream>") != std::string::npos) {
 		Swift::Presence::ref presence = Swift::Presence::create();
 		presence->setFrom(session->getRemoteJID());
 		presence->setType(Swift::Presence::Unavailable);
 		onPresenceReceived(presence);
+	}
+}
 void ServerStanzaChannel::finishSession(const JID& to, boost::shared_ptr<Element> element, bool last) {
 	std::vector<boost::shared_ptr<ServerFromClientSession> > candidateSessions;
 	for (std::list<boost::shared_ptr<ServerFromClientSession> >::const_iterator i = sessions[to.toBare().toString()].begin(); i != sessions[to.toBare().toString()].end(); ++i) {
 		candidateSessions.push_back(*i);
+	}
 	for (std::vector<boost::shared_ptr<ServerFromClientSession> >::const_iterator i = candidateSessions.begin(); i != candidateSessions.end(); ++i) {
 		removeSession(*i);
 		if (element) {
 			(*i)->sendElement(element);
+		}
 		if (last && (*i)->getRemoteJID().isValid()) {
 			Swift::Presence::ref presence = Swift::Presence::create();
 			presence->setFrom((*i)->getRemoteJID());
 			presence->setType(Swift::Presence::Unavailable);
 			onPresenceReceived(presence);
+		}
 		(*i)->finishSession();
 // 		std::cout << "FINISH SESSION " << sessions[to.toBare().toString()].size() << "\n";
 		if (last) {
 			break;
+		}
+	}
+}
 std::string ServerStanzaChannel::getNewIQID() {
 	return idGenerator.generateID();
+}
 void ServerStanzaChannel::send(boost::shared_ptr<Stanza> stanza) {
 	JID to = stanza->getTo();
 	assert(to.isValid());
 	// For a full JID, first try to route to a session with the full JID
 	if (!to.isBare()) {
 		std::list<boost::shared_ptr<ServerFromClientSession> >::const_iterator i = std::find_if(sessions[stanza->getTo().toBare().toString()].begin(), sessions[stanza->getTo().toBare().toString()].end(), HasJID(to));
 		if (i != sessions[stanza->getTo().toBare().toString()].end()) {
 			(*i)->sendElement(stanza);
 			return;
+		}
+	}
 	// Look for candidate sessions
 	to = to.toBare();
 	std::vector<boost::shared_ptr<ServerFromClientSession> > candidateSessions;
 	for (std::list<boost::shared_ptr<ServerFromClientSession> >::const_iterator i = sessions[stanza->getTo().toBare().toString()].begin(); i != sessions[stanza->getTo().toBare().toString()].end(); ++i) {
 		if ((*i)->getRemoteJID().equals(to, JID::WithoutResource)) {
 			candidateSessions.push_back(*i);
 			(*i)->sendElement(stanza);
+		}
+	}
 	if (candidateSessions.empty()) {
 		return;
+	}
 	// Find the session with the highest priority
 // 	std::vector<ServerSession*>::const_iterator i = std::max_element(sessions.begin(), sessions.end(), PriorityLessThan());
 // 	(*i)->sendStanza(stanza);
 	return;
+}
 void ServerStanzaChannel::handleSessionFinished(const boost::optional<Session::SessionError>&, const boost::shared_ptr<ServerFromClientSession>& session) {
 	removeSession(session);
 // 	if (!session->initiatedFinish()) {
 		Swift::Presence::ref presence = Swift::Presence::create();
 		presence->setFrom(session->getRemoteJID());
 		presence->setType(Swift::Presence::Unavailable);
 		onPresenceReceived(presence);
 // 	}
+}
 void ServerStanzaChannel::handleElement(boost::shared_ptr<Element> element, const boost::shared_ptr<ServerFromClientSession>& session) {
 	boost::shared_ptr<Stanza> stanza = boost::dynamic_pointer_cast<Stanza>(element);
 	if (!stanza) {
 		return;
+	}
 	stanza->setFrom(session->getRemoteJID());
 	if (!stanza->getFrom().isValid())
 		return;
 	boost::shared_ptr<Message> message = boost::dynamic_pointer_cast<Message>(stanza);
 	if (message) {
 		onMessageReceived(message);
 		return;
+	}
 	boost::shared_ptr<Presence> presence = boost::dynamic_pointer_cast<Presence>(stanza);
 	if (presence) {
 		onPresenceReceived(presence);
 		return;

include/Swiften/Server/ServerStanzaChannel.h

➞

Show inline comments

 /*
  * Copyright (c) 2010 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 #pragma once
 #include <boost/shared_ptr.hpp>
 #include "Swiften/Base/IDGenerator.h"
 #include "Swiften/Server/ServerFromClientSession.h"
 #include "Swiften/Client/StanzaChannel.h"
 #include "Swiften/Elements/Message.h"
 #include "Swiften/Elements/IQ.h"
 #include "Swiften/Elements/Presence.h"
 namespace Swift {
 	class Error;
 	class ServerStanzaChannel : public StanzaChannel {
 		public:
 			void addSession(boost::shared_ptr<ServerFromClientSession> session);
 			void removeSession(boost::shared_ptr<ServerFromClientSession> session);
 			void sendIQ(boost::shared_ptr<IQ> iq);
 			void sendMessage(boost::shared_ptr<Message> message);
 			void sendPresence(boost::shared_ptr<Presence> presence);
 			void finishSession(const JID& to, boost::shared_ptr<Element> element, bool last = false);
 			bool getStreamManagementEnabled() const {
 				return false;
+			}
 			bool isAvailable() const {
 				return true;
+			}
 		private:
 			std::string getNewIQID();
 			void send(boost::shared_ptr<Stanza> stanza);
 			void handleSessionFinished(const boost::optional<Session::SessionError>&, const boost::shared_ptr<ServerFromClientSession> &session);
 			void handleElement(boost::shared_ptr<Element> element, const boost::shared_ptr<ServerFromClientSession> &session);
 			void handleDataRead(const SafeByteArray &data, const boost::shared_ptr<ServerFromClientSession> &session);
 			void handleSessionInitialized();
 		private:
 			IDGenerator idGenerator;
 			// [JID][resources][ServerFromClientSession]
 			std::map<std::string, std::list<boost::shared_ptr<ServerFromClientSession> > > sessions;
 	};
+}

include/transport/pqxxbackend.h

➞

Show inline comments

@@ @@ -4,105 +4,106 @@ @@
  * 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
  */
 #pragma once
 #ifdef WITH_PQXX
 #include <string>
 #include <map>
 #include "Swiften/Swiften.h"
 #include "transport/storagebackend.h"
 #include "transport/config.h"
 #include <pqxx/pqxx>
 namespace Transport {
 /// Used to store transport data into SQLite3 database.
 class PQXXBackend : public StorageBackend
+{
 	public:
 		/// Creates new PQXXBackend instance.
 		/// \param config cofiguration, this class uses following Config values:
 		/// 	- database.database - path to SQLite3 database file, database file is created automatically
 		/// 	- service.prefix - prefix for tables created by createDatabase method
 		PQXXBackend(Config *config);
 		/// Destructor.
 		~PQXXBackend();
 		/// Connects to the database and creates it if it's needed. This method call createDatabase() function
 		/// automatically.
 		/// \return true if database is opened successfully.
 		bool connect();
 		void disconnect();
 		/// Creates database structure.
 		/// \see connect()
 		/// \return true if database structure has been created successfully. Note that it returns True also if database structure
 		/// already exists.
 		bool createDatabase();
 		/// Stores user into database.
 		/// \param user user struct containing all information about user which have to be stored
 		void setUser(const UserInfo &user);
 		/// Gets user data from database and stores them into user reference.
 		/// \param barejid barejid of user
 		/// \param user UserInfo object where user data will be stored
 		/// \return true if user has been found in database
 		bool getUser(const std::string &barejid, UserInfo &user);
 		/// Changes users online state variable in database.
 		/// \param id id of user - UserInfo.id
 		/// \param online online state
 		void setUserOnline(long id, bool online);
 		/// Removes user and all connected data from database.
 		/// \param id id of user - UserInfo.id
 		/// \return true if user has been found in database and removed
 		bool removeUser(long id);
 		/// Returns JIDs of all buddies in user's roster.
 		/// \param id id of user - UserInfo.id
 		/// \param roster string list used to store user's roster
 		/// \return true if user has been found in database and roster has been fetched
 		bool getBuddies(long id, std::list<BuddyInfo> &roster);
 		bool getOnlineUsers(std::vector<std::string> &users);
 		long addBuddy(long userId, const BuddyInfo &buddyInfo);
 		void updateBuddy(long userId, const BuddyInfo &buddyInfo);
 		void removeBuddy(long id) {}
 		void getUserSetting(long userId, const std::string &variable, int &type, std::string &value);
 		void updateUserSetting(long userId, const std::string &variable, const std::string &value);
 		void beginTransaction();
 		void commitTransaction();
 	private:
 		bool exec(const std::string &query, bool show_error = true);
 		bool exec(pqxx::work &txn, const std::string &query, bool show_error = true);
 		Config *m_config;
 		std::string m_prefix;
 		pqxx::connection *m_conn;
 };
+}
 #endif

spectrum/src/main.cpp

➞

Show inline comments

@@ @@ -303,137 +303,137 @@ int main(int argc, char **argv) @@
 #ifndef WIN32
 	if (!CONFIG_STRING(&config, "service.group").empty() ||!CONFIG_STRING(&config, "service.user").empty() ) {
 		struct rlimit limit;
 		getrlimit(RLIMIT_CORE, &limit);
 		if (!CONFIG_STRING(&config, "service.group").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";
 				return 1;
+			}
 			if (((setgid(gr->gr_gid)) != 0) || (initgroups(CONFIG_STRING(&config, "service.user").c_str(), gr->gr_gid) != 0)) {
 				std::cerr << "Failed to set service.group name " << CONFIG_STRING(&config, "service.group") << " - " << gr->gr_gid << ":" << strerror(errno) << "\n";
 				return 1;
+			}
+		}
 		if (!CONFIG_STRING(&config, "service.user").empty()) {
 			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";
 				return 1;
+			}
 			if ((setuid(pw->pw_uid)) != 0) {
 				std::cerr << "Failed to set service.user name " << CONFIG_STRING(&config, "service.user") << " - " << pw->pw_uid << ":" << strerror(errno) << "\n";
 				return 1;
+			}
+		}
 		setrlimit(RLIMIT_CORE, &limit);
+	}
 	struct rlimit limit;
 	limit.rlim_max = RLIM_INFINITY;
 	limit.rlim_cur = RLIM_INFINITY;
 	setrlimit(RLIMIT_CORE, &limit);
 #endif
 	Swift::SimpleEventLoop eventLoop;
 	Swift::BoostNetworkFactories *factories = new Swift::BoostNetworkFactories(&eventLoop);
 	UserRegistry userRegistry(&config, factories);
 	Component transport(&eventLoop, factories, &config, NULL, &userRegistry);
 	component_ = &transport;
 // 	Logger logger(&transport);
 	StorageBackend *storageBackend = NULL;
 #ifdef WITH_SQLITE
 	if (CONFIG_STRING(&config, "database.type") == "sqlite3") {
 		storageBackend = new SQLite3Backend(&config);
 		if (!storageBackend->connect()) {
 			std::cerr << "Can't connect to database. Check the log to find out the reason.\n";
 			return -1;
+		}
+	}
 #else
 	if (CONFIG_STRING(&config, "database.type") == "sqlite3") {
 		std::cerr << "Spectrum2 is not compiled with mysql backend.\n";
 		return -2;
+	}
 #endif
 #ifdef WITH_MYSQL
 	if (CONFIG_STRING(&config, "database.type") == "mysql") {
 		storageBackend = new MySQLBackend(&config);
 		if (!storageBackend->connect()) {
 			std::cerr << "Can't connect to database. Check the log to find out the reason.\n";
 			return -1;
+		}
+	}
 #else
 	if (CONFIG_STRING(&config, "database.type") == "mysql") {
 		std::cerr << "Spectrum2 is not compiled with mysql backend.\n";
 		return -2;
+	}
 #endif
 #ifdef WITH_PQXX
 	if (CONFIG_STRING(&config, "database.type") == "pqxx") {
 		storageBackend = new PQXXBackend(&config);
 		if (!storageBackend->connect()) {
 			std::cerr << "Can't connect to database. Check the log to find out the reason.\n";
 			return -1;
+		}
+	}
 #else
 	if (CONFIG_STRING(&config, "database.type") == "pqxx") {
 		std::cerr << "Spectrum2 is not compiled with pqxx backend.\n";
 		return -2;
+	}
 #endif
 	if (CONFIG_STRING(&config, "database.type") != "mysql" && CONFIG_STRING(&config, "database.type") != "sqlite3"
 		&& CONFIG_STRING(&config, "database.type") != "pqxx") {
+		&& CONFIG_STRING(&config, "database.type") != "pqxx" && CONFIG_STRING(&config, "database.type") != "none") {
 		std::cerr << "Unknown storage backend " << CONFIG_STRING(&config, "database.type") << "\n";
 		return -2;
+	}
 	UserManager userManager(&transport, &userRegistry, storageBackend);
 	userManager_ = &userManager;
 	UserRegistration *userRegistration = NULL;
 	UsersReconnecter *usersReconnecter = NULL;
 	if (storageBackend) {
 		userRegistration = new UserRegistration(&transport, &userManager, storageBackend);
 		userRegistration->start();
 		usersReconnecter = new UsersReconnecter(&transport, storageBackend);
+	}
 	FileTransferManager ftManager(&transport, &userManager);
 	NetworkPluginServer plugin(&transport, &config, &userManager, &ftManager);
 	AdminInterface adminInterface(&transport, &userManager, &plugin, storageBackend);
 	StatsResponder statsResponder(&transport, &userManager, &plugin, storageBackend);
 	statsResponder.start();
 	eventLoop_ = &eventLoop;
 	eventLoop.run();
 	if (userRegistration) {
 		userRegistration->stop();
 		delete userRegistration;
+	}
 	if (usersReconnecter) {
 		delete usersReconnecter;
+	}
 	delete storageBackend;
 	delete factories;
+}

src/pqxxbackend.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
  */
 #ifdef WITH_PQXX
 #include "transport/pqxxbackend.h"
 #include "transport/util.h"
 #include <boost/bind.hpp>
 #include "log4cxx/logger.h"
 using namespace log4cxx;
 using namespace boost;
 namespace Transport {
 static LoggerPtr logger = Logger::getLogger("PQXXBackend");
 PQXXBackend::PQXXBackend(Config *config) {
 	m_config = config;
 	m_prefix = CONFIG_STRING(m_config, "database.prefix");
+}
 PQXXBackend::~PQXXBackend(){
 	disconnect();
+}
 void PQXXBackend::disconnect() {
 	LOG4CXX_INFO(logger, "Disconnecting");
 	delete m_conn;
+}
 bool PQXXBackend::connect() {
 	LOG4CXX_INFO(logger, "Connecting PostgreSQL server " << CONFIG_STRING(m_config, "database.server") << ", user " <<
 		CONFIG_STRING(m_config, "database.user") << ", database " << CONFIG_STRING(m_config, "database.database") <<
 		", port " << CONFIG_INT(m_config, "database.port")
 	);
 	std::string str = "dbname=";
 	str += CONFIG_STRING(m_config, "database.database") + " ";
 	str += "user=" + CONFIG_STRING(m_config, "database.user") + " ";
 	m_conn = new pqxx::connection(str);
 	createDatabase();
 	return true;
+}
 bool PQXXBackend::createDatabase() {
 	int exist = exec("SELECT * FROM " + m_prefix + "buddies_settings LIMIT 1;", false);
 	if (!exist) {
 		exec("CREATE TABLE " + m_prefix + "buddies_settings ("
 				"user_id integer NOT NULL,"
 				"buddy_id integer NOT NULL,"
 				"var varchar(50) NOT NULL,"
 				"type smallint NOT NULL,"
 				"value varchar(255) NOT NULL,"
 				"PRIMARY KEY (buddy_id,var)"
 			");");
 		exec("CREATE TYPE Subscription AS ENUM ('to','from','both','ask','none');");
-		exec("CREATE TABLE IF NOT EXISTS " + m_prefix + "buddies ("
 		exec("CREATE TABLE " + m_prefix + "buddies ("
 							"id SERIAL,"
 							"user_id integer NOT NULL,"
 							"uin varchar(255) NOT NULL,"
 							"subscription Subscription NOT NULL,"
 							"nickname varchar(255) NOT NULL,"
 							"groups varchar(255) NOT NULL,"
 							"flags smallint NOT NULL DEFAULT '0',"
 							"PRIMARY KEY (id),"
 							"UNIQUE (user_id,uin)"
 						");");
-		exec("CREATE TABLE IF NOT EXISTS " + m_prefix + "users ("
 		exec("CREATE TABLE " + m_prefix + "users ("
 				"id SERIAL,"
 				"jid varchar(255) NOT NULL,"
 				"uin varchar(4095) NOT NULL,"
 				"password varchar(255) NOT NULL,"
 				"language varchar(25) NOT NULL,"
 				"encoding varchar(50) NOT NULL default 'utf8',"
 				"last_login timestamp,"
 				"vip boolean NOT NULL  default '0',"
 				"online boolean NOT NULL  default '0',"
 				"PRIMARY KEY (id),"
 				"UNIQUE (jid)"
 			");");
-		exec("CREATE TABLE IF NOT EXISTS " + m_prefix + "users_settings ("
 		exec("CREATE TABLE " + m_prefix + "users_settings ("
 				"user_id integer NOT NULL,"
 				"var varchar(50) NOT NULL,"
 				"type smallint NOT NULL,"
 				"value varchar(255) NOT NULL,"
 				"PRIMARY KEY (user_id,var)"
 			");");
-		exec("CREATE TABLE IF NOT EXISTS " + m_prefix + "db_version ("
 		exec("CREATE TABLE " + m_prefix + "db_version ("
 				"ver integer NOT NULL default '1',"
 				"UNIQUE (ver)"
 			");");
 // 		exec("INSERT INTO db_version (ver) VALUES ('2');");
+	}
 	return true;
+}
 bool PQXXBackend::exec(const std::string &query, bool show_error) {
 	pqxx::work txn(*m_conn);
 	return exec(txn, query, show_error);
+}
 bool PQXXBackend::exec(pqxx::work &txn, const std::string &query, bool show_error) {
 	try {
 		txn.exec(query);
 		txn.commit();
+	}
 	catch (std::exception& e) {
 		if (show_error)
 			LOG4CXX_ERROR(logger, e.what());
 		return false;
+	}
 	return true;
+}
 void PQXXBackend::setUser(const UserInfo &user) {
 //	std::string encrypted = user.password;
 //	if (!CONFIG_STRING(m_config, "database.encryption_key").empty()) {
 //		encrypted = Util::encryptPassword(encrypted, CONFIG_STRING(m_config, "database.encryption_key"));
 //	}
 //	*m_setUser << user.jid << user.uin << encrypted << user.language << user.encoding << user.vip << user.uin << encrypted;
 //	EXEC(m_setUser, setUser(user));
 	std::string encrypted = user.password;
 	if (!CONFIG_STRING(m_config, "database.encryption_key").empty()) {
 		encrypted = Util::encryptPassword(encrypted, CONFIG_STRING(m_config, "database.encryption_key"));
+	}
 	pqxx::work txn(*m_conn);
 	exec(txn, "UPDATE " + m_prefix + "users SET uin=" + txn.quote(user.uin) + ", password=" + txn.quote(encrypted) + ";"
 		"INSERT INTO " + m_prefix + "users (jid, uin, password, language, encoding, last_login, vip) VALUES "
 		 "(" + txn.quote(user.jid) + ","
 		+ txn.quote(user.uin) + ","
 		+ txn.quote(encrypted) + ","
 		+ txn.quote(user.language) + ","
 		+ txn.quote(user.encoding) + ","
 		+ "NOW(),"
 		+ txn.quote(user.vip) +")");
+}
 bool PQXXBackend::getUser(const std::string &barejid, UserInfo &user) {
 //	*m_getUser << barejid;
 //	EXEC(m_getUser, getUser(barejid, user));
 //	if (!exec_ok)
 //		return false;
 	try {
 		pqxx::work txn(*m_conn);
 	int ret = false;
 //	while (m_getUser->fetch() == 0) {
 //		ret = true;
 //		*m_getUser >> user.id >> user.jid >> user.uin >> user.password >> user.encoding >> user.language >> user.vip;
 		pqxx::result r = txn.exec("SELECT id, jid, uin, password, encoding, language, vip FROM " + m_prefix + "users WHERE jid="
 			+ txn.quote(barejid));
 //		if (!CONFIG_STRING(m_config, "database.encryption_key").empty()) {
 //			user.password = Util::decryptPassword(user.password, CONFIG_STRING(m_config, "database.encryption_key"));
 //		}
 //	}
 		if (r.size() == 0) {
 			return false;
+		}
 	return ret;
 		user.id = r[0][0].as<int>();
 		user.jid = r[0][1].as<std::string>();
 		user.uin = r[0][2].as<std::string>();
 		user.password = r[0][3].as<std::string>();
 		user.encoding = r[0][4].as<std::string>();
 		user.language = r[0][5].as<std::string>();
 		user.vip = r[0][6].as<bool>();
+	}
 	catch (std::exception& e) {
 		LOG4CXX_ERROR(logger, e.what());
 		return false;
+	}
 	return true;
+}
 void PQXXBackend::setUserOnline(long id, bool online) {
 //	*m_setUserOnline << online << id;
 //	EXEC(m_setUserOnline, setUserOnline(id, online));
 	try {
 		pqxx::work txn(*m_conn);
 		exec(txn, "UPDATE " + m_prefix + "users SET online=" + txn.quote(online) + ", last_login=NOW() WHERE id=" + txn.quote(id));
+	}
 	catch (std::exception& e) {
 		LOG4CXX_ERROR(logger, e.what());
+	}
+}
 bool PQXXBackend::getOnlineUsers(std::vector<std::string> &users) {
 //	EXEC(m_getOnlineUsers, getOnlineUsers(users));
 //	if (!exec_ok)
 //		return false;
 	try {
 		pqxx::work txn(*m_conn);
 		pqxx::result r = txn.exec("SELECT jid FROM " + m_prefix + "users WHERE online=1");
 //	std::string jid;
 //	while (m_getOnlineUsers->fetch() == 0) {
 //		*m_getOnlineUsers >> jid;
 //		users.push_back(jid);
 //	}
 		for (pqxx::result::const_iterator it = r.begin(); it != r.end(); it++)  {
 			users.push_back((*it)[0].as<std::string>());
+		}
+	}
 	catch (std::exception& e) {
 		LOG4CXX_ERROR(logger, e.what());
 		return false;
+	}
 	return true;
+}
 long PQXXBackend::addBuddy(long userId, const BuddyInfo &buddyInfo) {
 // 	"INSERT INTO " + m_prefix + "buddies (user_id, uin, subscription, groups, nickname, flags) VALUES (?, ?, ?, ?, ?, ?)"
 //	std::string groups = Util::serializeGroups(buddyInfo.groups);
 //	*m_addBuddy << userId << buddyInfo.legacyName << buddyInfo.subscription;
 //	*m_addBuddy << groups;
 //	*m_addBuddy << buddyInfo.alias << buddyInfo.flags;
 //	EXEC(m_addBuddy, addBuddy(userId, buddyInfo));
 //	long id = (long) mysql_insert_id(&m_conn);
 // 	INSERT OR REPLACE INTO " + m_prefix + "buddies_settings (user_id, buddy_id, var, type, value) VALUES (?, ?, ?, ?, ?)
 //	if (!buddyInfo.settings.find("icon_hash")->second.s.empty()) {
 //		*m_updateBuddySetting << userId << id << buddyInfo.settings.find("icon_hash")->first << (int) TYPE_STRING << buddyInfo.settings.find("icon_hash")->second.s << buddyInfo.settings.find("icon_hash")->second.s;
 //		EXEC(m_updateBuddySetting, addBuddy(userId, buddyInfo));
 //	}
 	return 0;
+}
 void PQXXBackend::updateBuddy(long userId, const BuddyInfo &buddyInfo) {
 // 	"UPDATE " + m_prefix + "buddies SET groups=?, nickname=?, flags=?, subscription=? WHERE user_id=? AND uin=?"
 //	std::string groups = Util::serializeGroups(buddyInfo.groups);
 //	*m_updateBuddy << groups;
 //	*m_updateBuddy << buddyInfo.alias << buddyInfo.flags << buddyInfo.subscription;
 //	*m_updateBuddy << userId << buddyInfo.legacyName;
 //	EXEC(m_updateBuddy, updateBuddy(userId, buddyInfo));
+}
 bool PQXXBackend::getBuddies(long id, std::list<BuddyInfo> &roster) {
 //	SELECT id, uin, subscription, nickname, groups, flags FROM " + m_prefix + "buddies WHERE user_id=? ORDER BY id ASC
 //	*m_getBuddies << id;
 // 	"SELECT buddy_id, type, var, value FROM " + m_prefix + "buddies_settings WHERE user_id=? ORDER BY buddy_id ASC"
 //	*m_getBuddiesSettings << id;
 //	SettingVariableInfo var;
 //	long buddy_id = -1;
 //	std::string key;
 //	EXEC(m_getBuddies, getBuddies(id, roster));
 //	if (!exec_ok)
 //		return false;
 //	while (m_getBuddies->fetch() == 0) {
 //		BuddyInfo b;
 //		std::string group;
 //		*m_getBuddies >> b.id >> b.legacyName >> b.subscription >> b.alias >> group >> b.flags;
 //		if (!group.empty()) {
 //			b.groups = Util::deserializeGroups(group);
 //		}
 //		roster.push_back(b);
 //	}
 //	EXEC(m_getBuddiesSettings, getBuddies(id, roster));
 //	if (!exec_ok)
 //		return false;
 //	BOOST_FOREACH(BuddyInfo &b, roster) {
 //		if (buddy_id == b.id) {
 //// 			std::cout << "Adding buddy info setting " << key << "\n";
 //			b.settings[key] = var;
 //			buddy_id = -1;
 //		}
 //		while(buddy_id == -1 && m_getBuddiesSettings->fetch() == 0) {
 //			std::string val;
 //			*m_getBuddiesSettings >> buddy_id >> var.type >> key >> val;
 //			switch (var.type) {
 //				case TYPE_BOOLEAN:
 //					var.b = atoi(val.c_str());
 //					break;
 //				case TYPE_STRING:
 //					var.s = val;
 //					break;
 //				default:
 //					if (buddy_id == b.id) {
 //						buddy_id = -1;
 //					}
 //					continue;
 //					break;
 //			}
 //			if (buddy_id == b.id) {
 //// 				std::cout << "Adding buddy info setting " << key << "=" << val << "\n";
 //				b.settings[key] = var;
 //				buddy_id = -1;
 //			}

0 comments (0 inline, 0 general)