Line data Source code
1 : /* Copyright (C) 2021 Wildfire Games.
2 : * This file is part of 0 A.D.
3 : *
4 : * 0 A.D. is free software: you can redistribute it and/or modify
5 : * it under the terms of the GNU General Public License as published by
6 : * the Free Software Foundation, either version 2 of the License, or
7 : * (at your option) any later version.
8 : *
9 : * 0 A.D. is distributed in the hope that it will be useful,
10 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 : * GNU General Public License for more details.
13 : *
14 : * You should have received a copy of the GNU General Public License
15 : * along with 0 A.D. If not, see <http://www.gnu.org/licenses/>.
16 : */
17 :
18 : #include "precompiled.h"
19 :
20 : #include "glooxwrapper.h"
21 :
22 : #include <gloox/connectionlistener.h>
23 : #include <gloox/error.h>
24 : #include <gloox/glooxversion.h>
25 : #include <gloox/messagehandler.h>
26 :
27 : #if OS_WIN
28 : const std::string gloox::EmptyString = "";
29 : #endif
30 :
31 0 : void* glooxwrapper::glooxwrapper_alloc(size_t size)
32 : {
33 0 : void* p = malloc(size);
34 0 : if (p == NULL)
35 0 : throw std::bad_alloc();
36 0 : return p;
37 : }
38 :
39 0 : void glooxwrapper::glooxwrapper_free(void* p)
40 : {
41 0 : free(p);
42 0 : }
43 :
44 :
45 : namespace glooxwrapper
46 : {
47 :
48 0 : class ConnectionListenerWrapper : public gloox::ConnectionListener
49 : {
50 : glooxwrapper::ConnectionListener* m_Wrapped;
51 : public:
52 0 : ConnectionListenerWrapper(glooxwrapper::ConnectionListener* wrapped) : m_Wrapped(wrapped) {}
53 :
54 0 : virtual void onConnect()
55 : {
56 0 : m_Wrapped->onConnect();
57 0 : }
58 :
59 0 : virtual void onDisconnect(gloox::ConnectionError e)
60 : {
61 0 : m_Wrapped->onDisconnect(e);
62 0 : }
63 :
64 0 : virtual bool onTLSConnect(const gloox::CertInfo& info)
65 : {
66 0 : glooxwrapper::CertInfo infoWrapped;
67 : #define COPY(n) infoWrapped.n = info.n
68 0 : COPY(status);
69 0 : COPY(chain);
70 0 : COPY(issuer);
71 0 : COPY(server);
72 0 : COPY(date_from);
73 0 : COPY(date_to);
74 0 : COPY(protocol);
75 0 : COPY(cipher);
76 0 : COPY(mac);
77 0 : COPY(compression);
78 : #undef COPY
79 0 : return m_Wrapped->onTLSConnect(infoWrapped);
80 : }
81 : };
82 :
83 0 : class IqHandlerWrapper : public gloox::IqHandler
84 : {
85 : glooxwrapper::IqHandler* m_Wrapped;
86 : public:
87 0 : IqHandlerWrapper(glooxwrapper::IqHandler* wrapped) : m_Wrapped(wrapped) {}
88 :
89 0 : virtual bool handleIq(const gloox::IQ& iq)
90 : {
91 0 : glooxwrapper::IQ iqWrapper(iq);
92 0 : return m_Wrapped->handleIq(iqWrapper);
93 : }
94 :
95 0 : virtual void handleIqID(const gloox::IQ& iq, int context)
96 : {
97 0 : glooxwrapper::IQ iqWrapper(iq);
98 0 : m_Wrapped->handleIqID(iqWrapper, context);
99 0 : }
100 : };
101 :
102 0 : class MessageHandlerWrapper : public gloox::MessageHandler
103 : {
104 : glooxwrapper::MessageHandler* m_Wrapped;
105 : public:
106 0 : MessageHandlerWrapper(glooxwrapper::MessageHandler* wrapped) : m_Wrapped(wrapped) {}
107 :
108 0 : virtual void handleMessage(const gloox::Message& msg, gloox::MessageSession* UNUSED(session))
109 : {
110 : /* MessageSession not supported */
111 0 : glooxwrapper::Message msgWrapper(const_cast<gloox::Message*>(&msg), false);
112 0 : m_Wrapped->handleMessage(msgWrapper, NULL);
113 0 : }
114 : };
115 :
116 : class MUCRoomHandlerWrapper : public gloox::MUCRoomHandler
117 : {
118 : glooxwrapper::MUCRoomHandler* m_Wrapped;
119 : public:
120 0 : MUCRoomHandlerWrapper(glooxwrapper::MUCRoomHandler* wrapped) : m_Wrapped(wrapped) {}
121 :
122 0 : virtual ~MUCRoomHandlerWrapper() {}
123 :
124 0 : virtual void handleMUCParticipantPresence(gloox::MUCRoom* room, const gloox::MUCRoomParticipant participant, const gloox::Presence& presence)
125 : {
126 0 : glooxwrapper::MUCRoom roomWrapper(room, false);
127 0 : glooxwrapper::MUCRoomParticipant part;
128 0 : glooxwrapper::JID nick(*participant.nick);
129 0 : glooxwrapper::JID jid(*participant.jid);
130 0 : glooxwrapper::JID actor(*participant.actor);
131 0 : glooxwrapper::JID alternate(*participant.alternate);
132 0 : part.nick = participant.nick ? &nick : NULL;
133 0 : part.affiliation = participant.affiliation;
134 0 : part.role = participant.role;
135 0 : part.jid = participant.jid ? &jid : NULL;
136 0 : part.flags = participant.flags;
137 0 : part.reason = participant.reason;
138 0 : part.actor = participant.actor ? &actor : NULL;
139 0 : part.newNick = participant.newNick;
140 0 : part.status = participant.status;
141 0 : part.alternate = participant.alternate ? &alternate : NULL;
142 :
143 0 : m_Wrapped->handleMUCParticipantPresence(roomWrapper, part, glooxwrapper::Presence(presence.presence()));
144 :
145 : /* gloox 1.0 leaks some JIDs (fixed in 1.0.1), so clean them up */
146 : #if GLOOXVERSION == 0x10000
147 : delete participant.jid;
148 : delete participant.actor;
149 : delete participant.alternate;
150 : #endif
151 0 : }
152 :
153 0 : virtual void handleMUCMessage(gloox::MUCRoom* room, const gloox::Message& msg, bool priv)
154 : {
155 0 : glooxwrapper::MUCRoom roomWrapper(room, false);
156 0 : glooxwrapper::Message msgWrapper(const_cast<gloox::Message*>(&msg), false);
157 0 : m_Wrapped->handleMUCMessage(roomWrapper, msgWrapper, priv);
158 0 : }
159 :
160 0 : virtual bool handleMUCRoomCreation(gloox::MUCRoom* UNUSED(room))
161 : {
162 : /* Not supported */
163 0 : return false;
164 : }
165 :
166 0 : virtual void handleMUCSubject(gloox::MUCRoom* room, const std::string& nick, const std::string& subject)
167 : {
168 0 : glooxwrapper::MUCRoom roomWrapper(room, false);
169 0 : m_Wrapped->handleMUCSubject(roomWrapper, nick, subject);
170 0 : }
171 :
172 0 : virtual void handleMUCInviteDecline(gloox::MUCRoom* UNUSED(room), const gloox::JID& UNUSED(invitee), const std::string& UNUSED(reason))
173 : {
174 : /* Not supported */
175 0 : }
176 :
177 0 : virtual void handleMUCError(gloox::MUCRoom* room, gloox::StanzaError error)
178 : {
179 0 : glooxwrapper::MUCRoom roomWrapper(room, false);
180 0 : m_Wrapped->handleMUCError(roomWrapper, error);
181 0 : }
182 :
183 0 : virtual void handleMUCInfo(gloox::MUCRoom* UNUSED(room), int UNUSED(features), const std::string& UNUSED(name), const gloox::DataForm* UNUSED(infoForm))
184 : {
185 : /* Not supported */
186 0 : }
187 :
188 0 : virtual void handleMUCItems(gloox::MUCRoom* UNUSED(room), const gloox::Disco::ItemList& UNUSED(items))
189 : {
190 : /* Not supported */
191 0 : }
192 : };
193 :
194 0 : class RegistrationHandlerWrapper : public gloox::RegistrationHandler
195 : {
196 : glooxwrapper::RegistrationHandler* m_Wrapped;
197 : public:
198 0 : RegistrationHandlerWrapper(glooxwrapper::RegistrationHandler* wrapped) : m_Wrapped(wrapped) {}
199 :
200 0 : virtual void handleRegistrationFields(const gloox::JID& from, int fields, std::string instructions)
201 : {
202 0 : glooxwrapper::JID fromWrapped(from);
203 0 : m_Wrapped->handleRegistrationFields(fromWrapped, fields, instructions);
204 0 : }
205 :
206 0 : virtual void handleAlreadyRegistered(const gloox::JID& from)
207 : {
208 0 : glooxwrapper::JID fromWrapped(from);
209 0 : m_Wrapped->handleAlreadyRegistered(fromWrapped);
210 0 : }
211 :
212 0 : virtual void handleRegistrationResult(const gloox::JID& from, gloox::RegistrationResult regResult)
213 : {
214 0 : glooxwrapper::JID fromWrapped(from);
215 0 : m_Wrapped->handleRegistrationResult(fromWrapped, regResult);
216 0 : }
217 :
218 0 : virtual void handleDataForm(const gloox::JID& UNUSED(from), const gloox::DataForm& UNUSED(form))
219 : {
220 : /* DataForm not supported */
221 0 : }
222 :
223 0 : virtual void handleOOB(const gloox::JID& UNUSED(from), const gloox::OOB& UNUSED(oob))
224 : {
225 : /* OOB not supported */
226 0 : }
227 : };
228 :
229 : class StanzaExtensionWrapper : public gloox::StanzaExtension
230 : {
231 : public:
232 : const glooxwrapper::StanzaExtension* m_Wrapped;
233 : bool m_Owned;
234 : std::string m_FilterString;
235 :
236 0 : StanzaExtensionWrapper(const glooxwrapper::StanzaExtension* wrapped, bool owned) :
237 0 : gloox::StanzaExtension(wrapped->extensionType()), m_Wrapped(wrapped), m_Owned(owned)
238 : {
239 0 : m_FilterString = m_Wrapped->filterString().to_string();
240 0 : }
241 :
242 0 : ~StanzaExtensionWrapper()
243 0 : {
244 0 : if (m_Owned)
245 0 : delete m_Wrapped;
246 0 : }
247 :
248 0 : virtual const std::string& filterString() const
249 : {
250 0 : return m_FilterString;
251 : }
252 :
253 0 : virtual gloox::StanzaExtension* newInstance(const gloox::Tag* tag) const
254 : {
255 0 : glooxwrapper::Tag* tagWrapper = glooxwrapper::Tag::allocate(const_cast<gloox::Tag*>(tag), false);
256 0 : gloox::StanzaExtension* ret = new StanzaExtensionWrapper(m_Wrapped->newInstance(tagWrapper), true);
257 0 : glooxwrapper::Tag::free(tagWrapper);
258 0 : return ret;
259 : }
260 :
261 0 : virtual gloox::Tag* tag() const
262 : {
263 0 : glooxwrapper::Tag* wrapper = m_Wrapped->tag();
264 0 : gloox::Tag* ret = wrapper->stealWrapped();
265 0 : glooxwrapper::Tag::free(wrapper);
266 0 : return ret;
267 : }
268 :
269 0 : virtual gloox::StanzaExtension* clone() const
270 : {
271 0 : return new StanzaExtensionWrapper(m_Wrapped->clone(), true);
272 : }
273 : };
274 :
275 : class SessionHandlerWrapper : public gloox::Jingle::SessionHandler
276 : {
277 : public:
278 : glooxwrapper::Jingle::SessionHandler* m_Wrapped;
279 : bool m_Owned;
280 :
281 0 : SessionHandlerWrapper(glooxwrapper::Jingle::SessionHandler* wrapped, bool owned)
282 0 : : m_Wrapped(wrapped), m_Owned(owned) {}
283 :
284 0 : ~SessionHandlerWrapper()
285 0 : {
286 0 : if (m_Owned)
287 0 : delete m_Wrapped;
288 0 : }
289 :
290 0 : virtual void handleSessionAction(gloox::Jingle::Action action, gloox::Jingle::Session* session, const gloox::Jingle::Session::Jingle* jingle)
291 : {
292 0 : glooxwrapper::Jingle::Session sessionWrapper(session, false);
293 0 : glooxwrapper::Jingle::Session::Jingle jingleWrapper(jingle, false);
294 0 : m_Wrapped->handleSessionAction(action, sessionWrapper, jingleWrapper);
295 0 : }
296 :
297 0 : virtual void handleSessionActionError(gloox::Jingle::Action UNUSED(action), gloox::Jingle::Session* UNUSED(session), const gloox::Error* UNUSED(error))
298 : {
299 0 : }
300 :
301 0 : virtual void handleIncomingSession(gloox::Jingle::Session* UNUSED(session))
302 : {
303 0 : }
304 : };
305 :
306 0 : class ClientImpl
307 : {
308 : public:
309 : // List of registered callback wrappers, to get deleted when Client is deleted
310 : std::list<std::shared_ptr<gloox::ConnectionListener>> m_ConnectionListeners;
311 : std::list<std::shared_ptr<gloox::MessageHandler>> m_MessageHandlers;
312 : std::list<std::shared_ptr<gloox::IqHandler>> m_IqHandlers;
313 : };
314 :
315 1 : static const std::string XMLNS = "xmlns";
316 1 : static const std::string XMLNS_JINGLE_0AD_GAME = "urn:xmpp:jingle:apps:0ad-game:1";
317 :
318 : } // namespace glooxwrapper
319 :
320 :
321 0 : glooxwrapper::Client::Client(const string& server)
322 : {
323 0 : m_Wrapped = new gloox::Client(server.to_string());
324 0 : m_DiscoWrapper = new glooxwrapper::Disco(m_Wrapped->disco());
325 0 : m_Impl = new ClientImpl;
326 0 : }
327 :
328 0 : glooxwrapper::Client::Client(const JID& jid, const string& password, int port)
329 : {
330 0 : m_Wrapped = new gloox::Client(jid.getWrapped(), password.to_string(), port);
331 0 : m_DiscoWrapper = new glooxwrapper::Disco(m_Wrapped->disco());
332 0 : m_Impl = new ClientImpl;
333 0 : }
334 :
335 0 : glooxwrapper::Client::~Client()
336 : {
337 0 : delete m_Wrapped;
338 0 : delete m_DiscoWrapper;
339 0 : delete m_Impl;
340 0 : }
341 :
342 0 : bool glooxwrapper::Client::connect(bool block)
343 : {
344 0 : return m_Wrapped->connect(block);
345 : }
346 :
347 0 : gloox::ConnectionError glooxwrapper::Client::recv(int timeout)
348 : {
349 0 : return m_Wrapped->recv(timeout);
350 : }
351 :
352 0 : const glooxwrapper::string glooxwrapper::Client::getID() const
353 : {
354 0 : return m_Wrapped->getID();
355 : }
356 :
357 0 : const glooxwrapper::string glooxwrapper::Client::getJID() const
358 : {
359 0 : return m_Wrapped->jid().full();
360 : }
361 :
362 0 : void glooxwrapper::Client::send(const IQ& iq)
363 : {
364 0 : m_Wrapped->send(iq.getWrapped());
365 0 : }
366 :
367 0 : void glooxwrapper::Client::setTls(gloox::TLSPolicy tls)
368 : {
369 0 : m_Wrapped->setTls(tls);
370 0 : }
371 :
372 0 : void glooxwrapper::Client::setCompression(bool compression)
373 : {
374 0 : m_Wrapped->setCompression(compression);
375 0 : }
376 :
377 0 : void glooxwrapper::Client::setSASLMechanisms(int mechanisms)
378 : {
379 0 : m_Wrapped->setSASLMechanisms(mechanisms);
380 0 : }
381 :
382 0 : void glooxwrapper::Client::disconnect()
383 : {
384 0 : m_Wrapped->disconnect();
385 0 : }
386 :
387 0 : void glooxwrapper::Client::registerStanzaExtension(glooxwrapper::StanzaExtension* ext)
388 : {
389 : // ~StanzaExtensionFactory() deletes this new StanzaExtensionWrapper
390 0 : m_Wrapped->registerStanzaExtension(new StanzaExtensionWrapper(ext, true));
391 0 : }
392 :
393 0 : void glooxwrapper::Client::registerConnectionListener(glooxwrapper::ConnectionListener* hnd)
394 : {
395 0 : gloox::ConnectionListener* listener = new ConnectionListenerWrapper(hnd);
396 0 : m_Wrapped->registerConnectionListener(listener);
397 0 : m_Impl->m_ConnectionListeners.push_back(std::shared_ptr<gloox::ConnectionListener>(listener));
398 0 : }
399 :
400 0 : void glooxwrapper::Client::registerMessageHandler(glooxwrapper::MessageHandler* hnd)
401 : {
402 0 : gloox::MessageHandler* handler = new MessageHandlerWrapper(hnd);
403 0 : m_Wrapped->registerMessageHandler(handler);
404 0 : m_Impl->m_MessageHandlers.push_back(std::shared_ptr<gloox::MessageHandler>(handler));
405 0 : }
406 :
407 0 : void glooxwrapper::Client::registerIqHandler(glooxwrapper::IqHandler* ih, int exttype)
408 : {
409 0 : gloox::IqHandler* handler = new IqHandlerWrapper(ih);
410 0 : m_Wrapped->registerIqHandler(handler, exttype);
411 0 : m_Impl->m_IqHandlers.push_back(std::shared_ptr<gloox::IqHandler>(handler));
412 0 : }
413 :
414 0 : bool glooxwrapper::Client::removePresenceExtension(int type)
415 : {
416 0 : return m_Wrapped->removePresenceExtension(type);
417 : }
418 :
419 0 : void glooxwrapper::Client::setPresence(gloox::Presence::PresenceType pres, int priority, const string& status)
420 : {
421 0 : m_Wrapped->setPresence(pres, priority, status.to_string());
422 0 : }
423 :
424 :
425 0 : glooxwrapper::DelayedDelivery::DelayedDelivery(const gloox::DelayedDelivery* wrapped)
426 : {
427 0 : m_Wrapped = wrapped;
428 0 : }
429 :
430 0 : const glooxwrapper::string glooxwrapper::DelayedDelivery::stamp() const
431 : {
432 0 : return m_Wrapped->stamp();
433 : }
434 :
435 :
436 0 : glooxwrapper::Disco::Disco(gloox::Disco* wrapped)
437 : {
438 0 : m_Wrapped = wrapped;
439 0 : }
440 :
441 0 : void glooxwrapper::Disco::setVersion(const string& name, const string& version, const string& os)
442 : {
443 0 : m_Wrapped->setVersion(name.to_string(), version.to_string(), os.to_string());
444 0 : }
445 :
446 0 : void glooxwrapper::Disco::setIdentity(const string& category, const string& type, const string& name)
447 : {
448 0 : m_Wrapped->setIdentity(category.to_string(), type.to_string(), name.to_string());
449 0 : }
450 :
451 :
452 0 : glooxwrapper::IQ::IQ(gloox::IQ::IqType type, const JID& to, const string& id)
453 : {
454 0 : m_Wrapped = new gloox::IQ(type, to.getWrapped(), id.to_string());
455 0 : m_Owned = true;
456 0 : }
457 :
458 0 : glooxwrapper::IQ::~IQ()
459 : {
460 0 : if (m_Owned)
461 0 : delete m_Wrapped;
462 0 : }
463 :
464 0 : void glooxwrapper::IQ::addExtension(const glooxwrapper::StanzaExtension* se)
465 : {
466 0 : m_Wrapped->addExtension(new StanzaExtensionWrapper(se, true));
467 0 : }
468 :
469 0 : const glooxwrapper::StanzaExtension* glooxwrapper::IQ::findExtension(int type) const
470 : {
471 0 : const gloox::StanzaExtension* ext = m_Wrapped->findExtension(type);
472 0 : if (!ext)
473 0 : return NULL;
474 0 : return static_cast<const StanzaExtensionWrapper*>(ext)->m_Wrapped;
475 : }
476 :
477 0 : gloox::StanzaError glooxwrapper::IQ::error_error() const
478 : {
479 0 : const gloox::Error* error = m_Wrapped->error();
480 0 : if (!error)
481 0 : return gloox::StanzaErrorInternalServerError;
482 0 : return error->error();
483 : }
484 :
485 0 : glooxwrapper::Tag* glooxwrapper::IQ::tag() const
486 : {
487 0 : return Tag::allocate(m_Wrapped->tag(), true);
488 : }
489 :
490 0 : gloox::IQ::IqType glooxwrapper::IQ::subtype() const
491 : {
492 0 : return m_Wrapped->subtype();
493 : }
494 :
495 0 : const glooxwrapper::string glooxwrapper::IQ::id() const
496 : {
497 0 : return m_Wrapped->id();
498 : }
499 :
500 0 : const gloox::JID& glooxwrapper::IQ::from() const
501 : {
502 0 : return m_Wrapped->from();
503 : }
504 :
505 0 : glooxwrapper::JID::JID()
506 : {
507 0 : m_Wrapped = new gloox::JID();
508 0 : m_Owned = true;
509 0 : }
510 :
511 0 : glooxwrapper::JID::JID(const glooxwrapper::string& jid)
512 : {
513 0 : m_Wrapped = new gloox::JID(jid.to_string());
514 0 : m_Owned = true;
515 0 : }
516 :
517 0 : void glooxwrapper::JID::init(const char* data, size_t len)
518 : {
519 0 : m_Wrapped = new gloox::JID(std::string(data, data+len));
520 0 : m_Owned = true;
521 0 : }
522 :
523 0 : glooxwrapper::JID::~JID()
524 : {
525 0 : if (m_Owned)
526 0 : delete m_Wrapped;
527 0 : }
528 :
529 0 : glooxwrapper::string glooxwrapper::JID::username() const
530 : {
531 0 : return m_Wrapped->username();
532 : }
533 :
534 0 : glooxwrapper::string glooxwrapper::JID::resource() const
535 : {
536 0 : return m_Wrapped->resource();
537 : };
538 :
539 :
540 0 : glooxwrapper::Message::Message(gloox::Message* wrapped, bool owned)
541 : : m_Wrapped(wrapped),
542 : m_Owned(owned),
543 0 : m_From(m_Wrapped->from()),
544 0 : m_DelayedDelivery(m_Wrapped->when() ? new glooxwrapper::DelayedDelivery(m_Wrapped->when()) : nullptr)
545 : {
546 0 : }
547 :
548 0 : glooxwrapper::Message::~Message()
549 : {
550 0 : if (m_Owned)
551 0 : delete m_Wrapped;
552 0 : delete m_DelayedDelivery;
553 0 : }
554 :
555 0 : gloox::Message::MessageType glooxwrapper::Message::subtype() const
556 : {
557 0 : return m_Wrapped->subtype();
558 : }
559 :
560 0 : const glooxwrapper::JID& glooxwrapper::Message::from() const
561 : {
562 0 : return m_From;
563 : }
564 :
565 0 : glooxwrapper::string glooxwrapper::Message::body() const
566 : {
567 0 : return m_Wrapped->body();
568 : }
569 :
570 0 : glooxwrapper::string glooxwrapper::Message::subject(const string& lang) const
571 : {
572 0 : return m_Wrapped->subject(lang.to_string());
573 : }
574 :
575 0 : glooxwrapper::string glooxwrapper::Message::thread() const
576 : {
577 0 : return m_Wrapped->thread();
578 : }
579 :
580 0 : const glooxwrapper::DelayedDelivery* glooxwrapper::Message::when() const
581 : {
582 0 : return m_DelayedDelivery;
583 : }
584 :
585 0 : glooxwrapper::MUCRoom::MUCRoom(gloox::MUCRoom* room, bool owned)
586 0 : : m_Wrapped(room), m_Owned(owned), m_HandlerWrapper(nullptr)
587 : {
588 0 : }
589 :
590 0 : glooxwrapper::MUCRoom::MUCRoom(Client* parent, const JID& nick, MUCRoomHandler* mrh, MUCRoomConfigHandler* UNUSED(mrch))
591 : {
592 0 : m_HandlerWrapper = new MUCRoomHandlerWrapper(mrh);
593 0 : m_Wrapped = new gloox::MUCRoom(parent ? parent->getWrapped() : NULL, nick.getWrapped(), m_HandlerWrapper);
594 0 : m_Owned = true;
595 0 : }
596 :
597 0 : glooxwrapper::MUCRoom::~MUCRoom()
598 : {
599 0 : if (m_Owned)
600 0 : delete m_Wrapped;
601 :
602 0 : delete m_HandlerWrapper;
603 0 : }
604 :
605 0 : const glooxwrapper::string glooxwrapper::MUCRoom::nick() const
606 : {
607 0 : return m_Wrapped->nick();
608 : }
609 :
610 0 : const glooxwrapper::string glooxwrapper::MUCRoom::name() const
611 : {
612 0 : return m_Wrapped->name();
613 : }
614 :
615 0 : const glooxwrapper::string glooxwrapper::MUCRoom::service() const
616 : {
617 0 : return m_Wrapped->service();
618 : }
619 :
620 0 : void glooxwrapper::MUCRoom::join(gloox::Presence::PresenceType type, const string& status, int priority)
621 : {
622 0 : m_Wrapped->join(type, status.to_string(), priority);
623 0 : }
624 :
625 0 : void glooxwrapper::MUCRoom::leave(const string& msg)
626 : {
627 0 : m_Wrapped->leave(msg.to_string());
628 0 : }
629 :
630 0 : void glooxwrapper::MUCRoom::send(const string& message)
631 : {
632 0 : m_Wrapped->send(message.to_string());
633 0 : }
634 :
635 0 : void glooxwrapper::MUCRoom::setNick(const string& nick)
636 : {
637 0 : m_Wrapped->setNick(nick.to_string());
638 0 : }
639 :
640 0 : void glooxwrapper::MUCRoom::setPresence(gloox::Presence::PresenceType presence, const string& msg)
641 : {
642 0 : m_Wrapped->setPresence(presence, msg.to_string());
643 0 : }
644 :
645 0 : void glooxwrapper::MUCRoom::setRequestHistory(int value, gloox::MUCRoom::HistoryRequestType type)
646 : {
647 0 : m_Wrapped->setRequestHistory(value, type);
648 0 : }
649 :
650 0 : void glooxwrapper::MUCRoom::kick(const string& nick, const string& reason)
651 : {
652 0 : m_Wrapped->kick(nick.to_string(), reason.to_string());
653 0 : }
654 :
655 0 : void glooxwrapper::MUCRoom::ban(const string& nick, const string& reason)
656 : {
657 0 : m_Wrapped->ban(nick.to_string(), reason.to_string());
658 0 : }
659 :
660 :
661 0 : glooxwrapper::Registration::Registration(Client* parent)
662 : {
663 0 : m_Wrapped = new gloox::Registration(parent->getWrapped());
664 0 : }
665 :
666 0 : glooxwrapper::Registration::~Registration()
667 : {
668 0 : delete m_Wrapped;
669 0 : }
670 :
671 0 : void glooxwrapper::Registration::fetchRegistrationFields()
672 : {
673 0 : m_Wrapped->fetchRegistrationFields();
674 0 : }
675 :
676 0 : bool glooxwrapper::Registration::createAccount(int fields, const glooxwrapper::RegistrationFields& values)
677 : {
678 0 : gloox::RegistrationFields valuesUnwrapped;
679 : #define COPY(n) valuesUnwrapped.n = values.n.to_string()
680 0 : COPY(username);
681 0 : COPY(nick);
682 0 : COPY(password);
683 0 : COPY(name);
684 0 : COPY(first);
685 0 : COPY(last);
686 0 : COPY(email);
687 0 : COPY(address);
688 0 : COPY(city);
689 0 : COPY(state);
690 0 : COPY(zip);
691 0 : COPY(phone);
692 0 : COPY(url);
693 0 : COPY(date);
694 0 : COPY(misc);
695 0 : COPY(text);
696 : #undef COPY
697 0 : return m_Wrapped->createAccount(fields, valuesUnwrapped);
698 : }
699 :
700 0 : void glooxwrapper::Registration::registerRegistrationHandler(RegistrationHandler* rh)
701 : {
702 0 : gloox::RegistrationHandler* handler = new RegistrationHandlerWrapper(rh);
703 0 : m_Wrapped->registerRegistrationHandler(handler);
704 0 : m_RegistrationHandlers.push_back(std::shared_ptr<gloox::RegistrationHandler>(handler));
705 0 : }
706 :
707 :
708 0 : glooxwrapper::Tag::Tag(const string& name)
709 : {
710 0 : m_Wrapped = new gloox::Tag(name.to_string());
711 0 : m_Owned = true;
712 0 : }
713 :
714 0 : glooxwrapper::Tag::Tag(const string& name, const string& cdata)
715 : {
716 0 : m_Wrapped = new gloox::Tag(name.to_string(), cdata.to_string());
717 0 : m_Owned = true;
718 0 : }
719 :
720 0 : glooxwrapper::Tag::~Tag()
721 : {
722 0 : if (m_Owned)
723 0 : delete m_Wrapped;
724 0 : }
725 :
726 0 : glooxwrapper::Tag* glooxwrapper::Tag::allocate(const string& name)
727 : {
728 0 : return new glooxwrapper::Tag(name);
729 : }
730 :
731 0 : glooxwrapper::Tag* glooxwrapper::Tag::allocate(const string& name, const string& cdata)
732 : {
733 0 : return new glooxwrapper::Tag(name, cdata);
734 : }
735 :
736 0 : glooxwrapper::Tag* glooxwrapper::Tag::allocate(gloox::Tag* wrapped, bool owned)
737 : {
738 0 : return new glooxwrapper::Tag(wrapped, owned);
739 : }
740 :
741 0 : void glooxwrapper::Tag::free(const glooxwrapper::Tag* tag)
742 : {
743 0 : delete tag;
744 0 : }
745 :
746 0 : bool glooxwrapper::Tag::addAttribute(const string& name, const string& value)
747 : {
748 0 : return m_Wrapped->addAttribute(name.to_string(), value.to_string());
749 : }
750 :
751 0 : glooxwrapper::string glooxwrapper::Tag::findAttribute(const string& name) const
752 : {
753 0 : return m_Wrapped->findAttribute(name.to_string());
754 : }
755 :
756 0 : glooxwrapper::Tag* glooxwrapper::Tag::clone() const
757 : {
758 0 : return new glooxwrapper::Tag(m_Wrapped->clone(), true);
759 : }
760 :
761 0 : glooxwrapper::string glooxwrapper::Tag::xmlns() const
762 : {
763 0 : return m_Wrapped->xmlns();
764 : }
765 :
766 0 : bool glooxwrapper::Tag::setXmlns(const string& xmlns)
767 : {
768 0 : return m_Wrapped->setXmlns(xmlns.to_string());
769 : }
770 :
771 0 : glooxwrapper::string glooxwrapper::Tag::xml() const
772 : {
773 0 : return m_Wrapped->xml();
774 : }
775 :
776 0 : void glooxwrapper::Tag::addChild(Tag* child)
777 : {
778 0 : m_Wrapped->addChild(child->stealWrapped());
779 0 : Tag::free(child);
780 0 : }
781 :
782 0 : glooxwrapper::string glooxwrapper::Tag::name() const
783 : {
784 0 : return m_Wrapped->name();
785 : }
786 :
787 0 : glooxwrapper::string glooxwrapper::Tag::cdata() const
788 : {
789 0 : return m_Wrapped->cdata();
790 : }
791 :
792 0 : const glooxwrapper::Tag* glooxwrapper::Tag::findTag_clone(const string& expression) const
793 : {
794 0 : const gloox::Tag* tag = m_Wrapped->findTag(expression.to_string());
795 0 : if (!tag)
796 0 : return NULL;
797 0 : return new glooxwrapper::Tag(const_cast<gloox::Tag*>(tag), false);
798 : }
799 :
800 0 : glooxwrapper::ConstTagList glooxwrapper::Tag::findTagList_clone(const string& expression) const
801 : {
802 0 : glooxwrapper::ConstTagList tagListWrapper;
803 0 : for (const gloox::Tag* const& t : m_Wrapped->findTagList(expression.to_string()))
804 0 : tagListWrapper.push_back(new glooxwrapper::Tag(const_cast<gloox::Tag*>(t), false));
805 0 : return tagListWrapper;
806 : }
807 :
808 0 : glooxwrapper::Jingle::Plugin::~Plugin()
809 : {
810 0 : if (m_Owned)
811 0 : delete m_Wrapped;
812 0 : }
813 :
814 0 : const glooxwrapper::Jingle::Plugin glooxwrapper::Jingle::Plugin::findPlugin(int type) const
815 : {
816 0 : return glooxwrapper::Jingle::Plugin(m_Wrapped->findPlugin(type), false);
817 : }
818 :
819 0 : glooxwrapper::Jingle::ICEUDP::Candidate glooxwrapper::Jingle::Session::Jingle::getCandidate() const
820 : {
821 0 : const gloox::Jingle::Content* content = static_cast<const gloox::Jingle::Content*>(m_Wrapped->plugins().front());
822 0 : if (!content)
823 0 : return glooxwrapper::Jingle::ICEUDP::Candidate();
824 :
825 0 : const gloox::Jingle::ICEUDP* iceUDP = static_cast<const gloox::Jingle::ICEUDP*>(content->findPlugin(gloox::Jingle::PluginICEUDP));
826 0 : if (!iceUDP)
827 0 : return glooxwrapper::Jingle::ICEUDP::Candidate();
828 :
829 0 : gloox::Jingle::ICEUDP::Candidate glooxCandidate = iceUDP->candidates().front();
830 0 : return glooxwrapper::Jingle::ICEUDP::Candidate{glooxCandidate.ip, glooxCandidate.port};
831 : }
832 :
833 0 : glooxwrapper::Jingle::Session::Session(gloox::Jingle::Session* wrapped, bool owned)
834 0 : : m_Wrapped(wrapped), m_Owned(owned)
835 : {
836 0 : }
837 :
838 0 : glooxwrapper::Jingle::Session::~Session()
839 : {
840 0 : if (m_Owned)
841 0 : delete m_Wrapped;
842 0 : }
843 :
844 0 : bool glooxwrapper::Jingle::Session::sessionInitiate(const char* ipStr, u16 port)
845 : {
846 0 : gloox::Jingle::ICEUDP::CandidateList candidateList;
847 :
848 0 : candidateList.push_back(gloox::Jingle::ICEUDP::Candidate
849 : {
850 : "1", // component_id,
851 : "1", // foundation
852 : "0", // andidate_generation
853 : "1", // candidate_id
854 : ipStr,
855 : "0", // network
856 : port,
857 : 0, // priotiry
858 : "udp",
859 : "", // base_ip
860 : 0, // base_port
861 : gloox::Jingle::ICEUDP::ServerReflexive
862 : });
863 :
864 : // sessionInitiate deletes the new Content, and
865 : // the Plugin destructor inherited by Content frees the ICEUDP plugin.
866 :
867 0 : gloox::Jingle::PluginList pluginList;
868 0 : pluginList.push_back(new gloox::Jingle::ICEUDP(/*local_pwd*/"", /*local_ufrag*/"", candidateList));
869 :
870 0 : return m_Wrapped->sessionInitiate(new gloox::Jingle::Content(std::string("game-data"), pluginList));
871 : }
872 :
873 0 : glooxwrapper::SessionManager::SessionManager(Client* parent, Jingle::SessionHandler* sh)
874 : {
875 0 : m_HandlerWrapper = new SessionHandlerWrapper(sh, false);
876 0 : m_Wrapped = new gloox::Jingle::SessionManager(parent->getWrapped(), m_HandlerWrapper);
877 0 : }
878 :
879 0 : glooxwrapper::SessionManager::~SessionManager()
880 : {
881 0 : delete m_Wrapped;
882 0 : delete m_HandlerWrapper;
883 0 : }
884 :
885 0 : void glooxwrapper::SessionManager::registerPlugins()
886 : {
887 : // This calls m_factory.registerPlugin (see jinglesessionmanager.cpp), hence
888 : // ~PluginFactory() will delete these new plugin templates.
889 0 : m_Wrapped->registerPlugin(new gloox::Jingle::Content());
890 0 : m_Wrapped->registerPlugin(new gloox::Jingle::ICEUDP());
891 0 : }
892 :
893 0 : glooxwrapper::Jingle::Session glooxwrapper::SessionManager::createSession(const JID& callee)
894 : {
895 : // The wrapped gloox SessionManager keeps track of this session and deletes it on ~SessionManager().
896 0 : gloox::Jingle::Session* glooxSession = m_Wrapped->createSession(callee.getWrapped(), m_HandlerWrapper);
897 :
898 : // Hence the glooxwrapper::Jingle::Session may not own the gloox::Jingle::Session.
899 0 : return glooxwrapper::Jingle::Session(glooxSession, false);
900 3 : }
|
