libtransport.git Changeset - feca4f35ee86

Changeset - feca4f35ee86

Parent rev.

Child rev.

[Not reviewed]

Merge

0 5 0

HanzZ - 13 years ago 2012-10-14 12:05:43
hanzz.k@gmail.com

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

4 files changed with 16 insertions and 6 deletions:

backends/libcommuni/ircnetworkplugin.cpp

backends/libcommuni/session.cpp

spectrum/src/sample2.cfg

src/storagebackend.cpp

0 comments (0 inline, 0 general)

backends/libcommuni/ircnetworkplugin.cpp

➞

Show inline comments

 #include "ircnetworkplugin.h"
 #include <IrcCommand>
 #include <IrcMessage>
 #include "transport/logging.h"
 DEFINE_LOGGER(logger, "IRCNetworkPlugin");
 #define FROM_UTF8(WHAT) QString::fromUtf8((WHAT).c_str(), (WHAT).size())
 #define TO_UTF8(WHAT) std::string((WHAT).toUtf8().data(), (WHAT).toUtf8().size())
 IRCNetworkPlugin::IRCNetworkPlugin(Config *config, Swift::QtEventLoop *loop, const std::string &host, int port) {
 	this->config = config;
 	m_currentServer = 0;
 	m_socket = new QTcpSocket();
 	m_socket->connectToHost(FROM_UTF8(host), port);
 	connect(m_socket, SIGNAL(readyRead()), this, SLOT(readData()));
 	std::string server = CONFIG_STRING_DEFAULTED(config, "service.irc_server", "");
 	if (!server.empty()) {
 		m_servers.push_back(server);
+	}
 	else {
 		std::list<std::string> list;
 		list = CONFIG_LIST_DEFAULTED(config, "service.irc_server", list);
 		m_servers.insert(m_servers.begin(), list.begin(), list.end());
+	}
 	if (CONFIG_HAS_KEY(config, "service.irc_identify")) {
 		m_identify = CONFIG_STRING(config, "service.irc_identify");
+	}
 	else {
 		m_identify = "NickServ identify $name $password";
+	}
+}
 void IRCNetworkPlugin::tryNextServer() {
 	if (!m_servers.empty()) {
 		int nextServer = (m_currentServer + 1) % m_servers.size();
 		LOG4CXX_INFO(logger, "Server " << m_servers[m_currentServer] << " disconnected user. Next server to try will be " << m_servers[nextServer]);
 		m_currentServer = nextServer;
+	}
+}
 void IRCNetworkPlugin::readData() {
 	size_t availableBytes = m_socket->bytesAvailable();
 	if (availableBytes == 0)
 		return;
 	std::string d = std::string(m_socket->readAll().data(), availableBytes);
 	handleDataRead(d);
+}
 void IRCNetworkPlugin::sendData(const std::string &string) {
 	m_socket->write(string.c_str(), string.size());
+}
 MyIrcSession *IRCNetworkPlugin::createSession(const std::string &user, const std::string &hostname, const std::string &nickname, const std::string &password, const std::string &suffix) {
 	MyIrcSession *session = new MyIrcSession(user, this, suffix);
 	session->setUserName(FROM_UTF8(nickname));
 	session->setNickName(FROM_UTF8(nickname));
 	session->setRealName(FROM_UTF8(nickname));
 	session->setHost(FROM_UTF8(hostname));
 	session->setPort(6667);
 	session->setEncoding( "utf-8" );
 	if (!password.empty()) {
 		std::string identify = m_identify;
 		boost::replace_all(identify, "$password", password);
 		boost::replace_all(identify, "$name", nickname);
 		session->setIdentify(identify);
+	}
 	LOG4CXX_INFO(logger, user << ": Connecting " << hostname << " as " << nickname << ", suffix=" << suffix);
 	session->open();
 	return session;
+}
 void IRCNetworkPlugin::handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) {
 	if (!m_servers.empty()) {
 		// legacy name is users nickname
 		if (m_sessions[user] != NULL) {
 			LOG4CXX_WARN(logger, user << ": Already logged in.");
 			return;
+		}
 		m_sessions[user] = createSession(user, m_servers[m_currentServer], legacyName, password, "");
+	}
 	else {
 		// We are waiting for first room join to connect user to IRC network, because we don't know which
 		// network he choose...
 		LOG4CXX_INFO(logger, user << ": Ready for connections");
 		handleConnected(user);
+	}
+}
 void IRCNetworkPlugin::handleLogoutRequest(const std::string &user, const std::string &legacyName) {
 	if (m_sessions[user] == NULL) {
 		LOG4CXX_WARN(logger, user << ": Already disconnected.");
 		return;
+	}
 	LOG4CXX_INFO(logger, user << ": Disconnecting.");
 	m_sessions[user]->close();
 	m_sessions[user]->deleteLater();
 	m_sessions.erase(user);
+}
 std::string IRCNetworkPlugin::getSessionName(const std::string &user, const std::string &legacyName) {
 	std::string u = user;
 	if (!CONFIG_BOOL(config, "service.server_mode") && m_servers.empty()) {
 		u = user + legacyName.substr(legacyName.find("@") + 1);
 		if (u.find("/") != std::string::npos) {
 			u = u.substr(0, u.find("/"));
+		}
+	}
 	return u;
+}
 std::string IRCNetworkPlugin::getTargetName(const std::string &legacyName) {
 	std::string r = legacyName;
 // 	if (!CONFIG_BOOL(config, "service.server_mode")) {
 		if (legacyName.find("/") == std::string::npos) {
 			r = legacyName.substr(0, r.find("@"));
+		}
 		else {
 			r = legacyName.substr(legacyName.find("/") + 1);
+		}
 // 	}
 	return r;
+}
 void IRCNetworkPlugin::handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &/*xhtml*/) {
 	std::string session = getSessionName(user, legacyName);
 	if (m_sessions[session] == NULL) {
 		LOG4CXX_WARN(logger, user << ": Session name: " << session << ", No session for user");
 		return;
+	}
 	std::string target = getTargetName(legacyName);
 	LOG4CXX_INFO(logger, user << ": Session name: " << session << ", message to " << target);
 	m_sessions[session]->sendCommand(IrcCommand::createMessage(FROM_UTF8(target), FROM_UTF8(message)));
 	if (message.find("/me") == 0) {
 		m_sessions[session]->sendCommand(IrcCommand::createCtcpAction(FROM_UTF8(target), FROM_UTF8(message.substr(4))));
+	}
 	else {
 		m_sessions[session]->sendCommand(IrcCommand::createMessage(FROM_UTF8(target), FROM_UTF8(message)));
+	}
 	if (target.find("#") == 0) {
 		handleMessage(user, legacyName, message, TO_UTF8(m_sessions[session]->nickName()));
+	}
+}
 void IRCNetworkPlugin::handleRoomSubjectChangedRequest(const std::string &user, const std::string &room, const std::string &message) {
 	std::string session = getSessionName(user, room);
 	if (m_sessions[session] == NULL) {
 		LOG4CXX_WARN(logger, user << ": Session name: " << session << ", No session for user");
 		return;
+	}
 	std::string target = getTargetName(room);
 	m_sessions[session]->sendCommand(IrcCommand::createTopic(FROM_UTF8(target), FROM_UTF8(message)));
+}
 void IRCNetworkPlugin::handleJoinRoomRequest(const std::string &user, const std::string &room, const std::string &nickname, const std::string &password) {
 	std::string session = getSessionName(user, room);
 	std::string target = getTargetName(room);
 	LOG4CXX_INFO(logger, user << ": Session name: " << session << ", Joining room " << target);
 	if (m_sessions[session] == NULL) {
 		if (m_servers.empty()) {
 			// in gateway mode we want to login this user to network according to legacyName
 			if (room.find("@") != std::string::npos) {
 				// suffix is %irc.freenode.net to let MyIrcSession return #room%irc.freenode.net
 				m_sessions[session] = createSession(user, room.substr(room.find("@") + 1), nickname, "", room.substr(room.find("@")));
+			}
 			else {
 				LOG4CXX_WARN(logger, user << ": There's no proper server defined in room to which this user wants to join: " << room);
 				return;
+			}
+		}
 		else {
 			LOG4CXX_WARN(logger, user << ": Join room requested for unconnected user");
 			return;
+		}
+	}
 	m_sessions[session]->addAutoJoinChannel(target, password);
 	m_sessions[session]->sendCommand(IrcCommand::createJoin(FROM_UTF8(target), FROM_UTF8(password)));
 	m_sessions[session]->rooms += 1;
 	// update nickname, because we have nickname per session, no nickname per room.
 	handleRoomNicknameChanged(user, target, TO_UTF8(m_sessions[session]->nickName()));
+}
 void IRCNetworkPlugin::handleLeaveRoomRequest(const std::string &user, const std::string &room) {
 	std::string session = getSessionName(user, room);
 	std::string target = getTargetName(room);
 	LOG4CXX_INFO(logger, user << ": Session name: " << session << ", Leaving room " << target);
 	if (m_sessions[session] == NULL)
 		return;
 	m_sessions[session]->sendCommand(IrcCommand::createPart(FROM_UTF8(target)));
 	m_sessions[session]->removeAutoJoinChannel(target);
 	m_sessions[session]->rooms -= 1;
 	if (m_sessions[session]->rooms <= 0 && m_servers.empty()) {
 		LOG4CXX_INFO(logger, user << ": Session name: " << session << ", User is not in any room, disconnecting from network");
 		m_sessions[session]->close();
 		m_sessions[session]->deleteLater();
 		m_sessions.erase(session);
+	}
+}

backends/libcommuni/session.cpp

➞

Show inline comments

 /*
  * Copyright (C) 2008-2009 J-P Nurmi jpnurmi@gmail.com
+ *
  * This example is free, and not covered by LGPL license. There is no
  * restriction applied to their modification, redistribution, using and so on.
  * You can study them, modify them, use them in your own program - either
  * completely or partially. By using it you may give me some credits in your
  * program, but you don't have to.
  */
 #include "session.h"
 #include <QtCore>
 #include <iostream>
 #include <IrcCommand>
 #include <IrcMessage>
 #include "ircnetworkplugin.h"
 #define FROM_UTF8(WHAT) QString::fromUtf8((WHAT).c_str(), (WHAT).size())
 #define TO_UTF8(WHAT) std::string((WHAT).toUtf8().data(), (WHAT).toUtf8().size())
 #include "transport/logging.h"
 DEFINE_LOGGER(logger, "IRCSession");
 MyIrcSession::MyIrcSession(const std::string &user, IRCNetworkPlugin *np, const std::string &suffix, QObject* parent) : IrcSession(parent)
+{
 	this->np = np;
 	this->user = user;
 	this->suffix = suffix;
 	m_connected = false;
 	rooms = 0;
 	connect(this, SIGNAL(disconnected()), SLOT(on_disconnected()));
 	connect(this, SIGNAL(socketError(QAbstractSocket::SocketError)), SLOT(on_socketError(QAbstractSocket::SocketError)));
 	connect(this, SIGNAL(connected()), SLOT(on_connected()));
 	connect(this, SIGNAL(messageReceived(IrcMessage*)), this, SLOT(onMessageReceived(IrcMessage*)));
+}
 void MyIrcSession::on_connected() {
 	m_connected = true;
 	if (suffix.empty()) {
 		np->handleConnected(user);
+	}
 	for(AutoJoinMap::iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {
 		sendCommand(IrcCommand::createJoin(FROM_UTF8(it->second->getChannel()), FROM_UTF8(it->second->getPassword())));
+	}
 	if (getIdentify().find(" ") != std::string::npos) {
 		std::string to = getIdentify().substr(0, getIdentify().find(" "));
 		std::string what = getIdentify().substr(getIdentify().find(" ") + 1);
 		sendCommand(IrcCommand::createMessage(FROM_UTF8(to), FROM_UTF8(what)));
+	}
+}
 void MyIrcSession::on_socketError(QAbstractSocket::SocketError error) {
 	on_disconnected();
+}
 void MyIrcSession::on_disconnected() {
 	if (suffix.empty()) {
 		np->handleDisconnected(user, 0, "");
 		np->tryNextServer();
+	}
 	m_connected = false;
+}
 bool MyIrcSession::correctNickname(std::string &nickname) {
 	bool flags = 0;
 	switch(nickname.at(0)) {
 		case '@': nickname = nickname.substr(1); flags = 1; break;
 		case '+': nickname = nickname.substr(1); break;
 		default: break;
+	}
 	return flags;
+}
 void MyIrcSession::on_joined(IrcMessage *message) {
 	IrcJoinMessage *m = (IrcJoinMessage *) message;
 	bool flags = 0;
 	std::string nickname = TO_UTF8(m->sender().name());
 	flags = correctNickname(nickname);
 	np->handleParticipantChanged(user, nickname, TO_UTF8(m->channel()), (int) flags, pbnetwork::STATUS_ONLINE);
 	LOG4CXX_INFO(logger, user << ": Joined " << TO_UTF8(m->parameters()[0]));
+}
 void MyIrcSession::on_parted(IrcMessage *message) {
 	IrcPartMessage *m = (IrcPartMessage *) message;
 	bool flags = 0;
 	std::string nickname = TO_UTF8(m->sender().name());
 	flags = correctNickname(nickname);
 	LOG4CXX_INFO(logger, user << ": " << nickname << " parted " << TO_UTF8(m->channel()) + suffix);
 	np->handleParticipantChanged(user, nickname, TO_UTF8(m->channel()) + suffix,(int) flags, pbnetwork::STATUS_NONE, TO_UTF8(m->reason()));
+}
 void MyIrcSession::on_quit(IrcMessage *message) {
 	IrcQuitMessage *m = (IrcQuitMessage *) message;
 	for(AutoJoinMap::iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {
 		bool flags = 0;
 		std::string nickname = TO_UTF8(m->sender().name());
 		flags = correctNickname(nickname);
 		LOG4CXX_INFO(logger, user << ": " << nickname << " quit " << it->second->getChannel() + suffix);
 		np->handleParticipantChanged(user, nickname, it->second->getChannel() + suffix,(int) flags, pbnetwork::STATUS_NONE, TO_UTF8(m->reason()));
+	}
+}
 void MyIrcSession::on_nickChanged(IrcMessage *message) {
 	IrcNickMessage *m = (IrcNickMessage *) message;
 	for(AutoJoinMap::iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {
 		std::string nickname = TO_UTF8(m->sender().name());
 		bool flags = m_modes[it->second->getChannel() + nickname];
 		LOG4CXX_INFO(logger, user << ": " << nickname << " changed nickname to " << TO_UTF8(m->nick()));
 		np->handleParticipantChanged(user, nickname, it->second->getChannel() + suffix,(int) flags, pbnetwork::STATUS_ONLINE, "", TO_UTF8(m->nick()));
+	}
+}
 void MyIrcSession::on_modeChanged(IrcMessage *message) {
 	IrcModeMessage *m = (IrcModeMessage *) message;
 	// mode changed: "#testik" "HanzZ" "+o" "hanzz_k"
 	std::string nickname = TO_UTF8(m->argument());
 	std::string mode = TO_UTF8(m->mode());
 	if (nickname.empty())
 		return;
 	LOG4CXX_INFO(logger, user << ": " << nickname << " changed mode to " << mode);
 	for(AutoJoinMap::iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {
 		if (mode == "+o") {
 			m_modes[it->second->getChannel() + nickname] = 1;
+		}
 		else {
 			m_modes[it->second->getChannel() + nickname] = 0;
+		}
 		bool flags = m_modes[it->second->getChannel() + nickname];
 		np->handleParticipantChanged(user, nickname, it->second->getChannel() + suffix,(int) flags, pbnetwork::STATUS_ONLINE, "");
+	}
+}
 void MyIrcSession::on_topicChanged(IrcMessage *message) {
 	IrcTopicMessage *m = (IrcTopicMessage *) message;
 	bool flags = 0;
 	std::string nickname = TO_UTF8(m->sender().name());
 	flags = correctNickname(nickname);
 	LOG4CXX_INFO(logger, user << ": " << nickname << " topic changed to " << TO_UTF8(m->topic()));
 	np->handleSubject(user, TO_UTF8(m->channel()) + suffix, TO_UTF8(m->topic()), nickname);
+}
 void MyIrcSession::on_messageReceived(IrcMessage *message) {
 	IrcPrivateMessage *m = (IrcPrivateMessage *) message;
 	if (m->isRequest()) {
 		QString request = m->message().split(" ", QString::SkipEmptyParts).value(0).toUpper();
 		if (request == "PING" || request == "TIME" || request == "VERSION") {
 			LOG4CXX_INFO(logger, user << ": " << TO_UTF8(request) << " received and has been answered");
 			return;
+		}
+	}
 	QString msg = m->message();
 	if (m->isAction()) {
 		msg = QString("/me ") + msg;
+	}
 	std::string target = TO_UTF8(m->target());
 	LOG4CXX_INFO(logger, user << ": Message from " << target);
 	if (target.find("#") == 0) {
 		bool flags = 0;
 		std::string nickname = TO_UTF8(m->sender().name());
 		flags = correctNickname(nickname);
-		np->handleMessage(user, target + suffix, TO_UTF8(m->message()), nickname);
+		np->handleMessage(user, target + suffix, TO_UTF8(msg), nickname);
+	}
 	else {
 		bool flags = 0;
 		std::string nickname = TO_UTF8(m->sender().name());
 		flags = correctNickname(nickname);
 		LOG4CXX_INFO(logger, nickname + suffix);
-		np->handleMessage(user, nickname + suffix, TO_UTF8(m->message()));
+		np->handleMessage(user, nickname + suffix, TO_UTF8(msg));
+	}
+}
 void MyIrcSession::on_numericMessageReceived(IrcMessage *message) {
 	QString channel;
 	QStringList members;
 	IrcNumericMessage *m = (IrcNumericMessage *) message;
 	switch (m->code()) {
 		case 332:
 			m_topicData = TO_UTF8(m->parameters().value(2));
 			break;
 		case 333:
 			 np->handleSubject(user, TO_UTF8(m->parameters().value(1)) + suffix, m_topicData, TO_UTF8(m->parameters().value(2)));
 			break;
 		case 353:
 			channel = m->parameters().value(2);
 			members = m->parameters().value(3).split(" ");
 			LOG4CXX_INFO(logger, user << ": Received members for " << TO_UTF8(channel) << suffix);
 			for (int i = 0; i < members.size(); i++) {
 				bool flags = 0;
 				std::string nickname = TO_UTF8(members.at(i));
 				flags = correctNickname(nickname);
 				m_modes[TO_UTF8(channel) + nickname] = flags;
 				np->handleParticipantChanged(user, nickname, TO_UTF8(channel) + suffix,(int) flags, pbnetwork::STATUS_ONLINE);
+			}
 			break;
 		case 432:
 			np->handleDisconnected(user, pbnetwork::CONNECTION_ERROR_INVALID_USERNAME, "Erroneous Nickname");
 			break;
 		default:
 			break;
+	}
 	//qDebug() << "numeric message received:" << receiver() << origin << code << params;
+}
 void MyIrcSession::onMessageReceived(IrcMessage *message) {
 	LOG4CXX_INFO(logger, user << ": " << TO_UTF8(message->toString()));
 	switch (message->type()) {
 		case IrcMessage::Join:
 			on_joined(message);
 			break;
 		case IrcMessage::Part:
 			on_parted(message);
 			break;
 		case IrcMessage::Quit:
 			on_quit(message);
 			break;
 		case IrcMessage::Nick:
 			on_nickChanged(message);
 			break;
 		case IrcMessage::Mode:
 			on_modeChanged(message);
 			break;
 		case IrcMessage::Topic:
 			on_topicChanged(message);
 			break;
 		case IrcMessage::Private:
 			on_messageReceived(message);
 			break;
 		case IrcMessage::Numeric:
 			on_numericMessageReceived(message);
 			break;
 		default:break;
+	}
+}

spectrum/src/sample2.cfg

➞

Show inline comments

 [service]
 # 1 if Spectrum should run in server mode.
 server_mode = 1
 # The name of user/group Spectrum runs as.
 #user=spectrum
 #group=spectrum
 # JID of Spectrum instance.
 jid = localhost
 # Password used to connect the XMPP server in gateway mode.
 # In server mode, this option is ignored.
 password = secret
 # XMPP server to which Spectrum connects in gateway mode.
 # In server mode, this option is ignored.
 server = 127.0.0.1
 # XMPP server port.
 port = 5222
 # Interface on which Spectrum listens for backends.
 backend_host = localhost
 # Port on which Spectrum listens for backends.
 # By default Spectrum chooses random backend port and there's
 # no need to change it normally
 #backend_port=10001
 # Full path to PKCS#12 cetficiate used for TLS in server mode.
 #cert=
 # Certificate password if any.
 #cert_password=
 # Number of users per one legacy network backend.
 users_per_backend=10
 # Full path to backend binary.
 backend=/usr/bin/spectrum2_libpurple_backend
-#backend=/usr/bin/spectrum2_libircclient-qt_backend
+#backend=/usr/bin/spectrum2_libcommuni_backend
 # For skype:
 #backend=/usr/bin/xvfb-run -n BACKEND_ID -s "-screen 0 10x10x8" -f /tmp/x-skype-gw /usr/bin/spectrum2_skype_backend
 # Libpurple protocol-id for spectrum_libpurple_backend
 protocol=prpl-jabber
 #protocol=prpl-msn
 #protocol=prpl-icq
 # prpl-any means that user sets his protocol in his JID which has to be
 # in following format: protocol.username@domain.tld
 # So for example: prpl-jabber.hanzz.k%gmail.com@domain.tld
 #protocol=prpl-any
 [identity]
 # Name of Spectrum instance in service discovery
 name=Spectrum Jabber Transport
 # Type of transport ("msn", "icq", "xmpp").
 # Check http://xmpp.org/registrar/disco-categories.html#gateway
 type=xmpp
 # Category of transport, default is "gateway
 #category=gateway
 [logging]
 # log4cxx/log4j logging configuration file in ini format used for main spectrum2 instance.
 config = /etc/spectrum2/logging.cfg
 # log4cxx/log4j logging configuration file in ini format used for backends.
 backend_config = /etc/spectrum2/backend-logging.cfg
 [database]
 # Database backend type
 # "sqlite3", "mysql", "pqxx", or "none" without database backend
 type = none
 # For SQLite3: Full path to database
 # For MySQL and PostgreSQL: name of database
 # default database = /var/lib/spectrum2/$jid/database.sql
 #database = jabber_transport
 # Server.
 #server = localhost
 # Port.
 #port = 0
 # User.
 #user = spectrum
 # Paasword.
 #password = secret
 # Prefix used for tables
 #prefix = jabber_
 [registration]
 # Enable public registrations
 enable_public_registration=1
 # Text to display upon user registration form
 #username_label=Jabber JID (e.g. user@server.tld):
 #instructions=Enter your remote jabber JID and password as well as your local username and password
 # If True a local jabber account on <local_account_server> is needed
 # for transport registration, the idea is to enable public registration
 # from other servers, but only for users, who have already local accounts
 #require_local_account=1
 #local_username_label=Local username (without @server.tld):
 #local_account_server=localhost
 #local_account_server_timeout=10000

src/storagebackend.cpp

➞

Show inline comments

 #include "transport/storagebackend.h"
 #include "transport/config.h"
 #include "transport/sqlite3backend.h"
 #include "transport/mysqlbackend.h"
 #include "transport/pqxxbackend.h"
 namespace Transport {
 StorageBackend *StorageBackend::createBackend(Config *config, std::string &error) {
 	StorageBackend *storageBackend = NULL;
 #ifdef WITH_SQLITE
 	if (CONFIG_STRING(config, "database.type") == "sqlite3" ||
 		(CONFIG_STRING(config, "database.type") == "none" && !CONFIG_BOOL(config, "service.server_mode"))) {
 	if (CONFIG_STRING(config, "database.type") == "sqlite3") {
 		storageBackend = new SQLite3Backend(config);
+	}
 #else
 	if (CONFIG_STRING(config, "database.type") == "sqlite3") {
 		error = "Libtransport is not compiled with sqlite3 backend support.";
+	}
 #endif
 #ifdef WITH_MYSQL
 	if (CONFIG_STRING(config, "database.type") == "mysql") {
 		storageBackend = new MySQLBackend(config);
+	}
 #else
 	if (CONFIG_STRING(config, "database.type") == "mysql") {
 		error = "Spectrum2 is not compiled with mysql backend support.";
+	}
 #endif
 #ifdef WITH_PQXX
 	if (CONFIG_STRING(config, "database.type") == "pqxx") {
 		storageBackend = new PQXXBackend(config);
+	}
 #else
 	if (CONFIG_STRING(config, "database.type") == "pqxx") {
 		error = "Spectrum2 is not compiled with pqxx backend support.";
+	}
 #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") != "none") {
 		error = "Unknown storage backend " + CONFIG_STRING(config, "database.type");
+	}
 	return storageBackend;
+}
+}

0 comments (0 inline, 0 general)