}

chatStateNotifier_->setContactIsOnline(presence && presence->getType() == Presence::Available);

handleBareJIDCapsChanged(toJID_);

}

void ChatController::setAvailableServerFeatures(boost::shared_ptr<DiscoInfo> info) {

ChatControllerBase::setAvailableServerFeatures(info);

if (iqRouter_->isAvailable() && info->hasFeature(DiscoInfo::BlockingCommandFeature)) {

boost::shared_ptr<BlockList> blockList = clientBlockListManager_->getBlockList();

blockingOnStateChangedConnection_ = blockList->onStateChanged.connect(boost::bind(&ChatController::handleBlockingStateChanged, this));

blockingOnItemAddedConnection_ = blockList->onItemAdded.connect(boost::bind(&ChatController::handleBlockingItemAdded, this, _1));

blockingOnItemRemovedConnection_ = blockList->onItemRemoved.connect(boost::bind(&ChatController::handleBlockingItemRemoved, this, _1));

handleBlockingStateChanged();

}

}

bool ChatController::isIncomingMessageFromMe(boost::shared_ptr<Message>) {

return false;

}

void ChatController::preHandleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent) {

if (messageEvent->isReadable()) {

chatWindow_->flash();

lastWasPresence_ = false;

}

boost::shared_ptr<Message> message = messageEvent->getStanza();

JID from = message->getFrom();

if (!from.equals(toJID_, JID::WithResource)) {

if (toJID_.equals(from, JID::WithoutResource) && toJID_.isBare()){

setToJID(from);

}

}

chatStateTracker_->handleMessageReceived(message);

// handle XEP-0184 Message Receipts

// incomming receipts

if (boost::shared_ptr<DeliveryReceipt> receipt = message->getPayload<DeliveryReceipt>()) {

SWIFT_LOG(debug) << "received receipt for id: " << receipt->getReceivedID() << std::endl;

if (requestedReceipts_.find(receipt->getReceivedID()) != requestedReceipts_.end()) {

chatWindow_->setMessageReceiptState(requestedReceipts_[receipt->getReceivedID()], ChatWindow::ReceiptReceived);

requestedReceipts_.erase(receipt->getReceivedID());

}

// incomming errors in response to send out receipts

} else if (message->getPayload<DeliveryReceiptRequest>() && (message->getType() == Message::Error)) {

if (requestedReceipts_.find(message->getID()) != requestedReceipts_.end()) {

chatWindow_->setMessageReceiptState(requestedReceipts_[message->getID()], ChatWindow::ReceiptFailed);

requestedReceipts_.erase(message->getID());

}

// incoming receipt requests

} else if (message->getPayload<DeliveryReceiptRequest>()) {

if (receivingPresenceFromUs_) {

boost::shared_ptr<Message> receiptMessage = boost::make_shared<Message>();

receiptMessage->setTo(toJID_);

receiptMessage->addPayload(boost::make_shared<DeliveryReceipt>(message->getID()));

stanzaChannel_->sendMessage(receiptMessage);

}

}

}

void ChatController::postHandleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent, const HighlightAction& highlight) {

eventController_->handleIncomingEvent(messageEvent);

if (!messageEvent->getConcluded()) {

highlighter_->handleHighlightAction(highlight);

}

}

void ChatController::preSendMessageRequest(boost::shared_ptr<Message> message) {

}

MUCController* controller = NULL;

SingleChatWindowFactoryAdapter* chatWindowFactoryAdapter = NULL;

if (reuseChatwindow) {

chatWindowFactoryAdapter = new SingleChatWindowFactoryAdapter(reuseChatwindow);

}

controller = new MUCController(jid_, muc, password, nick, stanzaChannel_, iqRouter_, reuseChatwindow ? chatWindowFactoryAdapter : chatWindowFactory_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory_, eventController_, entityCapsProvider_, roster_, historyController_, mucRegistry_, highlightManager_, chatMessageParser_, isImpromptu, autoAcceptMUCInviteDecider_, vcardManager_);

if (chatWindowFactoryAdapter) {

/* The adapters are only passed to chat windows, which are deleted in their

* controllers' dtor, which are deleted in ChatManager's dtor. The adapters

* are also deleted there.*/

chatWindowFactoryAdapters_[controller] = chatWindowFactoryAdapter;

}

mucControllers_[mucJID] = controller;

controller->setAvailableServerFeatures(serverDiscoInfo_);

controller->onUserLeft.connect(boost::bind(&ChatsManager::handleUserLeftMUC, this, controller));

controller->onUserJoined.connect(boost::bind(&ChatsManager::handleChatActivity, this, mucJID.toBare(), "", true));

controller->onActivity.connect(boost::bind(&ChatsManager::handleChatActivity, this, mucJID.toBare(), _1, true));

controller->onUnreadCountChanged.connect(boost::bind(&ChatsManager::handleUnreadCountChanged, this, controller));

handleChatActivity(mucJID.toBare(), "", true);

}

mucControllers_[mucJID]->showChatWindow();

return muc;

}

void ChatsManager::handleSearchMUCRequest() {

mucSearchController_->openSearchWindow();

}

void ChatsManager::handleIncomingMessage(boost::shared_ptr<Message> message) {

JID jid = message->getFrom();

boost::shared_ptr<MessageEvent> event(new MessageEvent(message));

bool isMediatedInvite = (message->getPayload<MUCUserPayload>() && message->getPayload<MUCUserPayload>()->getInvite());

if (isMediatedInvite) {

jid = (*message->getPayload<MUCUserPayload>()->getInvite()).from;

}

if (!event->isReadable() && !message->getPayload<ChatState>() && !message->getPayload<DeliveryReceipt>() && !message->getPayload<DeliveryReceiptRequest>() && !isInvite && !isMediatedInvite && !message->hasSubject()) {

return;

}

// Try to deliver it to a MUC

if (message->getType() == Message::Groupchat || message->getType() == Message::Error /*|| (isInvite && message->getType() == Message::Normal)*/) {

std::map<JID, MUCController*>::iterator i = mucControllers_.find(jid.toBare());

if (i != mucControllers_.end()) {

i->second->handleIncomingMessage(event);

return;

}

else if (message->getType() == Message::Groupchat) {

//FIXME: Error handling - groupchat messages from an unknown muc.

return;

}

}

// check for impromptu invite to potentially auto-accept

MUCInvitationPayload::ref invite = message->getPayload<MUCInvitationPayload>();

if (invite && autoAcceptMUCInviteDecider_->isAutoAcceptedInvite(message->getFrom(), invite)) {

if (invite->getIsContinuation()) {

// check for existing chat controller for the from JID

ChatController* controller = getChatControllerIfExists(jid);

if (controller) {

ChatWindow* window = controller->detachChatWindow();

chatControllers_.erase(jid);

delete controller;

handleJoinMUCRequest(invite->getJID(), boost::optional<std::string>(), boost::optional<std::string>(), false, false, true, window);

}

} else {

handleJoinMUCRequest(invite->getJID(), boost::optional<std::string>(), boost::optional<std::string>(), false, false, true);

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <boost/bind.hpp>

#include <iostream>

#include <Swiften/LinkLocal/LinkLocalServiceBrowser.h>

#include <Swiften/LinkLocal/DNSSD/DNSSDBrowseQuery.h>

#include <Swiften/Network/HostAddress.h>

namespace Swift {

LinkLocalServiceBrowser::LinkLocalServiceBrowser(boost::shared_ptr<DNSSDQuerier> querier) : querier(querier), haveError(false) {

}

LinkLocalServiceBrowser::~LinkLocalServiceBrowser() {

if (isRunning()) {

std::cerr << "WARNING: LinkLocalServiceBrowser still running on destruction" << std::endl;

}

}

void LinkLocalServiceBrowser::start() {

assert(!isRunning());

haveError = false;

browseQuery = querier->createBrowseQuery();

browseQuery->onServiceAdded.connect(

boost::bind(&LinkLocalServiceBrowser::handleServiceAdded, this, _1));

browseQuery->onServiceRemoved.connect(

boost::bind(&LinkLocalServiceBrowser::handleServiceRemoved, this, _1));

browseQuery->onError.connect(

boost::bind(&LinkLocalServiceBrowser::handleBrowseError, this));

browseQuery->startBrowsing();

}

void LinkLocalServiceBrowser::stop() {

assert(isRunning());

if (isRegistered()) {

unregisterService();

}

for (ResolveQueryMap::const_iterator i = resolveQueries.begin(); i != resolveQueries.end(); ++i) {

i->second->stop();

}

resolveQueries.clear();

services.clear();

browseQuery->stopBrowsing();

browseQuery.reset();

onStopped(haveError);

}

bool LinkLocalServiceBrowser::isRunning() const {

}

bool LinkLocalServiceBrowser::hasError() const {

return haveError;

}

bool LinkLocalServiceBrowser::isRegistered() const {

}

void LinkLocalServiceBrowser::registerService(const std::string& name, int port, const LinkLocalServiceInfo& info) {

assert(!registerQuery);

registerQuery = querier->createRegisterQuery(name, port, info.toTXTRecord());

registerQuery->onRegisterFinished.connect(

boost::bind(&LinkLocalServiceBrowser::handleRegisterFinished, this, _1));

registerQuery->registerService();

}

void LinkLocalServiceBrowser::updateService(const LinkLocalServiceInfo& info) {

assert(registerQuery);

registerQuery->updateServiceInfo(info.toTXTRecord());

}

void LinkLocalServiceBrowser::unregisterService() {

assert(registerQuery);

registerQuery->unregisterService();

registerQuery.reset();

selfService.reset();

}

std::vector<LinkLocalService> LinkLocalServiceBrowser::getServices() const {

std::vector<LinkLocalService> result;

for (ServiceMap::const_iterator i = services.begin(); i != services.end(); ++i) {

result.push_back(LinkLocalService(i->first, i->second));

}

return result;

}

void LinkLocalServiceBrowser::handleServiceAdded(const DNSSDServiceID& service) {

if (selfService && service == *selfService) {

return;

}

/*

* Copyright (c) 2011 Thilo Cestonaro

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Network/BOSHConnection.h>

#include <boost/bind.hpp>

#include <boost/thread.hpp>

#include <boost/lexical_cast.hpp>

#include <string>

#include <Swiften/Base/Log.h>

#include <Swiften/Base/String.h>

#include <Swiften/Base/Concat.h>

#include <Swiften/Base/ByteArray.h>

#include <Swiften/Network/HostAddressPort.h>

#include <Swiften/Parser/BOSHBodyExtractor.h>

namespace Swift {

BOSHConnection::BOSHConnection(const URL& boshURL, Connector::ref connector, XMLParserFactory* parserFactory)

: boshURL_(boshURL),

connector_(connector),

parserFactory_(parserFactory),

sid_(),

waitingForStartResponse_(false),

pending_(false),

connectionReady_(false)

{

}

BOSHConnection::~BOSHConnection() {

cancelConnector();

if (connection_) {

connection_->onDataRead.disconnect(boost::bind(&BOSHConnection::handleDataRead, shared_from_this(), _1));

safeContent.insert(safeContent.end(), contentTail.begin(), contentTail.end());

size = safeContent.size();

header << "POST " << boshURL.getPath() << " HTTP/1.1\r\n"

<< "Host: " << boshURL.getHost();

if (boshURL.getPort()) {

header << ":" << *boshURL.getPort();

}

header << "\r\n"

// << "Accept-Encoding: deflate\r\n"

<< "Content-Type: text/xml; charset=utf-8\r\n"

<< "Content-Length: " << size << "\r\n\r\n";

SafeByteArray safeHeader = createSafeByteArray(header.str());

safeHeader.insert(safeHeader.end(), safeContent.begin(), safeContent.end());

return std::pair<SafeByteArray, size_t>(safeHeader, size);

}

void BOSHConnection::write(const SafeByteArray& data, bool streamRestart, bool terminate) {

assert(connectionReady_);

assert(!sid_.empty());

SafeByteArray safeHeader = createHTTPRequest(data, streamRestart, terminate, rid_, sid_, boshURL_).first;

onBOSHDataWritten(safeHeader);

connection_->write(safeHeader);

pending_ = true;

SWIFT_LOG(debug) << "write data: " << safeByteArrayToString(safeHeader) << std::endl;

}

void BOSHConnection::handleConnectFinished(Connection::ref connection) {

cancelConnector();

if (connectionReady_) {

connection_ = connection;

connection_->onDataRead.connect(boost::bind(&BOSHConnection::handleDataRead, shared_from_this(), _1));

connection_->onDisconnected.connect(boost::bind(&BOSHConnection::handleDisconnected, shared_from_this(), _1));

}

onConnectFinished(!connectionReady_);

}

void BOSHConnection::startStream(const std::string& to, unsigned long long rid) {

assert(connectionReady_);

// Session Creation Request

std::stringstream content;

std::stringstream header;

content << "<body content='text/xml; charset=utf-8'"

<< " hold='1'"

<< " to='" << to << "'"

<< " rid='" << rid << "'"

<< " ver='1.6'"

<< " wait='60'" /* FIXME: we probably want this configurable*/

// << " ack='0'" FIXME: support acks

<< " xml:lang='en'"

<< " xmlns:xmpp='urn:xmpp:bosh'"

<< " xmpp:version='1.0'"

<< " xmlns='http://jabber.org/protocol/httpbind' />";

std::string contentString = content.str();

header << "POST " << boshURL_.getPath() << " HTTP/1.1\r\n"

<< "Host: " << boshURL_.getHost();

if (boshURL_.getPort()) {

header << ":" << *boshURL_.getPort();

}

header << "\r\n"

// << "Accept-Encoding: deflate\r\n"

/*

* 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/Serializer/ElementSerializer.h>

namespace Swift {

template<typename T>

class GenericElementSerializer : public ElementSerializer {

public:

virtual SafeByteArray serialize(boost::shared_ptr<Element> element) const = 0;

virtual bool canSerialize(boost::shared_ptr<Element> element) const {

}

};

}

/*

* 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/Serializer/PayloadSerializer.h>

namespace Swift {

template<typename PAYLOAD_TYPE>

class GenericPayloadSerializer : public PayloadSerializer {

public:

virtual std::string serialize(boost::shared_ptr<Payload> element) const {

return serializePayload(boost::dynamic_pointer_cast<PAYLOAD_TYPE>(element));

}

virtual bool canSerialize(boost::shared_ptr<Payload> element) const {

}

virtual std::string serializePayload(boost::shared_ptr<PAYLOAD_TYPE>) const = 0;

};

}