1 /*
2 * libjingle
3 * Copyright 2011, Google Inc.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright notice,
11 * this list of conditions and the following disclaimer in the documentation
12 * and/or other materials provided with the distribution.
13 * 3. The name of the author may not be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #include "talk/xmpp/pubsubtasks.h"
29
30 #include <string>
31 #include <vector>
32
33 #include "talk/xmpp/constants.h"
34 #include "talk/xmpp/receivetask.h"
35
36 // An implementation of the tasks for XEP-0060
37 // (http://xmpp.org/extensions/xep-0060.html).
38
39 namespace buzz {
40
41 namespace {
42
IsPubSubEventItemsElem(const XmlElement * stanza,const std::string & expected_node)43 bool IsPubSubEventItemsElem(const XmlElement* stanza,
44 const std::string& expected_node) {
45 if (stanza->Name() != QN_MESSAGE) {
46 return false;
47 }
48
49 const XmlElement* event_elem = stanza->FirstNamed(QN_PUBSUB_EVENT);
50 if (event_elem == NULL) {
51 return false;
52 }
53
54 const XmlElement* items_elem = event_elem->FirstNamed(QN_PUBSUB_EVENT_ITEMS);
55 if (items_elem == NULL) {
56 return false;
57 }
58
59 const std::string& actual_node = items_elem->Attr(QN_NODE);
60 return (actual_node == expected_node);
61 }
62
63 // Creates <pubsub node="node"><items></pubsub>
CreatePubSubItemsElem(const std::string & node)64 XmlElement* CreatePubSubItemsElem(const std::string& node) {
65 XmlElement* items_elem = new XmlElement(QN_PUBSUB_ITEMS, false);
66 items_elem->AddAttr(QN_NODE, node);
67 XmlElement* pubsub_elem = new XmlElement(QN_PUBSUB, false);
68 pubsub_elem->AddElement(items_elem);
69 return pubsub_elem;
70 }
71
72 // Creates <pubsub node="node"><publish><item id="itemid">payload</item>...
73 // Takes ownership of payload.
CreatePubSubPublishItemElem(const std::string & node,const std::string & itemid,const std::vector<XmlElement * > & children)74 XmlElement* CreatePubSubPublishItemElem(
75 const std::string& node,
76 const std::string& itemid,
77 const std::vector<XmlElement*>& children) {
78 XmlElement* pubsub_elem = new XmlElement(QN_PUBSUB, true);
79 XmlElement* publish_elem = new XmlElement(QN_PUBSUB_PUBLISH, false);
80 publish_elem->AddAttr(QN_NODE, node);
81 XmlElement* item_elem = new XmlElement(QN_PUBSUB_ITEM, false);
82 item_elem->AddAttr(QN_ID, itemid);
83 for (std::vector<XmlElement*>::const_iterator child = children.begin();
84 child != children.end(); ++child) {
85 item_elem->AddElement(*child);
86 }
87 publish_elem->AddElement(item_elem);
88 pubsub_elem->AddElement(publish_elem);
89 return pubsub_elem;
90 }
91
92 // Creates <pubsub node="node"><publish><item id="itemid">payload</item>...
93 // Takes ownership of payload.
CreatePubSubRetractItemElem(const std::string & node,const std::string & itemid)94 XmlElement* CreatePubSubRetractItemElem(const std::string& node,
95 const std::string& itemid) {
96 XmlElement* pubsub_elem = new XmlElement(QN_PUBSUB, true);
97 XmlElement* retract_elem = new XmlElement(QN_PUBSUB_RETRACT, false);
98 retract_elem->AddAttr(QN_NODE, node);
99 retract_elem->AddAttr(QN_NOTIFY, "true");
100 XmlElement* item_elem = new XmlElement(QN_PUBSUB_ITEM, false);
101 item_elem->AddAttr(QN_ID, itemid);
102 retract_elem->AddElement(item_elem);
103 pubsub_elem->AddElement(retract_elem);
104 return pubsub_elem;
105 }
106
ParseItem(const XmlElement * item_elem,std::vector<PubSubItem> * items)107 void ParseItem(const XmlElement* item_elem,
108 std::vector<PubSubItem>* items) {
109 PubSubItem item;
110 item.itemid = item_elem->Attr(QN_ID);
111 item.elem = item_elem;
112 items->push_back(item);
113 }
114
115 // Right now, <retract>s are treated the same as items with empty
116 // payloads. We may want to change it in the future, but right now
117 // it's sufficient for our needs.
ParseRetract(const XmlElement * retract_elem,std::vector<PubSubItem> * items)118 void ParseRetract(const XmlElement* retract_elem,
119 std::vector<PubSubItem>* items) {
120 ParseItem(retract_elem, items);
121 }
122
ParseEventItemsElem(const XmlElement * stanza,std::vector<PubSubItem> * items)123 void ParseEventItemsElem(const XmlElement* stanza,
124 std::vector<PubSubItem>* items) {
125 const XmlElement* event_elem = stanza->FirstNamed(QN_PUBSUB_EVENT);
126 if (event_elem != NULL) {
127 const XmlElement* items_elem =
128 event_elem->FirstNamed(QN_PUBSUB_EVENT_ITEMS);
129 if (items_elem != NULL) {
130 for (const XmlElement* item_elem =
131 items_elem->FirstNamed(QN_PUBSUB_EVENT_ITEM);
132 item_elem != NULL;
133 item_elem = item_elem->NextNamed(QN_PUBSUB_EVENT_ITEM)) {
134 ParseItem(item_elem, items);
135 }
136 for (const XmlElement* retract_elem =
137 items_elem->FirstNamed(QN_PUBSUB_EVENT_RETRACT);
138 retract_elem != NULL;
139 retract_elem = retract_elem->NextNamed(QN_PUBSUB_EVENT_RETRACT)) {
140 ParseRetract(retract_elem, items);
141 }
142 }
143 }
144 }
145
ParsePubSubItemsElem(const XmlElement * stanza,std::vector<PubSubItem> * items)146 void ParsePubSubItemsElem(const XmlElement* stanza,
147 std::vector<PubSubItem>* items) {
148 const XmlElement* pubsub_elem = stanza->FirstNamed(QN_PUBSUB);
149 if (pubsub_elem != NULL) {
150 const XmlElement* items_elem = pubsub_elem->FirstNamed(QN_PUBSUB_ITEMS);
151 if (items_elem != NULL) {
152 for (const XmlElement* item_elem = items_elem->FirstNamed(QN_PUBSUB_ITEM);
153 item_elem != NULL;
154 item_elem = item_elem->NextNamed(QN_PUBSUB_ITEM)) {
155 ParseItem(item_elem, items);
156 }
157 }
158 }
159 }
160
161 } // namespace
162
PubSubRequestTask(XmppTaskParentInterface * parent,const Jid & pubsubjid,const std::string & node)163 PubSubRequestTask::PubSubRequestTask(XmppTaskParentInterface* parent,
164 const Jid& pubsubjid,
165 const std::string& node)
166 : IqTask(parent, STR_GET, pubsubjid, CreatePubSubItemsElem(node)) {
167 }
168
HandleResult(const XmlElement * stanza)169 void PubSubRequestTask::HandleResult(const XmlElement* stanza) {
170 std::vector<PubSubItem> items;
171 ParsePubSubItemsElem(stanza, &items);
172 SignalResult(this, items);
173 }
174
WantsStanza(const XmlElement * stanza)175 bool PubSubReceiveTask::WantsStanza(const XmlElement* stanza) {
176 return MatchStanzaFrom(stanza, pubsubjid_) &&
177 IsPubSubEventItemsElem(stanza, node_);
178 }
179
ReceiveStanza(const XmlElement * stanza)180 void PubSubReceiveTask::ReceiveStanza(const XmlElement* stanza) {
181 std::vector<PubSubItem> items;
182 ParseEventItemsElem(stanza, &items);
183 SignalUpdate(this, items);
184 }
185
PubSubPublishTask(XmppTaskParentInterface * parent,const Jid & pubsubjid,const std::string & node,const std::string & itemid,const std::vector<XmlElement * > & children)186 PubSubPublishTask::PubSubPublishTask(XmppTaskParentInterface* parent,
187 const Jid& pubsubjid,
188 const std::string& node,
189 const std::string& itemid,
190 const std::vector<XmlElement*>& children)
191 : IqTask(parent, STR_SET, pubsubjid,
192 CreatePubSubPublishItemElem(node, itemid, children)),
193 itemid_(itemid) {
194 }
195
HandleResult(const XmlElement * stanza)196 void PubSubPublishTask::HandleResult(const XmlElement* stanza) {
197 SignalResult(this);
198 }
199
PubSubRetractTask(XmppTaskParentInterface * parent,const Jid & pubsubjid,const std::string & node,const std::string & itemid)200 PubSubRetractTask::PubSubRetractTask(XmppTaskParentInterface* parent,
201 const Jid& pubsubjid,
202 const std::string& node,
203 const std::string& itemid)
204 : IqTask(parent, STR_SET, pubsubjid,
205 CreatePubSubRetractItemElem(node, itemid)),
206 itemid_(itemid) {
207 }
208
HandleResult(const XmlElement * stanza)209 void PubSubRetractTask::HandleResult(const XmlElement* stanza) {
210 SignalResult(this);
211 }
212
213 } // namespace buzz
214