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(); }