+#include "Slimber/Server.h"

+

+#include <string>

+#include <boost/bind.hpp>

+

+#include "Swiften/LinkLocal/LinkLocalConnector.h"

+#include "Swiften/Network/Connection.h"

+#include "Swiften/Session/SessionTracer.h"

+#include "Swiften/Elements/Element.h"

+#include "Swiften/Elements/Presence.h"

+#include "Swiften/Elements/RosterPayload.h"

+#include "Swiften/Network/BoostConnection.h"

+#include "Swiften/Network/BoostConnectionServer.h"

+#include "Swiften/Session/SessionTracer.h"

+#include "Swiften/Elements/IQ.h"

+#include "Swiften/Elements/VCard.h"

+#include "Swiften/Server/UserRegistry.h"

+#include "Swiften/Base/String.h"

+#include "Swiften/LinkLocal/LinkLocalServiceInfo.h"

+#include "Swiften/LinkLocal/OutgoingLinkLocalSession.h"

+#include "Swiften/LinkLocal/IncomingLinkLocalSession.h"

+#include "Swiften/LinkLocal/LinkLocalServiceBrowser.h"

+#include "Swiften/Network/ConnectionServer.h"

+#include "Slimber/VCardCollection.h"

+#include "Slimber/LinkLocalPresenceManager.h"

+#include "Swiften/Server/ServerFromClientSession.h"

+

+namespace Swift {

+

+Server::Server(

+ int clientConnectionPort,

+ int linkLocalConnectionPort,

+ LinkLocalServiceBrowser* linkLocalServiceBrowser,

+ VCardCollection* vCardCollection) :

+ linkLocalServiceRegistered(false),

+ rosterRequested(false),

+ clientConnectionPort(clientConnectionPort),

+ linkLocalConnectionPort(linkLocalConnectionPort),

+ linkLocalServiceBrowser(linkLocalServiceBrowser),

+ vCardCollection(vCardCollection),

+ presenceManager(NULL),

+ stopping(false) {

+ linkLocalServiceBrowser->onServiceRegistered.connect(

+ boost::bind(&Server::handleServiceRegistered, this, _1));

+}

+

+Server::~Server() {

+ stop();

+}

+

+void Server::start() {

+ assert(!serverFromClientConnectionServer);

+ serverFromClientConnectionServer =

+ boost::shared_ptr<BoostConnectionServer>(new BoostConnectionServer(

+ clientConnectionPort, &boostIOServiceThread.getIOService()));

+ serverFromClientConnectionServerSignalConnections.push_back(

+ serverFromClientConnectionServer->onNewConnection.connect(

+ boost::bind(&Server::handleNewClientConnection, this, _1)));

+ serverFromClientConnectionServerSignalConnections.push_back(

+ serverFromClientConnectionServer->onStopped.connect(

+ boost::bind(&Server::handleClientConnectionServerStopped, this, _1)));

+

+ assert(!serverFromNetworkConnectionServer);

+ serverFromNetworkConnectionServer =

+ boost::shared_ptr<BoostConnectionServer>(new BoostConnectionServer(

+ linkLocalConnectionPort, &boostIOServiceThread.getIOService()));

+ serverFromNetworkConnectionServerSignalConnections.push_back(

+ serverFromNetworkConnectionServer->onNewConnection.connect(

+ boost::bind(&Server::handleNewLinkLocalConnection, this, _1)));

+ serverFromNetworkConnectionServerSignalConnections.push_back(

+ serverFromNetworkConnectionServer->onStopped.connect(

+ boost::bind(&Server::handleLinkLocalConnectionServerStopped, this, _1)));

+

+ assert(!presenceManager);

+ presenceManager = new LinkLocalPresenceManager(linkLocalServiceBrowser);

+ presenceManager->onRosterChanged.connect(

+ boost::bind(&Server::handleRosterChanged, this, _1));

+ presenceManager->onPresenceChanged.connect(

+ boost::bind(&Server::handlePresenceChanged, this, _1));

+

+ serverFromClientConnectionServer->start();

+ serverFromNetworkConnectionServer->start();

+}

+

+void Server::stop() {

+ stop(boost::optional<ServerError>());

+}

+

+void Server::stop(boost::optional<ServerError> e) {

+ if (stopping) {

+ return;

+ }

+

+ stopping = true;

+

+ delete presenceManager;

+ presenceManager = NULL;

+

+ if (serverFromClientSession) {

+ serverFromClientSession->finishSession();

+ }

+ serverFromClientSession.reset();

+ foreach(boost::shared_ptr<Session> session, linkLocalSessions) {

+ session->finishSession();

+ }

+ linkLocalSessions.clear();

+ foreach(boost::shared_ptr<LinkLocalConnector> connector, connectors) {

+ connector->cancel();

+ }

+ connectors.clear();

+ tracers.clear();

+

+ if (serverFromNetworkConnectionServer) {

+ serverFromNetworkConnectionServer->stop();

+ foreach(boost::bsignals::connection& connection, serverFromNetworkConnectionServerSignalConnections) {

+ connection.disconnect();

+ }

+ serverFromNetworkConnectionServerSignalConnections.clear();

+ serverFromNetworkConnectionServer.reset();

+ }

+ if (serverFromClientConnectionServer) {

+ serverFromClientConnectionServer->stop();

+ foreach(boost::bsignals::connection& connection, serverFromClientConnectionServerSignalConnections) {

+ connection.disconnect();

+ }

+ serverFromClientConnectionServerSignalConnections.clear();

+ serverFromClientConnectionServer.reset();

+ }

+

+ stopping = false;

+ onStopped(e);

+}

+

+void Server::handleNewClientConnection(boost::shared_ptr<Connection> connection) {

+ if (serverFromClientSession) {

+ connection->disconnect();

+ }

+ serverFromClientSession = boost::shared_ptr<ServerFromClientSession>(

+ new ServerFromClientSession(idGenerator.generateID(), connection,

+ &payloadParserFactories, &payloadSerializers, &userRegistry));

+ serverFromClientSession->onSessionStarted.connect(

+ boost::bind(&Server::handleSessionStarted, this));

+ serverFromClientSession->onElementReceived.connect(

+ boost::bind(&Server::handleElementReceived, this, _1,

+ serverFromClientSession));

+ serverFromClientSession->onSessionFinished.connect(

+ boost::bind(&Server::handleSessionFinished, this,

+ serverFromClientSession));

+ //tracers.push_back(boost::shared_ptr<SessionTracer>(

+ // new SessionTracer(serverFromClientSession)));

+ serverFromClientSession->startSession();

+}

+

+void Server::handleSessionStarted() {

+ onSelfConnected(true);

+}

+

+void Server::handleSessionFinished(boost::shared_ptr<ServerFromClientSession>) {

+ serverFromClientSession.reset();

+ unregisterService();

+ selfJID = JID();

+ rosterRequested = false;

+ onSelfConnected(false);

+ lastPresence.reset();

+}

+

+void Server::unregisterService() {

+ if (linkLocalServiceRegistered) {

+ linkLocalServiceRegistered = false;

+ linkLocalServiceBrowser->unregisterService();

+ }

+}

+

+void Server::handleElementReceived(boost::shared_ptr<Element> element, 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->getTo().isValid()) {

+ stanza->setTo(session->getLocalJID());

+ }

+

+ if (boost::shared_ptr<Presence> presence = boost::dynamic_pointer_cast<Presence>(stanza)) {

+ if (presence->getType() == Presence::Available) {

+ if (!linkLocalServiceRegistered) {

+ linkLocalServiceRegistered = true;

+ linkLocalServiceBrowser->registerService(

+ session->getRemoteJID().toBare().toString(),

+ linkLocalConnectionPort, getLinkLocalServiceInfo(presence));

+ }

+ else {

+ linkLocalServiceBrowser->updateService(

+ getLinkLocalServiceInfo(presence));

+ }

+ lastPresence = presence;

+ }

+ else {

+ unregisterService();

+ }

+ }

+ else if (!stanza->getTo().isValid() || stanza->getTo() == session->getLocalJID() || stanza->getTo() == session->getRemoteJID().toBare()) {

+ if (boost::shared_ptr<IQ> iq = boost::dynamic_pointer_cast<IQ>(stanza)) {

+ if (iq->getPayload<RosterPayload>()) {

+ if (iq->getType() == IQ::Get) {

+ session->sendElement(IQ::createResult(iq->getFrom(), iq->getID(), presenceManager->getRoster()));

+ rosterRequested = true;

+ foreach(const boost::shared_ptr<Presence> presence, presenceManager->getAllPresence()) {

+ session->sendElement(presence);

+ }

+ }

+ else {

+ session->sendElement(IQ::createError(iq->getFrom(), iq->getID(), ErrorPayload::Forbidden, ErrorPayload::Cancel));

+ }

+ }

+ if (boost::shared_ptr<VCard> vcard = iq->getPayload<VCard>()) {

+ if (iq->getType() == IQ::Get) {

+ session->sendElement(IQ::createResult(iq->getFrom(), iq->getID(), vCardCollection->getOwnVCard()));

+ }

+ else {

+ vCardCollection->setOwnVCard(vcard);

+ session->sendElement(IQ::createResult(iq->getFrom(), iq->getID()));

+ if (lastPresence) {

+ linkLocalServiceBrowser->updateService(getLinkLocalServiceInfo(lastPresence));

+ }

+ }

+ }

+ else {

+ session->sendElement(IQ::createError(iq->getFrom(), iq->getID(), ErrorPayload::FeatureNotImplemented, ErrorPayload::Cancel));

+ }

+ }

+ }

+ else {

+ JID toJID = stanza->getTo();

+ boost::shared_ptr<Session> outgoingSession =

+ getLinkLocalSessionForJID(toJID);

+ if (outgoingSession) {

+ outgoingSession->sendElement(stanza);

+ }

+ else {

+ boost::optional<LinkLocalService> service =

+ presenceManager->getServiceForJID(toJID);

+ if (service) {

+ boost::shared_ptr<LinkLocalConnector> connector =

+ getLinkLocalConnectorForJID(toJID);

+ if (!connector) {

+ connector = boost::shared_ptr<LinkLocalConnector>(

+ new LinkLocalConnector(

+ *service,

+ linkLocalServiceBrowser->getQuerier(),

+ boost::shared_ptr<BoostConnection>(new BoostConnection(&boostIOServiceThread.getIOService()))));

+ connector->onConnectFinished.connect(

+ boost::bind(&Server::handleConnectFinished, this, connector, _1));

+ connectors.push_back(connector);

+ connector->connect();

+ }

+ connector->queueElement(element);

+ }

+ else {

+ session->sendElement(IQ::createError(

+ stanza->getFrom(), stanza->getID(),

+ ErrorPayload::RecipientUnavailable, ErrorPayload::Wait));

+ }

+ }

+ }

+}

+

+void Server::handleNewLinkLocalConnection(boost::shared_ptr<Connection> connection) {

+ boost::shared_ptr<IncomingLinkLocalSession> session(

+ new IncomingLinkLocalSession(

+ selfJID, connection,

+ &payloadParserFactories, &payloadSerializers));

+ registerLinkLocalSession(session);

+}

+

+void Server::handleLinkLocalSessionFinished(boost::shared_ptr<Session> session) {

+ //std::cout << "Link local session from " << session->getRemoteJID() << " ended" << std::endl;

+ linkLocalSessions.erase(

+ std::remove(linkLocalSessions.begin(), linkLocalSessions.end(), session),

+ linkLocalSessions.end());

+}

+

+void Server::handleLinkLocalElementReceived(boost::shared_ptr<Element> element, boost::shared_ptr<Session> session) {

+ if (boost::shared_ptr<Stanza> stanza = boost::dynamic_pointer_cast<Stanza>(element)) {

+ JID fromJID = session->getRemoteJID();

+ if (!presenceManager->getServiceForJID(fromJID.toBare())) {

+ return; // TODO: Send error back

+ }

+ stanza->setFrom(fromJID);

+ serverFromClientSession->sendElement(stanza);

+ }

+}

+

+void Server::handleConnectFinished(boost::shared_ptr<LinkLocalConnector> connector, bool error) {

+ if (error) {

+ std::cerr << "Error connecting" << std::endl;

+ // TODO: Send back queued stanzas

+ }

+ else {

+ boost::shared_ptr<OutgoingLinkLocalSession> outgoingSession(

+ new OutgoingLinkLocalSession(

+ selfJID, connector->getService().getJID(), connector->getConnection(),

+ &payloadParserFactories, &payloadSerializers));

+ foreach(const boost::shared_ptr<Element> element, connector->getQueuedElements()) {

+ outgoingSession->queueElement(element);

+ }

+ registerLinkLocalSession(outgoingSession);

+ }

+ connectors.erase(std::remove(connectors.begin(), connectors.end(), connector), connectors.end());

+}

+

+void Server::registerLinkLocalSession(boost::shared_ptr<Session> session) {

+ session->onSessionFinished.connect(

+ boost::bind(&Server::handleLinkLocalSessionFinished, this, session));

+ session->onElementReceived.connect(

+ boost::bind(&Server::handleLinkLocalElementReceived, this, _1, session));

+ linkLocalSessions.push_back(session);

+ //tracers.push_back(boost::shared_ptr<SessionTracer>(new SessionTracer(session)));

+ session->startSession();

+}

+

+boost::shared_ptr<Session> Server::getLinkLocalSessionForJID(const JID& jid) {

+ foreach(const boost::shared_ptr<Session> session, linkLocalSessions) {

+ if (session->getRemoteJID() == jid) {

+ return session;

+ }

+ }

+ return boost::shared_ptr<Session>();

+}

+

+boost::shared_ptr<LinkLocalConnector> Server::getLinkLocalConnectorForJID(const JID& jid) {

+ foreach(const boost::shared_ptr<LinkLocalConnector> connector, connectors) {

+ if (connector->getService().getJID() == jid) {

+ return connector;

+ }

+ }

+ return boost::shared_ptr<LinkLocalConnector>();

+}

+

+void Server::handleServiceRegistered(const DNSSDServiceID& service) {

+ selfJID = JID(service.getName());

+}

+

+void Server::handleRosterChanged(boost::shared_ptr<RosterPayload> roster) {

+ if (rosterRequested) {

+ assert(serverFromClientSession);

+ boost::shared_ptr<IQ> iq = IQ::createRequest(

+ IQ::Set, serverFromClientSession->getRemoteJID(),

+ idGenerator.generateID(), roster);

+ iq->setFrom(serverFromClientSession->getRemoteJID().toBare());

+ serverFromClientSession->sendElement(iq);

+ }

+}

+

+void Server::handlePresenceChanged(boost::shared_ptr<Presence> presence) {

+ if (rosterRequested) {

+ serverFromClientSession->sendElement(presence);

+ }

+}

+

+void Server::handleClientConnectionServerStopped(boost::optional<BoostConnectionServer::Error> e) {

+ if (e) {

+ if (*e == BoostConnectionServer::Conflict) {

+ stop(ServerError(ServerError::C2SPortConflict));

+ }

+ else {

+ stop(ServerError(ServerError::C2SError));

+ }

+ }

+ else {

+ stop();

+ }

+}

+

+void Server::handleLinkLocalConnectionServerStopped(boost::optional<BoostConnectionServer::Error> e) {

+ if (e) {

+ if (*e == BoostConnectionServer::Conflict) {

+ stop(ServerError(ServerError::LinkLocalPortConflict));

+ }

+ else {

+ stop(ServerError(ServerError::LinkLocalError));

+ }

+ }

+ else {

+ stop();

+ }

+}

+

+LinkLocalServiceInfo Server::getLinkLocalServiceInfo(boost::shared_ptr<Presence> presence) {

+ LinkLocalServiceInfo info;

+ boost::shared_ptr<VCard> vcard = vCardCollection->getOwnVCard();

+ if (!vcard->getFamilyName().isEmpty() || !vcard->getGivenName().isEmpty()) {

+ info.setFirstName(vcard->getGivenName());

+ info.setLastName(vcard->getFamilyName());

+ }

+ else if (!vcard->getFullName().isEmpty()) {

+ std::pair<String,String> p = vcard->getFullName().getSplittedAtFirst(' ');

+ info.setFirstName(p.first);

+ info.setLastName(p.second);

+ }

+ if (!vcard->getNickname().isEmpty()) {

+ info.setNick(vcard->getNickname());

+ }

+ if (!vcard->getEMail().isEmpty()) {

+ info.setEMail(vcard->getEMail());

+ }

+ info.setMessage(presence->getStatus());

+ switch (presence->getShow()) {

+ case StatusShow::Online:

+ case StatusShow::None:

+ case StatusShow::FFC:

+ info.setStatus(LinkLocalServiceInfo::Available);

+ break;

+ case StatusShow::Away:

+ case StatusShow::XA:

+ info.setStatus(LinkLocalServiceInfo::Away);

+ break;

+ case StatusShow::DND:

+ info.setStatus(LinkLocalServiceInfo::DND);

+ break;

+ }

+ info.setPort(linkLocalConnectionPort);

+ return info;

+}

+

+}