void JingleParser::handleEndElement(const std::string& element, const std::string &ns) {
--level;
if (currentPayloadParser) {
if (level >= 1) {
currentPayloadParser->handleEndElement(element, ns);
}
if (level == 1) {
boost::shared_ptr<JinglePayload::Reason> reason = boost::dynamic_pointer_cast<JinglePayload::Reason>(currentPayloadParser->getPayload());
if (reason) {
getPayloadInternal()->setReason(*reason);
}
boost::shared_ptr<JingleContentPayload> payload = boost::dynamic_pointer_cast<JingleContentPayload>(currentPayloadParser->getPayload());
if (payload) {
getPayloadInternal()->addContent(payload);
}
boost::shared_ptr<JingleFileTransferHash> hash = boost::dynamic_pointer_cast<JingleFileTransferHash>(currentPayloadParser->getPayload());
if (hash) {
getPayloadInternal()->addPayload(hash);
}
}
}
}
void MUCUserPayloadParser::handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) {
if (level == ItemLevel) {
if (element == "item") {
MUCUserPayload::Item item;
std::string affiliation = attributes.getAttribute("affiliation");
std::string role = attributes.getAttribute("role");
std::string nick = attributes.getAttribute("nick");
std::string jid = attributes.getAttribute("jid");
item.affiliation = parseAffiliation(affiliation);
item.role = parseRole(role);
if (!jid.empty()) {
item.realJID = JID(jid);
}
if (!nick.empty()) {
item.nick = nick;
}
getPayloadInternal()->addItem(item);
} else if (element == "status") {
MUCUserPayload::StatusCode status;
try {
status.code = boost::lexical_cast<int>(attributes.getAttribute("code").c_str());
getPayloadInternal()->addStatusCode(status);
} catch (boost::bad_lexical_cast&) {
}
}
}
++level;
}
void MUCDestroyPayloadParser::handleTree(ParserElement::ref root) {
std::string ns = root->getNamespace();
std::string jid = root->getAttributes().getAttribute("jid");
if (!jid.empty()) {
getPayloadInternal()->setNewVenue(JID(jid));
}
getPayloadInternal()->setReason(root->getChild("reason", ns)->getText());
}
void JingleIBBTransportMethodPayloadParser::handleStartElement(const std::string&, const std::string&, const AttributeMap& attributes) {
try {
getPayloadInternal()->setBlockSize(boost::lexical_cast<int>(attributes.getAttributeValue("block-size").get_value_or("0")));
} catch (boost::bad_lexical_cast &) {
getPayloadInternal()->setBlockSize(0);
}
getPayloadInternal()->setSessionID(attributes.getAttributeValue("sid").get_value_or(""));
++level;
}
void ResourceBindParser::handleEndElement(const std::string&, const std::string&) {
--level_;
if (level_ == 1) {
if (inJID_) {
getPayloadInternal()->setJID(JID(text_));
}
else if (inResource_) {
getPayloadInternal()->setResource(text_);
}
}
}
void JingleFileTransferFileInfoParser::handleEndElement(const std::string& element, const std::string&) {
--level;
if (level == 1) {
if (element == "date") {
getPayloadInternal()->setDate(stringToDateTime(charData));
}
else if (element == "desc") {
getPayloadInternal()->setDescription(charData);
}
else if (element == "media-type") {
getPayloadInternal()->setMediaType(charData);
}
else if (element == "name") {
getPayloadInternal()->setName(charData);
}
else if (element == "size") {
boost::optional<boost::uintmax_t> size = safeLexicalCast<boost::uintmax_t>(charData);
if (size) {
getPayloadInternal()->setSize(size.get());
}
}
else if (element == "range") {
getPayloadInternal()->setSupportsRangeRequests(true);
if (rangeOffset) {
getPayloadInternal()->setRangeOffset(rangeOffset.get_value_or(0));
}
}
else if (element == "hash") {
getPayloadInternal()->addHash(HashElement(hashAlg, Base64::decode(charData)));
}
}
}
void SoftwareVersionParser::handleEndElement(const std::string& element, const std::string&) {
--level_;
if (level_ == PayloadLevel) {
if (element == "name") {
getPayloadInternal()->setName(currentText_);
}
else if (element == "version") {
getPayloadInternal()->setVersion(currentText_);
}
else if (element == "os") {
getPayloadInternal()->setOS(currentText_);
}
currentText_ = "";
}
}
void JingleReasonParser::handleEndElement(const std::string& element, const std::string&) {
--level;
if (element == "text") {
parseText = false;
getPayloadInternal()->text = text;
}
}
void IdleParser::handleStartElement(const std::string& /*element*/, const std::string& /*ns*/, const AttributeMap& attributes) {
if (level_ == 0) {
boost::posix_time::ptime since = stringToDateTime(attributes.getAttribute("since"));
getPayloadInternal()->setSince(since);
}
++level_;
}
void ReplaceParser::handleStartElement(const std::string&, const std::string&, const AttributeMap& attributes) {
if (level_ == 0) {
std::string id = attributes.getAttribute("id");
getPayloadInternal()->setID(id);
}
level_++;
}
void SecurityLabelParser::handleStartElement(const std::string& element, const std::string& ns, const AttributeMap& attributes) {
++level_;
if (level_ == DisplayMarkingOrLabelLevel) {
if (element == "displaymarking") {
currentText_ = "";
getPayloadInternal()->setBackgroundColor(attributes.getAttribute("bgcolor"));
getPayloadInternal()->setForegroundColor(attributes.getAttribute("fgcolor"));
}
else if (element == "label" || element == "equivalentlabel") {
assert(!labelParser_);
labelParser_ = new SerializingParser();
}
}
else if (level_ >= SecurityLabelLevel && labelParser_) {
labelParser_->handleStartElement(element, ns, attributes);
}
}
void JingleS5BTransportMethodPayloadParser::handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) {
if (level == 0) {
getPayloadInternal()->setSessionID(attributes.getAttributeValue("sid").get_value_or(""));
std::string mode = attributes.getAttributeValue("mode").get_value_or("tcp");
if (mode == "tcp") {
getPayloadInternal()->setMode(JingleS5BTransportPayload::TCPMode);
} else if(mode == "udp") {
getPayloadInternal()->setMode(JingleS5BTransportPayload::UDPMode);
} else {
SWIFT_LOG(warning) << "Unknown S5B mode; falling back to defaul!";
getPayloadInternal()->setMode(JingleS5BTransportPayload::TCPMode);
}
getPayloadInternal()->setDstAddr(attributes.getAttributeValue("dstaddr").get_value_or(""));
} else if (level == 1) {
if (element == "candidate") {
JingleS5BTransportPayload::Candidate candidate;
candidate.cid = attributes.getAttributeValue("cid").get_value_or("");
int port = -1;
try {
port = boost::lexical_cast<int>(attributes.getAttributeValue("port").get_value_or("-1"));
} catch(boost::bad_lexical_cast &) { }
candidate.hostPort = HostAddressPort(HostAddress(attributes.getAttributeValue("host").get_value_or("")), port);
candidate.jid = JID(attributes.getAttributeValue("jid").get_value_or(""));
int priority = -1;
try {
priority = boost::lexical_cast<int>(attributes.getAttributeValue("priority").get_value_or("-1"));
} catch(boost::bad_lexical_cast &) { }
candidate.priority = priority;
candidate.type = stringToType(attributes.getAttributeValue("type").get_value_or("direct"));
getPayloadInternal()->addCandidate(candidate);
} else if (element == "candidate-used") {
getPayloadInternal()->setCandidateUsed(attributes.getAttributeValue("cid").get_value_or(""));
} else if (element == "candidate-error") {
getPayloadInternal()->setCandidateError(true);
} else if (element == "activated") {
getPayloadInternal()->setActivated(attributes.getAttributeValue("cid").get_value_or(""));
} else if (element == "proxy-error") {
getPayloadInternal()->setProxyError(true);
}
}
++level;
}
void BytestreamsParser::handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) {
if (level == TopLevel) {
getPayloadInternal()->setStreamID(attributes.getAttribute("sid"));
}
else if (level == PayloadLevel) {
if (element == "streamhost") {
try {
getPayloadInternal()->addStreamHost(Bytestreams::StreamHost(attributes.getAttribute("host"), JID(attributes.getAttribute("jid")), boost::lexical_cast<int>(attributes.getAttribute("port"))));
}
catch (boost::bad_lexical_cast&) {
}
}
else if (element == "streamhost-used") {
getPayloadInternal()->setUsedStreamHost(JID(attributes.getAttribute("jid")));
}
}
++level;
}
void JingleFileTransferReceivedParser::handleEndElement(const std::string& element, const std::string& ) {
--level;
if (element == "file") {
boost::shared_ptr<StreamInitiationFileInfo> fileInfo = boost::dynamic_pointer_cast<StreamInitiationFileInfo>(currentPayloadParser->getPayload());
if (fileInfo) {
getPayloadInternal()->setFileInfo(*fileInfo);
}
}
}
void DiscoInfoParser::handleStartElement(const std::string& element, const std::string& ns, const AttributeMap& attributes) {
if (level_ == PayloadLevel) {
if (element == "identity") {
getPayloadInternal()->addIdentity(DiscoInfo::Identity(attributes.getAttribute("name"), attributes.getAttribute("category"), attributes.getAttribute("type"), attributes.getAttribute("lang", "http://www.w3.org/XML/1998/namespace")));
}
else if (element == "feature") {
getPayloadInternal()->addFeature(attributes.getAttribute("var"));
}
else if (element == "x" && ns == "jabber:x:data") {
assert(!formParser_);
formParser_ = new FormParser();
}
}
if (formParser_) {
formParser_->handleStartElement(element, ns, attributes);
}
++level_;
}
void DeliveryReceiptParser::handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributeMap) {
if (level_ == 0) {
if (element == "received") {
if (attributeMap.getAttributeValue("id").is_initialized()) {
getPayloadInternal()->setReceivedID(attributeMap.getAttributeValue("id").get());
}
}
}
++level_;
}
void CarbonsSentParser::handleEndElement(const std::string& element, const std::string& ns) {
--level_;
if (forwardedParser_ && level_ >= PayloadLevel) {
forwardedParser_->handleEndElement(element, ns);
}
if (forwardedParser_ && level_ == PayloadLevel) {
/* done parsing nested stanza */
getPayloadInternal()->setForwarded(forwardedParser_->getPayloadInternal());
forwardedParser_.reset();
}
}
void JingleReasonParser::handleStartElement(const std::string& element, const std::string&, const AttributeMap&) {
if (level == 1) {
if (element == "text") {
parseText = true;
} else {
// reason type
getPayloadInternal()->type = stringToReasonType(element);
}
}
++level;
}
void DiscoInfoParser::handleEndElement(const std::string& element, const std::string& ns) {
--level_;
if (formParser_) {
formParser_->handleEndElement(element, ns);
}
if (level_ == PayloadLevel && formParser_) {
getPayloadInternal()->addExtension(formParser_->getPayloadInternal());
delete formParser_;
formParser_ = NULL;
}
}
void JingleFileTransferDescriptionParser::handleEndElement(const std::string& element, const std::string& ns) {
--level;
if (level >= 1 && currentPayloadParser) {
currentPayloadParser->handleEndElement(element, ns);
}
if (level == 0) {
boost::shared_ptr<JingleFileTransferFileInfo> info = boost::dynamic_pointer_cast<JingleFileTransferFileInfo>(currentPayloadParser->getPayload());
if (info) {
getPayloadInternal()->setFileInfo(*info);
}
}
}
void LastParser::handleStartElement(const std::string&, const std::string&, const AttributeMap& attributes) {
if (level_ == 0) {
int seconds = 0;
try {
seconds = boost::lexical_cast<int>(attributes.getAttribute("seconds"));
}
catch (boost::bad_lexical_cast&) {
}
getPayloadInternal()->setSeconds(seconds);
}
++level_;
}
void SecurityLabelParser::handleEndElement(const std::string& element, const std::string& ns) {
if (level_ == DisplayMarkingOrLabelLevel) {
if (element == "displaymarking") {
getPayloadInternal()->setDisplayMarking(currentText_);
}
else if (labelParser_) {
if (element == "label") {
getPayloadInternal()->setLabel(labelParser_->getResult());
}
else {
getPayloadInternal()->addEquivalentLabel(labelParser_->getResult());
}
delete labelParser_;
labelParser_ = nullptr;
}
}
else if (labelParser_ && level_ >= SecurityLabelLevel) {
labelParser_->handleEndElement(element, ns);
}
--level_;
}
void StorageParser::handleEndElement(const std::string& element, const std::string&) {
--level;
if (level == BookmarkLevel) {
if (element == "conference") {
assert(room);
getPayloadInternal()->addRoom(*room);
room.reset();
}
else if (element == "url") {
assert(url);
getPayloadInternal()->addURL(*url);
url.reset();
}
}
else if (level == DetailLevel && room) {
if (element == "nick") {
room->nick = currentText;
}
else if (element == "password") {
room->password = currentText;
}
}
}
void SearchPayloadParser::handleEndElement(const std::string& element, const std::string& ns) {
--level;
if (formParser) {
formParser->handleEndElement(element, ns);
}
if (level == TopLevel) {
}
else if (level == PayloadLevel) {
if (formParser) {
getPayloadInternal()->setForm(formParser->getPayloadInternal());
delete formParser;
formParser = nullptr;
}
else if (element == "item") {
assert(currentItem);
getPayloadInternal()->addItem(*currentItem);
currentItem.reset();
}
else if (element == "instructions") {
getPayloadInternal()->setInstructions(currentText);
}
else if (element == "nick") {
getPayloadInternal()->setNick(currentText);
}
else if (element == "first") {
getPayloadInternal()->setFirst(currentText);
}
else if (element == "last") {
getPayloadInternal()->setLast(currentText);
}
else if (element == "email") {
getPayloadInternal()->setEMail(currentText);
}
}
else if (level == ItemLevel && currentItem) {
if (element == "nick") {
currentItem->nick = currentText;
}
else if (element == "first") {
currentItem->first = currentText;
}
else if (element == "last") {
currentItem->last = currentText;
}
else if (element == "email") {
currentItem->email = currentText;
}
}
}
void ChatStateParser::handleStartElement(const std::string& element, const std::string&, const AttributeMap&) {
if (level_ == 0) {
ChatState::ChatStateType state = ChatState::Active;
if (element == "active") {
state = ChatState::Active;
} else if (element == "composing") {
state = ChatState::Composing;
} else if (element == "inactive") {
state = ChatState::Inactive;
} else if (element == "paused") {
state = ChatState::Paused;
} else if (element == "gone") {
state = ChatState::Gone;
}
getPayloadInternal()->setChatState(state);
}
++level_;
}
void RosterParser::handleEndElement(const std::string& element, const std::string& ns) {
--level_;
if (level_ == PayloadLevel) {
if (inItem_) {
getPayloadInternal()->addItem(currentItem_);
inItem_ = false;
}
}
else if (level_ == ItemLevel) {
if (unknownContentParser_) {
unknownContentParser_->handleEndElement(element, ns);
currentItem_.addUnknownContent(unknownContentParser_->getResult());
delete unknownContentParser_;
unknownContentParser_ = NULL;
}
else if (element == "group") {
currentItem_.addGroup(currentText_);
}
}
else if (unknownContentParser_) {
unknownContentParser_->handleEndElement(element, ns);
}
}
void JingleParser::handleStartElement(const std::string& element, const std::string &ns, const AttributeMap& attributes) {
if (level == 0) {
// <jingle > tag
JinglePayload::ref payload = getPayloadInternal();
payload->setAction(stringToAction(attributes.getAttributeValue("action").get_value_or("")));
payload->setInitiator(JID(attributes.getAttributeValue("initiator").get_value_or("")));
payload->setResponder(JID(attributes.getAttributeValue("responder").get_value_or("")));
payload->setSessionID(attributes.getAttributeValue("sid").get_value_or(""));
}
if (level == 1) {
PayloadParserFactory* payloadParserFactory = factories->getPayloadParserFactory(element, ns, attributes);
if (payloadParserFactory) {
currentPayloadParser.reset(payloadParserFactory->createPayloadParser());
}
}
if (level >= 1 && currentPayloadParser) {
currentPayloadParser->handleStartElement(element, ns, attributes);
}
++level;
}
void SubjectParser::handleEndElement(const std::string&, const std::string&) {
--level_;
if (level_ == 0) {
getPayloadInternal()->setText(text_);
}
}
void FormParser::handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) {
if (level_ == TopLevel) {
std::string type = attributes.getAttribute("type");
if (type == "form") {
getPayloadInternal()->setType(Form::FormType);
}
else if (type == "submit") {
getPayloadInternal()->setType(Form::SubmitType);
}
else if (type == "cancel") {
getPayloadInternal()->setType(Form::CancelType);
}
else if (type == "result") {
getPayloadInternal()->setType(Form::ResultType);
}
}
else if (level_ == PayloadLevel) {
if (element == "title") {
currentText_.clear();
}
else if (element == "instructions") {
currentText_.clear();
}
else if (element == "field") {
std::string type;
FormField::ref correspondingReportedField;
if (!parsingItem_) {
type = attributes.getAttribute("type");
} else {
foreach(FormField::ref field, getPayloadInternal()->getReportedFields()) {
if (field->getName() == attributes.getAttribute("var")) {
correspondingReportedField = field;
break;
}
}
}
if (type == "boolean" || boost::dynamic_pointer_cast<BooleanFormField>(correspondingReportedField)) {
currentFieldParseHelper_ = BooleanFormFieldParseHelper::create();
}
else if (type == "fixed" || boost::dynamic_pointer_cast<FixedFormField>(correspondingReportedField)) {
currentFieldParseHelper_ = FixedFormFieldParseHelper::create();
}
else if (type == "hidden" || boost::dynamic_pointer_cast<HiddenFormField>(correspondingReportedField)) {
currentFieldParseHelper_ = HiddenFormFieldParseHelper::create();
}
else if (type == "jid-multi" || boost::dynamic_pointer_cast<JIDMultiFormField>(correspondingReportedField)) {
currentFieldParseHelper_ = JIDMultiFormFieldParseHelper::create();
}
else if (type == "jid-single" || boost::dynamic_pointer_cast<JIDSingleFormField>(correspondingReportedField)) {
currentFieldParseHelper_ = JIDSingleFormFieldParseHelper::create();
}
else if (type == "list-multi" || boost::dynamic_pointer_cast<ListMultiFormField>(correspondingReportedField)) {
currentFieldParseHelper_ = ListMultiFormFieldParseHelper::create();
}
else if (type == "list-single" || boost::dynamic_pointer_cast<ListSingleFormField>(correspondingReportedField)) {
currentFieldParseHelper_ = ListSingleFormFieldParseHelper::create();
}
else if (type == "text-multi" || boost::dynamic_pointer_cast<TextMultiFormField>(correspondingReportedField)) {
currentFieldParseHelper_ = TextMultiFormFieldParseHelper::create();
}
else if (type == "text-private" || boost::dynamic_pointer_cast<TextPrivateFormField>(correspondingReportedField)) {
currentFieldParseHelper_ = TextPrivateFormFieldParseHelper::create();
}
else /*if (type == "text-single") || undefined */ {
currentFieldParseHelper_ = TextSingleFormFieldParseHelper::create();
}
if (currentFieldParseHelper_) {
currentFieldParseHelper_->getField()->setName(attributes.getAttribute("var"));
currentFieldParseHelper_->getField()->setLabel(attributes.getAttribute("label"));
}
}
else if (element == "reported") {
void VCardParser::handleEndElement(const std::string& element, const std::string& ns) {
if (unknownContentParser_) {
unknownContentParser_->handleEndElement(element, ns);
}
std::string elementHierarchy = getElementHierarchy();
if (elementHierarchy == "/vCard/VERSION") {
getPayloadInternal()->setVersion(currentText_);
}
else if (elementHierarchy == "/vCard/FN") {
getPayloadInternal()->setFullName(currentText_);
}
else if (elementHierarchy == "/vCard/N/FAMILY") {
getPayloadInternal()->setFamilyName(currentText_);
}
else if (elementHierarchy == "/vCard/N/GIVEN") {
getPayloadInternal()->setGivenName(currentText_);
}
else if (elementHierarchy == "/vCard/N/MIDDLE") {
getPayloadInternal()->setMiddleName(currentText_);
}
else if (elementHierarchy == "/vCard/N/PREFIX") {
getPayloadInternal()->setPrefix(currentText_);
}
else if (elementHierarchy == "/vCard/N/SUFFIX") {
getPayloadInternal()->setSuffix(currentText_);
}
else if (elementHierarchy == "/vCard/N") {
}
else if (elementHierarchy == "/vCard/NICKNAME") {
getPayloadInternal()->setNickname(currentText_);
}
else if (elementHierarchy == "/vCard/PHOTO/TYPE") {
getPayloadInternal()->setPhotoType(currentText_);
}
else if (elementHierarchy == "/vCard/PHOTO/BINVAL") {
getPayloadInternal()->setPhoto(Base64::decode(currentText_));
}
else if (elementHierarchy == "/vCard/PHOTO") {
}
else if (elementHierarchy == "/vCard/EMAIL/USERID") {
currentEMailAddress_.address = currentText_;
}
else if (elementHierarchy == "/vCard/EMAIL/HOME") {
currentEMailAddress_.isHome = true;
}
else if (elementHierarchy == "/vCard/EMAIL/WORK") {
currentEMailAddress_.isWork = true;
}
else if (elementHierarchy == "/vCard/EMAIL/INTERNET") {
currentEMailAddress_.isInternet = true;
}
else if (elementHierarchy == "/vCard/EMAIL/X400") {
currentEMailAddress_.isX400 = true;
}
else if (elementHierarchy == "/vCard/EMAIL/PREF") {
currentEMailAddress_.isPreferred = true;
}
else if (elementHierarchy == "/vCard/EMAIL") {
getPayloadInternal()->addEMailAddress(currentEMailAddress_);
}
else if (elementStack_.size() == 2 && unknownContentParser_) {
getPayloadInternal()->addUnknownContent(unknownContentParser_->getResult());
}
if (elementStack_.size() == 2 && unknownContentParser_) {
delete unknownContentParser_;
unknownContentParser_ = NULL;
}
elementStack_.pop_back();
}
