/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/BytestreamsSerializer.h>

#include <memory>

#include <boost/lexical_cast.hpp>

#include <Swiften/Serializer/PayloadSerializerCollection.h>

#include <Swiften/Serializer/XML/XMLElement.h>

namespace Swift {

BytestreamsSerializer::BytestreamsSerializer() {

}

std::string BytestreamsSerializer::serializePayload(std::shared_ptr<Bytestreams> bytestreams) const {

XMLElement queryElement("query", "http://jabber.org/protocol/bytestreams");

queryElement.setAttribute("sid", bytestreams->getStreamID());

std::shared_ptr<XMLElement> streamHostElement(new XMLElement("streamhost"));

streamHostElement->setAttribute("host", streamHost.host);

streamHostElement->setAttribute("jid", streamHost.jid.toString());

streamHostElement->setAttribute("port", boost::lexical_cast<std::string>(streamHost.port));

queryElement.addNode(streamHostElement);

}

if (bytestreams->getUsedStreamHost()) {

std::shared_ptr<XMLElement> streamHostElement(new XMLElement("streamhost-used"));

streamHostElement->setAttribute("jid", *bytestreams->getUsedStreamHost());

queryElement.addNode(streamHostElement);

}

return queryElement.serialize();

}

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/CommandSerializer.h>

#include <memory>

#include <Swiften/Serializer/PayloadSerializers/FormSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

namespace Swift {

CommandSerializer::CommandSerializer() {

}

std::string CommandSerializer::serializePayload(std::shared_ptr<Command> command) const {

XMLElement commandElement("command", "http://jabber.org/protocol/commands");

commandElement.setAttribute("node", command->getNode());

if (!command->getSessionID().empty()) {

commandElement.setAttribute("sessionid", command->getSessionID());

}

std::string action = actionToString(command->getAction());

if (!action.empty()) {

commandElement.setAttribute("action", action);

}

std::string status;

switch (command->getStatus()) {

case Command::Executing: status = "executing";break;

case Command::Completed: status = "completed";break;

case Command::Canceled: status = "canceled";break;

case Command::NoStatus: break;

}

if (!status.empty()) {

commandElement.setAttribute("status", status);

}

if (command->getAvailableActions().size() > 0) {

std::string actions = "<actions";

std::string executeAction = actionToString(command->getExecuteAction());

if (!executeAction.empty()) {

actions += " execute='" + executeAction + "'";

}

actions += ">";

actions += "<" + actionToString(action) + "/>";

}

actions += "</actions>";

commandElement.addNode(std::make_shared<XMLRawTextNode>(actions));

}

std::shared_ptr<XMLElement> noteElement(new XMLElement("note"));

std::string type;

switch (note.type) {

case Command::Note::Info: type = "info"; break;

case Command::Note::Warn: type = "warn"; break;

case Command::Note::Error: type = "error"; break;

}

if (!type.empty()) {

noteElement->setAttribute("type", type);

}

noteElement->addNode(std::make_shared<XMLTextNode>(note.note));

commandElement.addNode(noteElement);

}

Form::ref form = command->getForm();

if (form) {

commandElement.addNode(std::make_shared<XMLRawTextNode>(FormSerializer().serialize(form)));

}

return commandElement.serialize();

}

std::string CommandSerializer::actionToString(Command::Action action) const {

std::string string;

switch (action) {

case Command::Cancel: string = "cancel"; break;

case Command::Execute: string = "execute"; break;

case Command::Complete: string = "complete"; break;

case Command::Prev: string = "prev"; break;

case Command::Next: string = "next"; break;

case Command::NoAction: break;

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/DiscoInfoSerializer.h>

#include <memory>

#include <Swiften/Serializer/PayloadSerializers/FormSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

namespace Swift {

DiscoInfoSerializer::DiscoInfoSerializer() : GenericPayloadSerializer<DiscoInfo>() {

}

std::string DiscoInfoSerializer::serializePayload(std::shared_ptr<DiscoInfo> discoInfo) const {

XMLElement queryElement("query", "http://jabber.org/protocol/disco#info");

if (!discoInfo->getNode().empty()) {

queryElement.setAttribute("node", discoInfo->getNode());

}

std::shared_ptr<XMLElement> identityElement(new XMLElement("identity"));

if (!identity.getLanguage().empty()) {

identityElement->setAttribute("xml:lang", identity.getLanguage());

}

identityElement->setAttribute("category", identity.getCategory());

identityElement->setAttribute("name", identity.getName());

identityElement->setAttribute("type", identity.getType());

queryElement.addNode(identityElement);

}

std::shared_ptr<XMLElement> featureElement(new XMLElement("feature"));

featureElement->setAttribute("var", feature);

queryElement.addNode(featureElement);

}

queryElement.addNode(std::make_shared<XMLRawTextNode>(FormSerializer().serialize(extension)));

}

return queryElement.serialize();

}

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/DiscoItemsSerializer.h>

#include <memory>

#include <Swiften/Serializer/XML/XMLElement.h>

namespace Swift {

DiscoItemsSerializer::DiscoItemsSerializer() : GenericPayloadSerializer<DiscoItems>() {

}

std::string DiscoItemsSerializer::serializePayload(std::shared_ptr<DiscoItems> discoItems) const {

XMLElement queryElement("query", "http://jabber.org/protocol/disco#items");

if (!discoItems->getNode().empty()) {

queryElement.setAttribute("node", discoItems->getNode());

}

std::shared_ptr<XMLElement> itemElement(new XMLElement("item"));

itemElement->setAttribute("name", item.getName());

itemElement->setAttribute("jid", item.getJID());

if (!item.getNode().empty()) {

itemElement->setAttribute("node", item.getNode());

}

queryElement.addNode(itemElement);

}

return queryElement.serialize();

}

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/FormSerializer.h>

#include <memory>

#include <string>

#include <Swiften/Base/Algorithm.h>

#include <Swiften/Base/String.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

using namespace Swift;

namespace {

template<typename T> void serializeValueAsString(std::shared_ptr<FormField> field, std::shared_ptr<XMLElement> parent) {

std::string value = std::dynamic_pointer_cast<T>(field)->getValue();

if (!value.empty()) {

std::shared_ptr<XMLElement> valueElement(new XMLElement("value"));

valueElement->addNode(XMLTextNode::create(value));

parent->addNode(valueElement);

}

}

}

namespace Swift {

FormSerializer::FormSerializer() : GenericPayloadSerializer<Form>() {}

std::string FormSerializer::serializePayload(std::shared_ptr<Form> form) const {

if (!form) {

return "";

}

std::shared_ptr<XMLElement> formElement(new XMLElement("x", "jabber:x:data"));

std::string type;

switch (form->getType()) {

case Form::FormType: type = "form"; break;

case Form::SubmitType: type = "submit"; break;

case Form::CancelType: type = "cancel"; break;

case Form::ResultType: type = "result"; break;

}

formElement->setAttribute("type", type);

if (!form->getTitle().empty()) {

multiLineify(form->getTitle(), "title", formElement);

}

if (!form->getInstructions().empty()) {

multiLineify(form->getInstructions(), "instructions", formElement);

}

formElement->addNode(pageToXML(page));

}

formElement->addNode(fieldToXML(field, true));

}

if (!form->getReportedFields().empty()) {

std::shared_ptr<XMLElement> reportedElement(new XMLElement("reported"));

reportedElement->addNode(fieldToXML(field, true));

}

formElement->addNode(reportedElement);

}

std::shared_ptr<XMLElement> itemElement(new XMLElement("item"));

itemElement->addNode(fieldToXML(field, false));

}

formElement->addNode(itemElement);

}

formElement->addNode(textToXML(text));

}

formElement->addNode(fieldToXML(field,true));

}

return formElement->serialize();

}

std::shared_ptr<XMLElement> FormSerializer::textToXML(std::shared_ptr<FormText> text) const {

std::shared_ptr<XMLElement> textElement (new XMLElement("text"));

textElement->addNode(std::make_shared<XMLTextNode>(text->getTextString()));

return textElement;

}

std::shared_ptr<XMLElement> FormSerializer::fieldRefToXML(const std::string& ref) const {

std::shared_ptr<XMLElement> fieldRefElement(new XMLElement("fieldref"));

fieldRefElement->setAttribute("var", ref);

return fieldRefElement;

}

std::shared_ptr<XMLElement> FormSerializer::pageToXML(std::shared_ptr<FormPage> page) const {

std::shared_ptr<XMLElement> pageElement(new XMLElement("page"));

pageElement->setAttribute("xmlns", "http://jabber.org/protocol/xdata-layout");

if (!page->getLabel().empty()) {

pageElement->setAttribute("label", page->getLabel());

}

pageElement->addNode(textToXML(text));

}

pageElement->addNode(fieldRefToXML(field->getName()));

fields_.push_back(field);

}

pageElement->addNode(std::make_shared<XMLElement>("reportedref"));

}

pageElement->addNode(sectionToXML(section));

}

return pageElement;

}

std::shared_ptr<XMLElement> FormSerializer::sectionToXML(std::shared_ptr<FormSection> section) const {

std::shared_ptr<XMLElement> sectionElement(new XMLElement("section"));

if (!section->getLabel().empty()) {

sectionElement->setAttribute("label", section->getLabel());

}

sectionElement->addNode(textToXML(text));

}

sectionElement->addNode(fieldRefToXML(field->getName()));

fields_.push_back(field);

}

sectionElement->addNode(std::make_shared<XMLElement>("reportedref"));

}

sectionElement->addNode(sectionToXML(childSection));

}

return sectionElement;

}

std::shared_ptr<XMLElement> FormSerializer::fieldToXML(std::shared_ptr<FormField> field, bool withTypeAttribute) const {

std::shared_ptr<XMLElement> fieldElement(new XMLElement("field"));

if (!field->getName().empty()) {

fieldElement->setAttribute("var", field->getName());

}

if (!field->getLabel().empty()) {

fieldElement->setAttribute("label", field->getLabel());

}

if (field->getRequired()) {

fieldElement->addNode(std::make_shared<XMLElement>("required"));

}

if (!field->getDescription().empty()) {

std::shared_ptr<XMLElement> descriptionElement(new XMLElement("desc"));

descriptionElement->addNode(std::make_shared<XMLTextNode>(field->getDescription()));

fieldElement->addNode(descriptionElement);

}

// Set the value and type

std::string fieldType;

switch (field->getType()) {

case FormField::UnknownType: fieldType = ""; break;

case FormField::BooleanType: fieldType = "boolean"; break;

case FormField::FixedType: fieldType = "fixed"; break;

case FormField::HiddenType: fieldType = "hidden"; break;

case FormField::ListSingleType: fieldType = "list-single"; break;

case FormField::TextMultiType: fieldType = "text-multi"; break;

case FormField::TextPrivateType: fieldType = "text-private"; break;

case FormField::TextSingleType: fieldType = "text-single"; break;

case FormField::JIDSingleType: fieldType = "jid-single"; break;

case FormField::JIDMultiType: fieldType = "jid-multi"; break;

case FormField::ListMultiType: fieldType = "list-multi"; break;

}

if (!fieldType.empty() && withTypeAttribute) {

fieldElement->setAttribute("type", fieldType);

}

std::shared_ptr<XMLElement> valueElement = std::make_shared<XMLElement>("value");

valueElement->addNode(std::make_shared<XMLTextNode>(value));

fieldElement->addNode(valueElement);

}

std::shared_ptr<XMLElement> optionElement(new XMLElement("option"));

if (!option.label.empty()) {

optionElement->setAttribute("label", option.label);

}

std::shared_ptr<XMLElement> valueElement(new XMLElement("value"));

valueElement->addNode(XMLTextNode::create(option.value));

optionElement->addNode(valueElement);

fieldElement->addNode(optionElement);

}

return fieldElement;

}

void FormSerializer::multiLineify(const std::string& text, const std::string& elementName, std::shared_ptr<XMLElement> element) const {

std::string unRdText(text);

erase(unRdText, '\r');

std::vector<std::string> lines = String::split(unRdText, '\n');

std::shared_ptr<XMLElement> lineElement(new XMLElement(elementName));

lineElement->addNode(std::make_shared<XMLTextNode>(line));

element->addNode(lineElement);

}

}

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/FullPayloadSerializerCollection.h>

#include <Swiften/Elements/BlockListPayload.h>

#include <Swiften/Elements/BlockPayload.h>

#include <Swiften/Elements/UnblockPayload.h>

#include <Swiften/Serializer/PayloadSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/BlockSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/BodySerializer.h>

#include <Swiften/Serializer/PayloadSerializers/BytestreamsSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/CapsInfoSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/CarbonsDisableSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/CarbonsEnableSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/CarbonsPrivateSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/CarbonsReceivedSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/CarbonsSentSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/ChatStateSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/CommandSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/DelaySerializer.h>

#include <Swiften/Serializer/PayloadSerializers/DeliveryReceiptRequestSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/DeliveryReceiptSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/DiscoInfoSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/DiscoItemsSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/ErrorSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/FormSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/ForwardedSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/IBBSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/IdleSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/InBandRegistrationPayloadSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/IsodeIQDelegationSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/JingleContentPayloadSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/JingleFileTransferDescriptionSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/JingleFileTransferFileInfoSerializer.h>

serializers_.push_back(new JingleFileTransferFileInfoSerializer());

serializers_.push_back(new JingleContentPayloadSerializer());

serializers_.push_back(new JingleFileTransferDescriptionSerializer());

serializers_.push_back(new JingleFileTransferHashSerializer());

serializers_.push_back(new JingleIBBTransportPayloadSerializer());

serializers_.push_back(new JingleS5BTransportPayloadSerializer());

serializers_.push_back(new JinglePayloadSerializer(this));

serializers_.push_back(new S5BProxyRequestSerializer());

serializers_.push_back(new DeliveryReceiptSerializer());

serializers_.push_back(new DeliveryReceiptRequestSerializer());

serializers_.push_back(new PubSubSerializer(this));

serializers_.push_back(new PubSubEventSerializer(this));

serializers_.push_back(new PubSubOwnerPubSubSerializer(this));

serializers_.push_back(new PubSubErrorSerializer());

serializers_.push_back(new ResultSetSerializer());

serializers_.push_back(new ForwardedSerializer(this));

serializers_.push_back(new MAMResultSerializer(this));

serializers_.push_back(new MAMQuerySerializer());

serializers_.push_back(new MAMFinSerializer());

serializers_.push_back(new CarbonsDisableSerializer());

serializers_.push_back(new CarbonsEnableSerializer());

serializers_.push_back(new CarbonsPrivateSerializer());

serializers_.push_back(new CarbonsReceivedSerializer(this));

serializers_.push_back(new CarbonsSentSerializer(this));

serializers_.push_back(new IsodeIQDelegationSerializer(this));

addSerializer(serializer);

}

}

FullPayloadSerializerCollection::~FullPayloadSerializerCollection() {

removeSerializer(serializer);

delete serializer;

}

serializers_.clear();

}

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/IBBSerializer.h>

#include <cassert>

#include <memory>

#include <boost/lexical_cast.hpp>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

#include <Swiften/StringCodecs/Base64.h>

namespace Swift {

IBBSerializer::IBBSerializer() {

}

std::string IBBSerializer::serializePayload(std::shared_ptr<IBB> ibb) const {

switch(ibb->getAction()) {

case IBB::Data: {

XMLElement ibbElement("data", "http://jabber.org/protocol/ibb");

ibbElement.setAttribute("sid", ibb->getStreamID());

if (ibb->getSequenceNumber() >= 0) {

ibbElement.setAttribute("seq", boost::lexical_cast<std::string>(ibb->getSequenceNumber()));

}

ibbElement.addNode(std::make_shared<XMLTextNode>(Base64::encode(ibb->getData())));

return ibbElement.serialize();

}

case IBB::Open: {

XMLElement ibbElement("open", "http://jabber.org/protocol/ibb");

ibbElement.setAttribute("sid", ibb->getStreamID());

switch (ibb->getStanzaType()) {

case IBB::IQStanza: ibbElement.setAttribute("stanza", "iq"); break;

case IBB::MessageStanza: ibbElement.setAttribute("stanza", "message"); break;

}

assert(ibb->getBlockSize() > 0);

ibbElement.setAttribute("block-size", boost::lexical_cast<std::string>(ibb->getBlockSize()));

return ibbElement.serialize();

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/InBandRegistrationPayloadSerializer.h>

#include <memory>

#include <Swiften/Serializer/PayloadSerializers/FormSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

namespace Swift {

InBandRegistrationPayloadSerializer::InBandRegistrationPayloadSerializer() {

}

std::string InBandRegistrationPayloadSerializer::serializePayload(std::shared_ptr<InBandRegistrationPayload> registration) const {

XMLElement registerElement("query", "jabber:iq:register");

if (registration->isRegistered()) {

registerElement.addNode(XMLElement::ref(new XMLElement("registered")));

}

if (registration->isRemove()) {

registerElement.addNode(XMLElement::ref(new XMLElement("remove")));

}

if (registration->getInstructions()) {

registerElement.addNode(XMLElement::ref(new XMLElement("instructions", "", *registration->getInstructions())));

}

if (registration->getUsername()) {

registerElement.addNode(XMLElement::ref(new XMLElement("username", "", *registration->getUsername())));

}

if (registration->getNick()) {

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the simplified BSD license.

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

*/

/*

* Copyright (c) 2014-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/JingleContentPayloadSerializer.h>

#include <memory>

#include <Swiften/Base/Log.h>

#include <Swiften/Serializer/PayloadSerializers/JingleFileTransferDescriptionSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/JingleIBBTransportPayloadSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/JingleS5BTransportPayloadSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLNode.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

namespace Swift {

JingleContentPayloadSerializer::JingleContentPayloadSerializer() {

}

std::string JingleContentPayloadSerializer::serializePayload(std::shared_ptr<JingleContentPayload> payload) const {

XMLElement payloadXML("content");

payloadXML.setAttribute("creator", creatorToString(payload->getCreator()));

payloadXML.setAttribute("name", payload->getName());

if (!payload->getDescriptions().empty()) {

// JingleFileTransferDescription

JingleFileTransferDescriptionSerializer ftSerializer;

JingleFileTransferDescription::ref filetransfer;

if ((filetransfer = std::dynamic_pointer_cast<JingleFileTransferDescription>(desc))) {

payloadXML.addNode(std::make_shared<XMLRawTextNode>(ftSerializer.serializePayload(filetransfer)));

}

}

}

if (!payload->getTransports().empty()) {

// JingleIBBTransportPayload

JingleIBBTransportPayloadSerializer ibbSerializer;

JingleIBBTransportPayload::ref ibb;

// JingleS5BTransportPayload

JingleS5BTransportPayloadSerializer s5bSerializer;

JingleS5BTransportPayload::ref s5b;

if ((ibb = std::dynamic_pointer_cast<JingleIBBTransportPayload>(transport))) {

payloadXML.addNode(std::make_shared<XMLRawTextNode>(ibbSerializer.serializePayload(ibb)));

} else if ((s5b = std::dynamic_pointer_cast<JingleS5BTransportPayload>(transport))) {

payloadXML.addNode(std::make_shared<XMLRawTextNode>(s5bSerializer.serializePayload(s5b)));

}

}

}

return payloadXML.serialize();

}

std::string JingleContentPayloadSerializer::creatorToString(JingleContentPayload::Creator creator) const {

switch(creator) {

case JingleContentPayload::InitiatorCreator:

return "initiator";

case JingleContentPayload::ResponderCreator:

return "responder";

case JingleContentPayload::UnknownCreator:

SWIFT_LOG(error) << "Serializing unknown creator value.";

return "ERROR ERROR ERROR";

}

assert(false);

return "";

}

}

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the simplified BSD license.

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

*/

/*

* Copyright (c) 2015-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/JingleFileTransferDescriptionSerializer.h>

#include <memory>

#include <boost/lexical_cast.hpp>

#include <Swiften/Base/DateTime.h>

#include <Swiften/Serializer/PayloadSerializers/JingleFileTransferFileInfoSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLNode.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

#include <Swiften/StringCodecs/Base64.h>

namespace Swift {

JingleFileTransferDescriptionSerializer::JingleFileTransferDescriptionSerializer() {

}

std::string JingleFileTransferDescriptionSerializer::serializePayload(std::shared_ptr<JingleFileTransferDescription> payload) const {

XMLElement description("description", "urn:xmpp:jingle:apps:file-transfer:4");

JingleFileTransferFileInfoSerializer fileInfoSerializer;

std::shared_ptr<XMLRawTextNode> fileInfoXML = std::make_shared<XMLRawTextNode>(fileInfoSerializer.serialize(std::make_shared<JingleFileTransferFileInfo>(payload->getFileInfo())));

description.addNode(fileInfoXML);

return description.serialize();

}

}

/*

* Copyright (c) 2014-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/JingleFileTransferFileInfoSerializer.h>

#include <memory>

#include <boost/lexical_cast.hpp>

#include <Swiften/Base/DateTime.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

#include <Swiften/StringCodecs/Base64.h>

namespace Swift {

JingleFileTransferFileInfoSerializer::JingleFileTransferFileInfoSerializer() {

}

std::string JingleFileTransferFileInfoSerializer::serializePayload(std::shared_ptr<JingleFileTransferFileInfo> fileInfo) const {

XMLElement fileElement("file", "");

if (fileInfo->getDate() != stringToDateTime("")) {

fileElement.addNode(std::make_shared<XMLElement>("date", "", dateTimeToString(fileInfo->getDate())));

}

if (!fileInfo->getDescription().empty()) {

fileElement.addNode(std::make_shared<XMLElement>("desc", "", fileInfo->getDescription()));

}

if (!fileInfo->getMediaType().empty()) {

fileElement.addNode(std::make_shared<XMLElement>("media-type", "", fileInfo->getMediaType()));

}

if (!fileInfo->getName().empty()) {

fileElement.addNode(std::make_shared<XMLElement>("name", "", fileInfo->getName()));

}

if (fileInfo->getSupportsRangeRequests()) {

std::shared_ptr<XMLElement> range = std::make_shared<XMLElement>("range");

if (fileInfo->getRangeOffset() != 0) {

range->setAttribute("offset", boost::lexical_cast<std::string>(fileInfo->getRangeOffset()));

}

fileElement.addNode(range);

}

if (fileInfo->getSize() > 0) {

fileElement.addNode(std::make_shared<XMLElement>("size", "", boost::lexical_cast<std::string>(fileInfo->getSize())));

}

std::shared_ptr<XMLElement> hash = std::make_shared<XMLElement>("hash", "urn:xmpp:hashes:1", Base64::encode(hashElement.second));

hash->setAttribute("algo", hashElement.first);

fileElement.addNode(hash);

}

return fileElement.serialize();

}

}

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the simplified BSD license.

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

*/

/*

* Copyright (c) 2015-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/JingleFileTransferHashSerializer.h>

#include <map>

#include <memory>

#include <string>

#include <Swiften/Serializer/PayloadSerializers/JingleFileTransferFileInfoSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLNode.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

namespace Swift {

JingleFileTransferHashSerializer::JingleFileTransferHashSerializer() {

}

std::string JingleFileTransferHashSerializer::serializePayload(std::shared_ptr<JingleFileTransferHash> payload) const {

// code for version urn:xmpp:jingle:apps:file-transfer:2

//XMLElement hash("hash", "urn:xmpp:jingle:apps:file-transfer:info:2", payload->getHash());

// code for version urn:xmpp:jingle:apps:file-transfer:4

XMLElement checksum("checksum", "urn:xmpp:jingle:apps:file-transfer:4");

JingleFileTransferFileInfoSerializer fileSerializer;

std::shared_ptr<XMLRawTextNode> file = std::make_shared<XMLRawTextNode>(fileSerializer.serialize(std::make_shared<JingleFileTransferFileInfo>(payload->getFileInfo())));

checksum.addNode(file);

return checksum.serialize();

}

}

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the simplified BSD license.

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

*/

/*

* Copyright (c) 2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/JingleIBBTransportPayloadSerializer.h>

#include <memory>

#include <boost/lexical_cast.hpp>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLNode.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

namespace Swift {

JingleIBBTransportPayloadSerializer::JingleIBBTransportPayloadSerializer() {

}

std::string JingleIBBTransportPayloadSerializer::serializePayload(std::shared_ptr<JingleIBBTransportPayload> payload) const {

XMLElement payloadXML("transport", "urn:xmpp:jingle:transports:ibb:1");

if (payload->getBlockSize()) {

payloadXML.setAttribute("block-size", boost::lexical_cast<std::string>(*payload->getBlockSize()));

}

payloadXML.setAttribute("sid", payload->getSessionID());

return payloadXML.serialize();

}

}

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the simplified BSD license.

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

*/

/*

* Copyright (c) 2015-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/JinglePayloadSerializer.h>

#include <memory>

#include <Swiften/Base/Log.h>

#include <Swiften/Elements/JingleContentPayload.h>

#include <Swiften/Elements/JingleFileTransferDescription.h>

#include <Swiften/Elements/JingleFileTransferHash.h>

#include <Swiften/Elements/JingleIBBTransportPayload.h>

#include <Swiften/Elements/JinglePayload.h>

#include <Swiften/Serializer/PayloadSerializerCollection.h>

#include <Swiften/Serializer/PayloadSerializers/JingleContentPayloadSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/JingleFileTransferHashSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLNode.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

namespace Swift {

JinglePayloadSerializer::JinglePayloadSerializer(PayloadSerializerCollection* serializers) : serializers(serializers) {

}

std::string JinglePayloadSerializer::serializePayload(std::shared_ptr<JinglePayload> payload) const {

XMLElement jinglePayload("jingle", "urn:xmpp:jingle:1");

jinglePayload.setAttribute("action", actionToString(payload->getAction()));

jinglePayload.setAttribute("initiator", payload->getInitiator());

jinglePayload.setAttribute("sid", payload->getSessionID());

std::vector<std::shared_ptr<Payload> > payloads = payload->getPayloads();

if (!payloads.empty()) {

PayloadSerializer* serializer = serializers->getPayloadSerializer(subPayload);

if (serializer) {

jinglePayload.addNode(std::make_shared<XMLRawTextNode>(serializer->serialize(subPayload)));

}

}

}

if (payload->getReason().is_initialized()) {

std::shared_ptr<XMLElement> reason = std::make_shared<XMLElement>("reason");

reason->addNode(std::make_shared<XMLElement>(reasonTypeToString(payload->getReason()->type)));

if (!payload->getReason()->text.empty()) {

reason->addNode(std::make_shared<XMLElement>("desc", "", payload->getReason()->text));

}

jinglePayload.addNode(reason);

}

return jinglePayload.serialize();

}

std::string JinglePayloadSerializer::actionToString(JinglePayload::Action action) const {

switch(action) {

case JinglePayload::ContentAccept:

return "content-accept";

case JinglePayload::ContentAdd:

return "content-add";

case JinglePayload::ContentModify:

return "content-modify";

case JinglePayload::ContentReject:

return "content-reject";

case JinglePayload::ContentRemove:

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the simplified BSD license.

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

*/

/*

* Copyright (c) 2015-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/JingleS5BTransportPayloadSerializer.h>

#include <memory>

#include <boost/lexical_cast.hpp>

#include <Swiften/Base/Log.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLNode.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

namespace Swift {

JingleS5BTransportPayloadSerializer::JingleS5BTransportPayloadSerializer() {

}

std::string JingleS5BTransportPayloadSerializer::serializePayload(std::shared_ptr<JingleS5BTransportPayload> payload) const {

XMLElement payloadXML("transport", "urn:xmpp:jingle:transports:s5b:1");

payloadXML.setAttribute("sid", payload->getSessionID());

payloadXML.setAttribute("mode", modeToString(payload->getMode()));

if (!payload->getDstAddr().empty()) {

payloadXML.setAttribute("dstaddr", payload->getDstAddr());

}

std::shared_ptr<XMLElement> candidateXML = std::make_shared<XMLElement>("candidate");

candidateXML->setAttribute("cid", candidate.cid);

candidateXML->setAttribute("host", candidate.hostPort.getAddress().toString());

candidateXML->setAttribute("jid", candidate.jid.toString());

candidateXML->setAttribute("port", boost::lexical_cast<std::string>(candidate.hostPort.getPort()));

candidateXML->setAttribute("priority", boost::lexical_cast<std::string>(candidate.priority));

candidateXML->setAttribute("type", typeToString(candidate.type));

payloadXML.addNode(candidateXML);

}

if (payload->hasCandidateError()) {

payloadXML.addNode(std::make_shared<XMLElement>("candidate-error"));

}

if (payload->hasProxyError()) {

payloadXML.addNode(std::make_shared<XMLElement>("proxy-error"));

}

if (!payload->getActivated().empty()) {

std::shared_ptr<XMLElement> activatedXML = std::make_shared<XMLElement>("activated");

activatedXML->setAttribute("cid", payload->getActivated());

payloadXML.addNode(activatedXML);

}

if (!payload->getCandidateUsed().empty()) {

std::shared_ptr<XMLElement> candusedXML = std::make_shared<XMLElement>("candidate-used");

candusedXML->setAttribute("cid", payload->getCandidateUsed());

payloadXML.addNode(candusedXML);

}

return payloadXML.serialize();

}

/*

* Copyright (c) 2011-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/MUCAdminPayloadSerializer.h>

#include <memory>

#include <sstream>

#include <Swiften/Serializer/PayloadSerializers/MUCItemSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

namespace Swift {

MUCAdminPayloadSerializer::MUCAdminPayloadSerializer() : GenericPayloadSerializer<MUCAdminPayload>() {

}

std::string MUCAdminPayloadSerializer::serializePayload(std::shared_ptr<MUCAdminPayload> payload) const {

XMLElement mucElement("query", "http://jabber.org/protocol/muc#admin");

mucElement.addNode(MUCItemSerializer::itemToElement(item));

}

return mucElement.serialize();

}

}

/*

* Copyright (c) 2011-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/MUCDestroyPayloadSerializer.h>

#include <memory>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

namespace Swift {

MUCDestroyPayloadSerializer::MUCDestroyPayloadSerializer() : GenericPayloadSerializer<MUCDestroyPayload>() {

}

std::string MUCDestroyPayloadSerializer::serializePayload(std::shared_ptr<MUCDestroyPayload> payload) const {

XMLElement mucElement("destroy", "");

if (!payload->getReason().empty()) {

XMLElement::ref reason = std::make_shared<XMLElement>("reason", "");

reason->addNode(std::make_shared<XMLTextNode>(payload->getReason()));

mucElement.addNode(reason);

}

if (payload->getNewVenue().isValid()) {

mucElement.setAttribute("jid", payload->getNewVenue().toString());

}

return mucElement.serialize();

}

}

/*

* Copyright (c) 2011-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/MUCInvitationPayloadSerializer.h>

#include <memory>

#include <Swiften/Serializer/PayloadSerializers/MUCItemSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

namespace Swift {

MUCInvitationPayloadSerializer::MUCInvitationPayloadSerializer() : GenericPayloadSerializer<MUCInvitationPayload>() {

}

std::string MUCInvitationPayloadSerializer::serializePayload(std::shared_ptr<MUCInvitationPayload> payload) const {

XMLElement mucElement("x", "jabber:x:conference");

if (payload->getIsContinuation()) {

mucElement.setAttribute("continue", "true");

}

if (payload->getJID().isValid()) {

mucElement.setAttribute("jid", payload->getJID().toString());

}

if (!payload->getPassword().empty()) {

mucElement.setAttribute("password", payload->getPassword());

}

if (!payload->getReason().empty()) {

mucElement.setAttribute("reason", payload->getReason());

}

if (!payload->getThread().empty()) {

mucElement.setAttribute("thread", payload->getThread());

}

if (payload->getIsImpromptu()) {

mucElement.addNode(std::make_shared<XMLElement>("impromptu", "http://swift.im/impromptu"));

}

return mucElement.serialize();

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/MUCUserPayloadSerializer.h>

#include <memory>

#include <sstream>

#include <Swiften/Serializer/PayloadSerializerCollection.h>

#include <Swiften/Serializer/PayloadSerializers/MUCItemSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

namespace Swift {

MUCUserPayloadSerializer::MUCUserPayloadSerializer(PayloadSerializerCollection* serializers) : GenericPayloadSerializer<MUCUserPayload>(), serializers(serializers) {

}

std::string MUCUserPayloadSerializer::serializePayload(std::shared_ptr<MUCUserPayload> payload) const {

XMLElement mucElement("x", "http://jabber.org/protocol/muc#user");

std::shared_ptr<XMLElement> statusElement(new XMLElement("status"));

std::ostringstream code;

code << statusCode.code;

statusElement->setAttribute("code", code.str());

mucElement.addNode(statusElement);

}

mucElement.addNode(MUCItemSerializer::itemToElement(item));

}

if (payload->getPassword()) {

std::shared_ptr<XMLElement> passwordElement = std::make_shared<XMLElement>("password");

passwordElement->addNode(std::make_shared<XMLTextNode>(*payload->getPassword()));

}

if (payload->getInvite()) {

MUCUserPayload::Invite invite = *payload->getInvite();

std::shared_ptr<XMLElement> inviteElement = std::make_shared<XMLElement>("invite");

if (invite.to.isValid()) {

inviteElement->setAttribute("to", invite.to.toString());

}

if (invite.from.isValid()) {

inviteElement->setAttribute("from", invite.from.toString());

}

if (!invite.reason.empty()) {

std::shared_ptr<XMLElement> reasonElement = std::make_shared<XMLElement>("reason");

reasonElement->addNode(std::make_shared<XMLTextNode>(invite.reason));

}

mucElement.addNode(inviteElement);

}

std::shared_ptr<Payload> childPayload = payload->getPayload();

if (childPayload) {

PayloadSerializer* serializer = serializers->getPayloadSerializer(childPayload);

if (serializer) {

mucElement.addNode(std::make_shared<XMLRawTextNode>(serializer->serialize(childPayload)));

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/PrivateStorageSerializer.h>

#include <memory>

#include <Swiften/Serializer/PayloadSerializerCollection.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

namespace Swift {

PrivateStorageSerializer::PrivateStorageSerializer(PayloadSerializerCollection* serializers) : serializers(serializers) {

}

std::string PrivateStorageSerializer::serializePayload(std::shared_ptr<PrivateStorage> storage) const {

XMLElement storageElement("query", "jabber:iq:private");

std::shared_ptr<Payload> payload = storage->getPayload();

if (payload) {

PayloadSerializer* serializer = serializers->getPayloadSerializer(payload);

if (serializer) {

storageElement.addNode(std::make_shared<XMLRawTextNode>(serializer->serialize(payload)));

}

}

return storageElement.serialize();

}

}

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/PubSubAffiliationsSerializer.h>

#include <memory>

#include <Swiften/Serializer/PayloadSerializerCollection.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubAffiliationSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

using namespace Swift;

PubSubAffiliationsSerializer::PubSubAffiliationsSerializer(PayloadSerializerCollection* serializers) : serializers(serializers) {

}

PubSubAffiliationsSerializer::~PubSubAffiliationsSerializer() {

}

std::string PubSubAffiliationsSerializer::serializePayload(std::shared_ptr<PubSubAffiliations> payload) const {

if (!payload) {

return "";

}

XMLElement element("affiliations", "http://jabber.org/protocol/pubsub");

if (payload->getNode()) {

element.setAttribute("node", *payload->getNode());

}

element.addNode(std::make_shared<XMLRawTextNode>(PubSubAffiliationSerializer(serializers).serialize(item)));

}

return element.serialize();

}

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/PubSubEventItemSerializer.h>

#include <memory>

#include <Swiften/Serializer/PayloadSerializerCollection.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

using namespace Swift;

PubSubEventItemSerializer::PubSubEventItemSerializer(PayloadSerializerCollection* serializers) : serializers(serializers) {

}

PubSubEventItemSerializer::~PubSubEventItemSerializer() {

}

std::string PubSubEventItemSerializer::serializePayload(std::shared_ptr<PubSubEventItem> payload) const {

if (!payload) {

return "";

}

XMLElement element("item", "http://jabber.org/protocol/pubsub#event");

if (payload->getNode()) {

element.setAttribute("node", *payload->getNode());

}

if (payload->getPublisher()) {

element.setAttribute("publisher", *payload->getPublisher());

}

element.addNode(std::make_shared<XMLRawTextNode>(serializers->getPayloadSerializer(item)->serialize(item)));

}

if (payload->getID()) {

element.setAttribute("id", *payload->getID());

}

return element.serialize();

}

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/PubSubEventItemsSerializer.h>

#include <memory>

#include <Swiften/Serializer/PayloadSerializerCollection.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubEventItemSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubEventRetractSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

using namespace Swift;

PubSubEventItemsSerializer::PubSubEventItemsSerializer(PayloadSerializerCollection* serializers) : serializers(serializers) {

}

PubSubEventItemsSerializer::~PubSubEventItemsSerializer() {

}

std::string PubSubEventItemsSerializer::serializePayload(std::shared_ptr<PubSubEventItems> payload) const {

if (!payload) {

return "";

}

XMLElement element("items", "http://jabber.org/protocol/pubsub#event");

element.setAttribute("node", payload->getNode());

element.addNode(std::make_shared<XMLRawTextNode>(PubSubEventItemSerializer(serializers).serialize(item)));

}

element.addNode(std::make_shared<XMLRawTextNode>(PubSubEventRetractSerializer(serializers).serialize(item)));

}

return element.serialize();

}

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/PubSubEventSerializer.h>

#include <memory>

#include <Swiften/Serializer/PayloadSerializers/PubSubEventCollectionSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubEventConfigurationSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubEventDeleteSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubEventItemsSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubEventPurgeSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubEventSubscriptionSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

using namespace Swift;

PubSubEventSerializer::PubSubEventSerializer(PayloadSerializerCollection* serializers) {

pubsubSerializers.push_back(std::make_shared<PubSubEventSubscriptionSerializer>(serializers));

pubsubSerializers.push_back(std::make_shared<PubSubEventPurgeSerializer>(serializers));

pubsubSerializers.push_back(std::make_shared<PubSubEventCollectionSerializer>(serializers));

pubsubSerializers.push_back(std::make_shared<PubSubEventDeleteSerializer>(serializers));

pubsubSerializers.push_back(std::make_shared<PubSubEventItemsSerializer>(serializers));

pubsubSerializers.push_back(std::make_shared<PubSubEventConfigurationSerializer>(serializers));

}

PubSubEventSerializer::~PubSubEventSerializer() {

}

std::string PubSubEventSerializer::serializePayload(std::shared_ptr<PubSubEvent> payload) const {

if (!payload) {

return "";

}

XMLElement element("event", "http://jabber.org/protocol/pubsub#event");

std::shared_ptr<PubSubEventPayload> p = payload->getPayload();

if (serializer->canSerialize(p)) {

element.addNode(std::make_shared<XMLRawTextNode>(serializer->serialize(p)));

}

}

return element.serialize();

}

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/PubSubItemSerializer.h>

#include <memory>

#include <Swiften/Serializer/PayloadSerializerCollection.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

using namespace Swift;

PubSubItemSerializer::PubSubItemSerializer(PayloadSerializerCollection* serializers) : serializers(serializers) {

}

PubSubItemSerializer::~PubSubItemSerializer() {

}

std::string PubSubItemSerializer::serializePayload(std::shared_ptr<PubSubItem> payload) const {

if (!payload) {

return "";

}

XMLElement element("item", "http://jabber.org/protocol/pubsub");

element.addNode(std::make_shared<XMLRawTextNode>(serializers->getPayloadSerializer(item)->serialize(item)));

}

if (!payload->getID().empty()) {

element.setAttribute("id", payload->getID());

}

return element.serialize();

}

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/PubSubItemsSerializer.h>

#include <memory>

#include <boost/lexical_cast.hpp>

#include <Swiften/Base/Log.h>

#include <Swiften/Serializer/PayloadSerializerCollection.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubItemSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

using namespace Swift;

PubSubItemsSerializer::PubSubItemsSerializer(PayloadSerializerCollection* serializers) : serializers(serializers) {

}

PubSubItemsSerializer::~PubSubItemsSerializer() {

}

std::string PubSubItemsSerializer::serializePayload(std::shared_ptr<PubSubItems> payload) const {

if (!payload) {

return "";

}

XMLElement element("items", "http://jabber.org/protocol/pubsub");

if (payload->getNode().empty()) {

SWIFT_LOG(warning) << "Serializing PubSubItems with empty node attribute";

}

element.setAttribute("node", payload->getNode());

element.addNode(std::make_shared<XMLRawTextNode>(PubSubItemSerializer(serializers).serialize(item)));

}

if (payload->getMaximumItems()) {

element.setAttribute("max_items", boost::lexical_cast<std::string>(*payload->getMaximumItems()));

}

if (payload->getSubscriptionID()) {

element.setAttribute("subid", *payload->getSubscriptionID());

}

return element.serialize();

}

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/PubSubOwnerAffiliationsSerializer.h>

#include <memory>

#include <Swiften/Serializer/PayloadSerializerCollection.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubOwnerAffiliationSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

using namespace Swift;

PubSubOwnerAffiliationsSerializer::PubSubOwnerAffiliationsSerializer(PayloadSerializerCollection* serializers) : serializers(serializers) {

}

PubSubOwnerAffiliationsSerializer::~PubSubOwnerAffiliationsSerializer() {

}

std::string PubSubOwnerAffiliationsSerializer::serializePayload(std::shared_ptr<PubSubOwnerAffiliations> payload) const {

if (!payload) {

return "";

}

XMLElement element("affiliations", "http://jabber.org/protocol/pubsub#owner");

element.setAttribute("node", payload->getNode());

element.addNode(std::make_shared<XMLRawTextNode>(PubSubOwnerAffiliationSerializer(serializers).serialize(item)));

}

return element.serialize();

}

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/PubSubOwnerPubSubSerializer.h>

#include <memory>

#include <Swiften/Serializer/PayloadSerializers/PubSubOwnerAffiliationsSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubOwnerConfigureSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubOwnerDefaultSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubOwnerDeleteSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubOwnerPurgeSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubOwnerSubscriptionsSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

using namespace Swift;

PubSubOwnerPubSubSerializer::PubSubOwnerPubSubSerializer(PayloadSerializerCollection* serializers) {

pubsubSerializers.push_back(std::make_shared<PubSubOwnerConfigureSerializer>(serializers));

pubsubSerializers.push_back(std::make_shared<PubSubOwnerSubscriptionsSerializer>(serializers));

pubsubSerializers.push_back(std::make_shared<PubSubOwnerDefaultSerializer>(serializers));

pubsubSerializers.push_back(std::make_shared<PubSubOwnerPurgeSerializer>(serializers));

pubsubSerializers.push_back(std::make_shared<PubSubOwnerAffiliationsSerializer>(serializers));

pubsubSerializers.push_back(std::make_shared<PubSubOwnerDeleteSerializer>(serializers));

}

PubSubOwnerPubSubSerializer::~PubSubOwnerPubSubSerializer() {

}

std::string PubSubOwnerPubSubSerializer::serializePayload(std::shared_ptr<PubSubOwnerPubSub> payload) const {

if (!payload) {

return "";

}

XMLElement element("pubsub", "http://jabber.org/protocol/pubsub#owner");

std::shared_ptr<PubSubOwnerPayload> p = payload->getPayload();

if (serializer->canSerialize(p)) {

element.addNode(std::make_shared<XMLRawTextNode>(serializer->serialize(p)));

}

}

return element.serialize();

}

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/PubSubOwnerSubscriptionsSerializer.h>

#include <memory>

#include <Swiften/Serializer/PayloadSerializerCollection.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubOwnerSubscriptionSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

using namespace Swift;

PubSubOwnerSubscriptionsSerializer::PubSubOwnerSubscriptionsSerializer(PayloadSerializerCollection* serializers) : serializers(serializers) {

}

PubSubOwnerSubscriptionsSerializer::~PubSubOwnerSubscriptionsSerializer() {

}

std::string PubSubOwnerSubscriptionsSerializer::serializePayload(std::shared_ptr<PubSubOwnerSubscriptions> payload) const {

if (!payload) {

return "";

}

XMLElement element("subscriptions", "http://jabber.org/protocol/pubsub#owner");

element.setAttribute("node", payload->getNode());

element.addNode(std::make_shared<XMLRawTextNode>(PubSubOwnerSubscriptionSerializer(serializers).serialize(item)));

}

return element.serialize();

}

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/PubSubPublishSerializer.h>

#include <memory>

#include <Swiften/Serializer/PayloadSerializerCollection.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubItemSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

using namespace Swift;

PubSubPublishSerializer::PubSubPublishSerializer(PayloadSerializerCollection* serializers) : serializers(serializers) {

}

PubSubPublishSerializer::~PubSubPublishSerializer() {

}

std::string PubSubPublishSerializer::serializePayload(std::shared_ptr<PubSubPublish> payload) const {

if (!payload) {

return "";

}

XMLElement element("publish", "http://jabber.org/protocol/pubsub");

element.setAttribute("node", payload->getNode());

element.addNode(std::make_shared<XMLRawTextNode>(PubSubItemSerializer(serializers).serialize(item)));

}

return element.serialize();

}

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/PubSubRetractSerializer.h>

#include <memory>

#include <Swiften/Serializer/PayloadSerializerCollection.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubItemSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

using namespace Swift;

PubSubRetractSerializer::PubSubRetractSerializer(PayloadSerializerCollection* serializers) : serializers(serializers) {

}

PubSubRetractSerializer::~PubSubRetractSerializer() {

}

std::string PubSubRetractSerializer::serializePayload(std::shared_ptr<PubSubRetract> payload) const {

if (!payload) {

return "";

}

XMLElement element("retract", "http://jabber.org/protocol/pubsub");

element.setAttribute("node", payload->getNode());

element.addNode(std::make_shared<XMLRawTextNode>(PubSubItemSerializer(serializers).serialize(item)));

}

if (payload->isNotify().is_initialized()) {

element.setAttribute("notify", payload->isNotify().get() ? "true" : "false");

}

return element.serialize();

}

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/PubSubSerializer.h>

#include <memory>

#include <Swiften/Serializer/PayloadSerializerCollection.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubAffiliationsSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubConfigureSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubCreateSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubDefaultSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubItemsSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubOptionsSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubPublishSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubRetractSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubSubscribeSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubSubscriptionSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubSubscriptionsSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubUnsubscribeSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

using namespace Swift;

PubSubSerializer::PubSubSerializer(PayloadSerializerCollection* serializers) : serializers(serializers) {

pubsubSerializers.push_back(std::make_shared<PubSubItemsSerializer>(serializers));

pubsubSerializers.push_back(std::make_shared<PubSubCreateSerializer>(serializers));

pubsubSerializers.push_back(std::make_shared<PubSubPublishSerializer>(serializers));

pubsubSerializers.push_back(std::make_shared<PubSubOptionsSerializer>(serializers));

pubsubSerializers.push_back(std::make_shared<PubSubAffiliationsSerializer>(serializers));

pubsubSerializers.push_back(std::make_shared<PubSubRetractSerializer>(serializers));

pubsubSerializers.push_back(std::make_shared<PubSubDefaultSerializer>(serializers));

pubsubSerializers.push_back(std::make_shared<PubSubSubscriptionsSerializer>(serializers));

pubsubSerializers.push_back(std::make_shared<PubSubSubscribeSerializer>(serializers));

pubsubSerializers.push_back(std::make_shared<PubSubUnsubscribeSerializer>(serializers));

pubsubSerializers.push_back(std::make_shared<PubSubSubscriptionSerializer>(serializers));

}

PubSubSerializer::~PubSubSerializer() {

}

std::string PubSubSerializer::serializePayload(std::shared_ptr<PubSub> payload) const {

if (!payload) {

return "";

}

XMLElement element("pubsub", "http://jabber.org/protocol/pubsub");

std::shared_ptr<PubSubPayload> p = payload->getPayload();

if (serializer->canSerialize(p)) {

element.addNode(std::make_shared<XMLRawTextNode>(serializer->serialize(p)));

if (std::shared_ptr<PubSubCreate> create = std::dynamic_pointer_cast<PubSubCreate>(p)) {

element.addNode(std::make_shared<XMLRawTextNode>(std::make_shared<PubSubConfigureSerializer>(serializers)->serialize(create->getConfigure())));

}

if (std::shared_ptr<PubSubSubscribe> subscribe = std::dynamic_pointer_cast<PubSubSubscribe>(p)) {

element.addNode(std::make_shared<XMLRawTextNode>(std::make_shared<PubSubConfigureSerializer>(serializers)->serialize(subscribe->getOptions())));

}

}

}

return element.serialize();

}

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/PubSubSubscriptionsSerializer.h>

#include <memory>

#include <Swiften/Serializer/PayloadSerializerCollection.h>

#include <Swiften/Serializer/PayloadSerializers/PubSubSubscriptionSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

using namespace Swift;

PubSubSubscriptionsSerializer::PubSubSubscriptionsSerializer(PayloadSerializerCollection* serializers) : serializers(serializers) {

}

PubSubSubscriptionsSerializer::~PubSubSubscriptionsSerializer() {

}

std::string PubSubSubscriptionsSerializer::serializePayload(std::shared_ptr<PubSubSubscriptions> payload) const {

if (!payload) {

return "";

}

XMLElement element("subscriptions", "http://jabber.org/protocol/pubsub");

if (payload->getNode()) {

element.setAttribute("node", *payload->getNode());

}

element.addNode(std::make_shared<XMLRawTextNode>(PubSubSubscriptionSerializer(serializers).serialize(item)));

}

return element.serialize();

}

/*

* Copyright (c) 2011 Jan Kaluza

* Licensed under the Simplified BSD license.

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

*/

/*

* Copyright (c) 2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/RosterItemExchangeSerializer.h>

#include <memory>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

namespace Swift {

RosterItemExchangeSerializer::RosterItemExchangeSerializer() : GenericPayloadSerializer<RosterItemExchangePayload>() {

}

std::string RosterItemExchangeSerializer::serializePayload(std::shared_ptr<RosterItemExchangePayload> roster) const {

XMLElement queryElement("x", "http://jabber.org/protocol/rosterx");

std::shared_ptr<XMLElement> itemElement(new XMLElement("item"));

itemElement->setAttribute("jid", item.getJID());

itemElement->setAttribute("name", item.getName());

switch (item.getAction()) {

case RosterItemExchangePayload::Item::Add: itemElement->setAttribute("action", "add"); break;

case RosterItemExchangePayload::Item::Modify: itemElement->setAttribute("action", "modify"); break;

case RosterItemExchangePayload::Item::Delete: itemElement->setAttribute("action", "delete"); break;

}

std::shared_ptr<XMLElement> groupElement(new XMLElement("group"));

groupElement->addNode(std::make_shared<XMLTextNode>(group));

itemElement->addNode(groupElement);

}

queryElement.addNode(itemElement);

}

return queryElement.serialize();

}

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/RosterSerializer.h>

#include <memory>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

namespace Swift {

RosterSerializer::RosterSerializer() : GenericPayloadSerializer<RosterPayload>() {

}

std::string RosterSerializer::serializePayload(std::shared_ptr<RosterPayload> roster) const {

XMLElement queryElement("query", "jabber:iq:roster");

if (roster->getVersion()) {

queryElement.setAttribute("ver", *roster->getVersion());

}

std::shared_ptr<XMLElement> itemElement(new XMLElement("item"));

itemElement->setAttribute("jid", item.getJID());

itemElement->setAttribute("name", item.getName());

switch (item.getSubscription()) {

case RosterItemPayload::To: itemElement->setAttribute("subscription", "to"); break;

case RosterItemPayload::From: itemElement->setAttribute("subscription", "from"); break;

case RosterItemPayload::Both: itemElement->setAttribute("subscription", "both"); break;

case RosterItemPayload::Remove: itemElement->setAttribute("subscription", "remove"); break;

case RosterItemPayload::None: itemElement->setAttribute("subscription", "none"); break;

}

if (item.getSubscriptionRequested()) {

itemElement->setAttribute("ask", "subscribe");

}

std::shared_ptr<XMLElement> groupElement(new XMLElement("group"));

groupElement->addNode(std::make_shared<XMLTextNode>(group));

itemElement->addNode(groupElement);

}

if (!item.getUnknownContent().empty()) {

itemElement->addNode(std::make_shared<XMLRawTextNode>(item.getUnknownContent()));

}

queryElement.addNode(itemElement);

}

return queryElement.serialize();

}

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/SearchPayloadSerializer.h>

#include <memory>

#include <Swiften/Serializer/PayloadSerializers/FormSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

namespace Swift {

SearchPayloadSerializer::SearchPayloadSerializer() {

}

std::string SearchPayloadSerializer::serializePayload(std::shared_ptr<SearchPayload> searchPayload) const {

XMLElement searchElement("query", "jabber:iq:search");

if (searchPayload->getInstructions()) {

searchElement.addNode(XMLElement::ref(new XMLElement("instructions", "", *searchPayload->getInstructions())));

}

if (searchPayload->getNick()) {

searchElement.addNode(XMLElement::ref(new XMLElement("nick", "", *searchPayload->getNick())));

}

if (searchPayload->getFirst()) {

searchElement.addNode(XMLElement::ref(new XMLElement("first", "", *searchPayload->getFirst())));

}

if (searchPayload->getLast()) {

searchElement.addNode(XMLElement::ref(new XMLElement("last", "", *searchPayload->getLast())));

}

if (searchPayload->getEMail()) {

searchElement.addNode(XMLElement::ref(new XMLElement("email", "", *searchPayload->getEMail())));

}

XMLElement::ref itemElement(new XMLElement("item"));

itemElement->setAttribute("jid", item.jid);

itemElement->addNode(XMLElement::ref(new XMLElement("first", "", item.first)));

itemElement->addNode(XMLElement::ref(new XMLElement("last", "", item.last)));

itemElement->addNode(XMLElement::ref(new XMLElement("nick", "", item.nick)));

itemElement->addNode(XMLElement::ref(new XMLElement("email", "", item.email)));

searchElement.addNode(itemElement);

}

if (Form::ref form = searchPayload->getForm()) {

searchElement.addNode(std::make_shared<XMLRawTextNode>(FormSerializer().serialize(form)));

}

return searchElement.serialize();

}

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/SecurityLabelSerializer.h>

#include <memory>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

namespace Swift {

SecurityLabelSerializer::SecurityLabelSerializer() : GenericPayloadSerializer<SecurityLabel>() {

}

std::string SecurityLabelSerializer::serializePayload(std::shared_ptr<SecurityLabel> label) const {

XMLElement element("securitylabel", "urn:xmpp:sec-label:0");

if (!label->getDisplayMarking().empty()) {

std::shared_ptr<XMLElement> displayMarking(new XMLElement("displaymarking"));

if (!label->getForegroundColor().empty()) {

displayMarking->setAttribute("fgcolor", label->getForegroundColor());

}

if (!label->getBackgroundColor().empty()) {

displayMarking->setAttribute("bgcolor", label->getBackgroundColor());

}

displayMarking->addNode(std::make_shared<XMLTextNode>(label->getDisplayMarking()));

element.addNode(displayMarking);

}

std::shared_ptr<XMLElement> labelElement(new XMLElement("label"));

labelElement->addNode(std::make_shared<XMLRawTextNode>(label->getLabel()));

element.addNode(labelElement);

std::shared_ptr<XMLElement> equivalentLabelElement(new XMLElement("equivalentlabel"));

equivalentLabelElement->addNode(std::make_shared<XMLRawTextNode>(equivalentLabel));

element.addNode(equivalentLabelElement);

}

return element.serialize();

}

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/SecurityLabelsCatalogSerializer.h>

#include <memory>

#include <Swiften/Serializer/PayloadSerializers/SecurityLabelSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

namespace Swift {

SecurityLabelsCatalogSerializer::SecurityLabelsCatalogSerializer() : GenericPayloadSerializer<SecurityLabelsCatalog>() {

}

std::string SecurityLabelsCatalogSerializer::serializePayload(std::shared_ptr<SecurityLabelsCatalog> catalog) const {

XMLElement element("catalog", "urn:xmpp:sec-label:catalog:2");

if (!catalog->getName().empty()) {

element.setAttribute("name", catalog->getName());

}

if (catalog->getTo().isValid()) {

element.setAttribute("to", catalog->getTo());

}

if (!catalog->getDescription().empty()) {

element.setAttribute("desc", catalog->getDescription());

}

std::shared_ptr<XMLElement> itemElement(new XMLElement("item"));

itemElement->setAttribute("selector", item.getSelector());

if (item.getIsDefault()) {

itemElement->setAttribute("default", "true");

}

if (item.getLabel()) {

std::string serializedLabel = SecurityLabelSerializer().serialize(item.getLabel());

itemElement->addNode(std::make_shared<XMLRawTextNode>(serializedLabel));

}

element.addNode(itemElement);

}

return element.serialize();

}

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/StorageSerializer.h>

#include <memory>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

namespace Swift {

StorageSerializer::StorageSerializer() : GenericPayloadSerializer<Storage>() {

}

std::string StorageSerializer::serializePayload(std::shared_ptr<Storage> storage) const {

XMLElement storageElement("storage", "storage:bookmarks");

std::shared_ptr<XMLElement> conferenceElement(new XMLElement("conference"));

conferenceElement->setAttribute("name", room.name);

conferenceElement->setAttribute("jid", room.jid);

conferenceElement->setAttribute("autojoin", room.autoJoin ? "1" : "0");

if (!room.nick.empty()) {

std::shared_ptr<XMLElement> nickElement(new XMLElement("nick"));

nickElement->addNode(std::make_shared<XMLTextNode>(room.nick));

conferenceElement->addNode(nickElement);

}

if (room.password) {

std::shared_ptr<XMLElement> passwordElement(new XMLElement("password"));

passwordElement->addNode(std::make_shared<XMLTextNode>(*room.password));

conferenceElement->addNode(passwordElement);

}

storageElement.addNode(conferenceElement);

}

std::shared_ptr<XMLElement> urlElement(new XMLElement("url"));

urlElement->setAttribute("name", url.name);

urlElement->setAttribute("url", url.url);

storageElement.addNode(urlElement);

}

return storageElement.serialize();

}

}

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the simplified BSD license.

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

*/

/*

* Copyright (c) 2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/StreamInitiationFileInfoSerializer.h>

#include <memory>

#include <boost/lexical_cast.hpp>

#include <Swiften/Base/DateTime.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

namespace Swift {

StreamInitiationFileInfoSerializer::StreamInitiationFileInfoSerializer() {

}

std::string StreamInitiationFileInfoSerializer::serializePayload(std::shared_ptr<StreamInitiationFileInfo> fileInfo) const {

XMLElement fileElement("file", "http://jabber.org/protocol/si/profile/file-transfer");

if (fileInfo->getDate() != stringToDateTime("")) {

fileElement.setAttribute("date", dateTimeToString(fileInfo->getDate()));

}

fileElement.setAttribute("hash", fileInfo->getHash());

if (fileInfo->getAlgo() != "md5") {

fileElement.setAttribute("algo", fileInfo->getAlgo());

}

if (!fileInfo->getName().empty()) {

fileElement.setAttribute("name", fileInfo->getName());

}

if (fileInfo->getSize() != 0) {

fileElement.setAttribute("size", boost::lexical_cast<std::string>(fileInfo->getSize()));

}

if (!fileInfo->getDescription().empty()) {

std::shared_ptr<XMLElement> desc = std::make_shared<XMLElement>("desc", "", fileInfo->getDescription());

fileElement.addNode(desc);

}

if (fileInfo->getSupportsRangeRequests()) {

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/StreamInitiationSerializer.h>

#include <memory>

#include <memory>

#include <boost/lexical_cast.hpp>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

#include <Swiften/Serializer/PayloadSerializers/FormSerializer.h>

#define FILE_TRANSFER_NS "http://jabber.org/protocol/si/profile/file-transfer"

#define FEATURE_NEG_NS "http://jabber.org/protocol/feature-neg"

namespace Swift {

StreamInitiationSerializer::StreamInitiationSerializer() {

}

std::string StreamInitiationSerializer::serializePayload(std::shared_ptr<StreamInitiation> streamInitiation) const {

assert(streamInitiation->getIsFileTransfer());

XMLElement siElement("si", "http://jabber.org/protocol/si");

if (!streamInitiation->getID().empty()) {

siElement.setAttribute("id", streamInitiation->getID());

}

siElement.setAttribute("profile", FILE_TRANSFER_NS);

if (streamInitiation->getFileInfo()) {

StreamInitiationFileInfo file = *streamInitiation->getFileInfo();

std::shared_ptr<XMLElement> fileElement(new XMLElement("file", "http://jabber.org/protocol/si/profile/file-transfer"));

fileElement->setAttribute("name", file.getName());

if (file.getSize() != 0) {

fileElement->setAttribute("size", boost::lexical_cast<std::string>(file.getSize()));

}

if (!file.getDescription().empty()) {

std::shared_ptr<XMLElement> descElement(new XMLElement("desc"));

descElement->addNode(std::make_shared<XMLTextNode>(file.getDescription()));

fileElement->addNode(descElement);

}

siElement.addNode(fileElement);

}

std::shared_ptr<XMLElement> featureElement(new XMLElement("feature", FEATURE_NEG_NS));

if (streamInitiation->getProvidedMethods().size() > 0) {

Form::ref form(new Form(Form::FormType));

FormField::ref field = std::make_shared<FormField>(FormField::ListSingleType);

field->setName("stream-method");

field->addOption(FormField::Option("", method));

}

form->addField(field);

featureElement->addNode(std::make_shared<XMLRawTextNode>(FormSerializer().serialize(form)));

}

else if (!streamInitiation->getRequestedMethod().empty()) {

Form::ref form(new Form(Form::SubmitType));

FormField::ref field = std::make_shared<FormField>(FormField::ListSingleType);

field->addValue(streamInitiation->getRequestedMethod());

field->setName("stream-method");

form->addField(field);

featureElement->addNode(std::make_shared<XMLRawTextNode>(FormSerializer().serialize(form)));

}

siElement.addNode(featureElement);

return siElement.serialize();

}

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/VCardSerializer.h>

#include <memory>

#include <Swiften/Base/DateTime.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

#include <Swiften/StringCodecs/Base64.h>

namespace Swift {

VCardSerializer::VCardSerializer() : GenericPayloadSerializer<VCard>() {

}

std::string VCardSerializer::serializePayload(std::shared_ptr<VCard> vcard) const {

XMLElement queryElement("vCard", "vcard-temp");

if (!vcard->getVersion().empty()) {

queryElement.addNode(std::make_shared<XMLElement>("VERSION", "", vcard->getVersion()));

}

if (!vcard->getFullName().empty()) {

queryElement.addNode(std::make_shared<XMLElement>("FN", "", vcard->getFullName()));

}

if (!vcard->getGivenName().empty() || !vcard->getFamilyName().empty() || !vcard->getMiddleName().empty() || !vcard->getPrefix().empty() || !vcard->getSuffix().empty()) {

std::shared_ptr<XMLElement> nameElement(new XMLElement("N"));

if (!vcard->getFamilyName().empty()) {

nameElement->addNode(std::make_shared<XMLElement>("FAMILY", "", vcard->getFamilyName()));

}

if (!vcard->getGivenName().empty()) {

nameElement->addNode(std::make_shared<XMLElement>("GIVEN", "", vcard->getGivenName()));

}

if (!vcard->getMiddleName().empty()) {

nameElement->addNode(std::make_shared<XMLElement>("MIDDLE", "", vcard->getMiddleName()));

}

if (!vcard->getPrefix().empty()) {

nameElement->addNode(std::make_shared<XMLElement>("PREFIX", "", vcard->getPrefix()));

}

if (!vcard->getSuffix().empty()) {

nameElement->addNode(std::make_shared<XMLElement>("SUFFIX", "", vcard->getSuffix()));

}

queryElement.addNode(nameElement);

}

std::shared_ptr<XMLElement> emailElement(new XMLElement("EMAIL"));

emailElement->addNode(std::make_shared<XMLElement>("USERID", "", emailAddress.address));

if (emailAddress.isHome) {

emailElement->addNode(std::make_shared<XMLElement>("HOME"));

}

if (emailAddress.isWork) {

emailElement->addNode(std::make_shared<XMLElement>("WORK"));

}

if (emailAddress.isInternet) {

emailElement->addNode(std::make_shared<XMLElement>("INTERNET"));

}

if (emailAddress.isPreferred) {

emailElement->addNode(std::make_shared<XMLElement>("PREF"));

}

if (emailAddress.isX400) {

emailElement->addNode(std::make_shared<XMLElement>("X400"));

}

queryElement.addNode(emailElement);

}

if (!vcard->getNickname().empty()) {

queryElement.addNode(std::make_shared<XMLElement>("NICKNAME", "", vcard->getNickname()));

}

if (!vcard->getPhoto().empty() || !vcard->getPhotoType().empty()) {

XMLElement::ref photoElement(new XMLElement("PHOTO"));

if (!vcard->getPhotoType().empty()) {

photoElement->addNode(std::make_shared<XMLElement>("TYPE", "", vcard->getPhotoType()));

}

if (!vcard->getPhoto().empty()) {

photoElement->addNode(std::make_shared<XMLElement>("BINVAL", "", Base64::encode(vcard->getPhoto())));

}

queryElement.addNode(photoElement);

}

if (!vcard->getBirthday().is_not_a_date_time()) {

queryElement.addNode(std::make_shared<XMLElement>("BDAY", "", dateTimeToString(vcard->getBirthday())));

}

std::shared_ptr<XMLElement> telElement(new XMLElement("TEL"));

telElement->addNode(std::make_shared<XMLElement>("NUMBER", "", telephone.number));

if (telephone.isHome) {

telElement->addNode(std::make_shared<XMLElement>("HOME"));

}

if (telephone.isWork) {

telElement->addNode(std::make_shared<XMLElement>("WORK"));

}

if (telephone.isVoice) {

telElement->addNode(std::make_shared<XMLElement>("VOICE"));

}

if (telephone.isFax) {

telElement->addNode(std::make_shared<XMLElement>("FAX"));

}

if (telephone.isPager) {

telElement->addNode(std::make_shared<XMLElement>("PAGER"));

}

if (telephone.isMSG) {

telElement->addNode(std::make_shared<XMLElement>("MSG"));

}

if (telephone.isCell) {

telElement->addNode(std::make_shared<XMLElement>("CELL"));

}

if (telephone.isVideo) {

telElement->addNode(std::make_shared<XMLElement>("VIDEO"));

}

if (telephone.isBBS) {

telElement->addNode(std::make_shared<XMLElement>("BBS"));

}

if (telephone.isModem) {

telElement->addNode(std::make_shared<XMLElement>("MODEM"));

}

if (telephone.isISDN) {

telElement->addNode(std::make_shared<XMLElement>("ISDN"));

}

if (telephone.isPCS) {

telElement->addNode(std::make_shared<XMLElement>("PCS"));

}

if (telephone.isPreferred) {

telElement->addNode(std::make_shared<XMLElement>("PREF"));

}

queryElement.addNode(telElement);

}

std::shared_ptr<XMLElement> adrElement = std::make_shared<XMLElement>("ADR");

if (!address.poBox.empty()) {

adrElement->addNode(std::make_shared<XMLElement>("POBOX", "", address.poBox));

}

if (!address.addressExtension.empty()) {

adrElement->addNode(std::make_shared<XMLElement>("EXTADD", "", address.addressExtension));

}

if (!address.street.empty()) {

adrElement->addNode(std::make_shared<XMLElement>("STREET", "", address.street));

}

if (!address.locality.empty()) {

adrElement->addNode(std::make_shared<XMLElement>("LOCALITY", "", address.locality));

}

if (!address.region.empty()) {

adrElement->addNode(std::make_shared<XMLElement>("REGION", "", address.region));

}

if (!address.postalCode.empty()) {

adrElement->addNode(std::make_shared<XMLElement>("PCODE", "", address.postalCode));

}

if (!address.country.empty()) {

adrElement->addNode(std::make_shared<XMLElement>("CTRY", "", address.country));

}

if (address.isHome) {

adrElement->addNode(std::make_shared<XMLElement>("HOME"));

}

if (address.isWork) {

adrElement->addNode(std::make_shared<XMLElement>("WORK"));

}

if (address.isPostal) {

adrElement->addNode(std::make_shared<XMLElement>("POSTAL"));

}

if (address.isParcel) {

adrElement->addNode(std::make_shared<XMLElement>("PARCEL"));

}

if (address.deliveryType == VCard::DomesticDelivery) {

adrElement->addNode(std::make_shared<XMLElement>("DOM"));

}

if (address.deliveryType == VCard::InternationalDelivery) {

adrElement->addNode(std::make_shared<XMLElement>("INTL"));

}

if (address.isPreferred) {

adrElement->addNode(std::make_shared<XMLElement>("PREF"));

}

queryElement.addNode(adrElement);

}

std::shared_ptr<XMLElement> labelElement = std::make_shared<XMLElement>("LABEL");

labelElement->addNode(std::make_shared<XMLElement>("LINE", "", line));

}

if (addressLabel.isHome) {

labelElement->addNode(std::make_shared<XMLElement>("HOME"));

}

if (addressLabel.isWork) {

labelElement->addNode(std::make_shared<XMLElement>("WORK"));

}

if (addressLabel.isPostal) {

labelElement->addNode(std::make_shared<XMLElement>("POSTAL"));

}

if (addressLabel.isParcel) {

labelElement->addNode(std::make_shared<XMLElement>("PARCEL"));

}

if (addressLabel.deliveryType == VCard::DomesticDelivery) {

labelElement->addNode(std::make_shared<XMLElement>("DOM"));

}

if (addressLabel.deliveryType == VCard::InternationalDelivery) {

labelElement->addNode(std::make_shared<XMLElement>("INTL"));

}

if (addressLabel.isPreferred) {

labelElement->addNode(std::make_shared<XMLElement>("PREF"));

}

queryElement.addNode(labelElement);

}

queryElement.addNode(std::make_shared<XMLElement>("JID", "", jid.toString()));

}

if (!vcard->getDescription().empty()) {

queryElement.addNode(std::make_shared<XMLElement>("DESC", "", vcard->getDescription()));

}

std::shared_ptr<XMLElement> orgElement = std::make_shared<XMLElement>("ORG");

if (!org.name.empty()) {

orgElement->addNode(std::make_shared<XMLElement>("ORGNAME", "", org.name));

}

if (!org.units.empty()) {

orgElement->addNode(std::make_shared<XMLElement>("ORGUNIT", "", unit));

}

}

queryElement.addNode(orgElement);

}

queryElement.addNode(std::make_shared<XMLElement>("TITLE", "", title));

}

queryElement.addNode(std::make_shared<XMLElement>("ROLE", "", role));

}

queryElement.addNode(std::make_shared<XMLElement>("URL", "", url));

}

if (!vcard->getUnknownContent().empty()) {

queryElement.addNode(std::make_shared<XMLRawTextNode>(vcard->getUnknownContent()));

}

return queryElement.serialize();

}

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/StanzaSerializer.h>

#include <sstream>

#include <typeinfo>

#include <Swiften/Base/Log.h>

#include <Swiften/Elements/Stanza.h>

#include <Swiften/Serializer/PayloadSerializer.h>

#include <Swiften/Serializer/PayloadSerializerCollection.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

namespace Swift {

StanzaSerializer::StanzaSerializer(const std::string& tag, PayloadSerializerCollection* payloadSerializers, const boost::optional<std::string>& explicitNS) : tag_(tag), payloadSerializers_(payloadSerializers), explicitDefaultNS_(explicitNS) {

}

SafeByteArray StanzaSerializer::serialize(std::shared_ptr<ToplevelElement> element) const {

if (explicitDefaultNS_) {

return serialize(element, explicitDefaultNS_.get());

}

else {

return serialize(element, "");

}

}

SafeByteArray StanzaSerializer::serialize(std::shared_ptr<ToplevelElement> element, const std::string& xmlns) const {

std::shared_ptr<Stanza> stanza(std::dynamic_pointer_cast<Stanza>(element));

XMLElement stanzaElement(tag_, explicitDefaultNS_ ? explicitDefaultNS_.get() : xmlns);

if (stanza->getFrom().isValid()) {

stanzaElement.setAttribute("from", stanza->getFrom());

}

if (stanza->getTo().isValid()) {

stanzaElement.setAttribute("to", stanza->getTo());

}

if (!stanza->getID().empty()) {

stanzaElement.setAttribute("id", stanza->getID());

}

setStanzaSpecificAttributes(stanza, stanzaElement);

std::string serializedPayloads;

PayloadSerializer* serializer = payloadSerializers_->getPayloadSerializer(payload);

if (serializer) {

serializedPayloads += serializer->serialize(payload);

}

else {

SWIFT_LOG(warning) << "Could not find serializer for " << typeid(*(payload.get())).name() << std::endl;

}

}

if (!serializedPayloads.empty()) {

stanzaElement.addNode(std::make_shared<XMLRawTextNode>(serializedPayloads));

}

return createSafeByteArray(stanzaElement.serialize());

}

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/StreamFeaturesSerializer.h>

#include <memory>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

namespace Swift {

StreamFeaturesSerializer::StreamFeaturesSerializer() {

}

SafeByteArray StreamFeaturesSerializer::serialize(std::shared_ptr<ToplevelElement> element) const {

std::shared_ptr<StreamFeatures> streamFeatures(std::dynamic_pointer_cast<StreamFeatures>(element));

XMLElement streamFeaturesElement("stream:features");

if (streamFeatures->hasStartTLS()) {

streamFeaturesElement.addNode(std::make_shared<XMLElement>("starttls", "urn:ietf:params:xml:ns:xmpp-tls"));

}

if (!streamFeatures->getCompressionMethods().empty()) {

std::shared_ptr<XMLElement> compressionElement(new XMLElement("compression", "http://jabber.org/features/compress"));

std::shared_ptr<XMLElement> methodElement(new XMLElement("method"));

methodElement->addNode(std::make_shared<XMLTextNode>(method));

compressionElement->addNode(methodElement);

}

streamFeaturesElement.addNode(compressionElement);

}

if (!streamFeatures->getAuthenticationMechanisms().empty()) {

std::shared_ptr<XMLElement> mechanismsElement(new XMLElement("mechanisms", "urn:ietf:params:xml:ns:xmpp-sasl"));

std::shared_ptr<XMLElement> mechanismElement(new XMLElement("mechanism"));

mechanismElement->addNode(std::make_shared<XMLTextNode>(mechanism));

mechanismsElement->addNode(mechanismElement);

}

streamFeaturesElement.addNode(mechanismsElement);

}

if (streamFeatures->hasResourceBind()) {

streamFeaturesElement.addNode(std::make_shared<XMLElement>("bind", "urn:ietf:params:xml:ns:xmpp-bind"));

}

if (streamFeatures->hasSession()) {

streamFeaturesElement.addNode(std::make_shared<XMLElement>("session", "urn:ietf:params:xml:ns:xmpp-session"));

}

if (streamFeatures->hasStreamManagement()) {

streamFeaturesElement.addNode(std::make_shared<XMLElement>("sm", "urn:xmpp:sm:2"));

}

if (streamFeatures->hasRosterVersioning()) {

streamFeaturesElement.addNode(std::make_shared<XMLElement>("ver", "urn:xmpp:features:rosterver"));

}

return createSafeByteArray(streamFeaturesElement.serialize());

}

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

namespace Swift {

XMLElement::XMLElement(const std::string& tag, const std::string& xmlns, const std::string& text) : tag_(tag) {

if (!xmlns.empty()) {

setAttribute("xmlns", xmlns);

}

if (!text.empty()) {

addNode(XMLTextNode::ref(new XMLTextNode(text)));

}

}

std::string XMLElement::serialize() {

std::string result;

result += "<" + tag_;

result += " " + p.first + "=\"" + p.second + "\"";

}

if (!childNodes_.empty()) {

result += ">";

result += node->serialize();

}

result += "</" + tag_ + ">";

}

else {

result += "/>";

}

return result;

}

void XMLElement::setAttribute(const std::string& attribute, const std::string& value) {

std::string escapedValue(value);

String::replaceAll(escapedValue, '&', "&amp;");

String::replaceAll(escapedValue, '<', "&lt;");

String::replaceAll(escapedValue, '>', "&gt;");

String::replaceAll(escapedValue, '\'', "&apos;");

String::replaceAll(escapedValue, '"', "&quot;");

attributes_[attribute] = escapedValue;

}

void XMLElement::addNode(std::shared_ptr<XMLNode> node) {

if (node) {

childNodes_.push_back(node);

}

}

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Serializer/XMPPSerializer.h>

#include <cassert>

#include <memory>

#include <boost/bind.hpp>

#include <Swiften/Base/Log.h>

#include <Swiften/Elements/ProtocolHeader.h>

#include <Swiften/Serializer/AuthChallengeSerializer.h>

#include <Swiften/Serializer/AuthFailureSerializer.h>

#include <Swiften/Serializer/AuthRequestSerializer.h>

#include <Swiften/Serializer/AuthResponseSerializer.h>

#include <Swiften/Serializer/AuthSuccessSerializer.h>

#include <Swiften/Serializer/ComponentHandshakeSerializer.h>

#include <Swiften/Serializer/CompressFailureSerializer.h>

#include <Swiften/Serializer/CompressRequestSerializer.h>

#include <Swiften/Serializer/EnableStreamManagementSerializer.h>

#include <Swiften/Serializer/IQSerializer.h>

#include <Swiften/Serializer/MessageSerializer.h>

#include <Swiften/Serializer/PresenceSerializer.h>

#include <Swiften/Serializer/StanzaAckRequestSerializer.h>

#include <Swiften/Serializer/StanzaAckSerializer.h>

#include <Swiften/Serializer/StartTLSFailureSerializer.h>

#include <Swiften/Serializer/StartTLSRequestSerializer.h>

#include <Swiften/Serializer/StreamErrorSerializer.h>

#include <Swiften/Serializer/StreamFeaturesSerializer.h>

#include <Swiften/Serializer/StreamManagementEnabledSerializer.h>

#include <Swiften/Serializer/StreamManagementFailedSerializer.h>

#include <Swiften/Serializer/StreamResumeSerializer.h>

#include <Swiften/Serializer/StreamResumedSerializer.h>

#include <Swiften/Serializer/TLSProceedSerializer.h>

namespace Swift {

XMPPSerializer::XMPPSerializer(PayloadSerializerCollection* payloadSerializers, StreamType type, bool setExplictNSonTopLevelElements) : type_(type) {

serializers_.push_back(std::make_shared<PresenceSerializer>(payloadSerializers, setExplictNSonTopLevelElements ? getDefaultNamespace() : boost::optional<std::string>()));

serializers_.push_back(std::make_shared<IQSerializer>(payloadSerializers, setExplictNSonTopLevelElements ? getDefaultNamespace() : boost::optional<std::string>()));