gloox 1.0.28
mucroom.cpp
1/*
2 Copyright (c) 2006-2023 by Jakob Schröter <js@camaya.net>
3 This file is part of the gloox library. http://camaya.net/gloox
4
5 This software is distributed under a license. The full license
6 agreement can be found in the file LICENSE in this distribution.
7 This software may not be copied, modified, sold or distributed
8 other than expressed in the named license agreement.
9
10 This software is distributed without any warranty.
11*/
12
13
14
15#include "mucroom.h"
16#include "clientbase.h"
17#include "dataform.h"
18#include "presence.h"
19#include "disco.h"
20#include "mucmessagesession.h"
21#include "message.h"
22#include "error.h"
23#include "util.h"
24#include "tag.h"
25
26namespace gloox
27{
28
29 // ---- MUCRoom::MUCAdmin ----
30 /* Error type values */
31 static const char* affiliationValues [] = {
32 "none",
33 "outcast",
34 "member",
35 "owner",
36 "admin"
37 };
38
39 /* Stanza error values */
40 static const char* roleValues [] = {
41 "none",
42 "visitor",
43 "participant",
44 "moderator",
45 };
46
48 const char* historyTypeValues[] =
49 {
50 "maxchars", "maxstanzas", "seconds", "since"
51 };
52
53 static inline MUCRoomAffiliation affiliationType( const std::string& type )
54 {
55 return static_cast<MUCRoomAffiliation>( util::lookup( type, affiliationValues ) );
56 }
57
58 static inline MUCRoomRole roleType( const std::string& type )
59 {
60 return static_cast<MUCRoomRole>( util::lookup( type, roleValues ) );
61 }
62
63 MUCRoom::MUCAdmin::MUCAdmin( MUCRoomRole role, const std::string& nick,
64 const std::string& reason )
65 : StanzaExtension( ExtMUCAdmin ), m_affiliation( AffiliationInvalid ), m_role( role )
66 {
67 m_list.push_back( MUCListItem( nick, role, reason ) );
68 }
69
70 MUCRoom::MUCAdmin::MUCAdmin( MUCRoomAffiliation affiliation, const std::string& nick,
71 const std::string& reason )
72 : StanzaExtension( ExtMUCAdmin ), m_affiliation( affiliation ), m_role( RoleInvalid )
73 {
74 m_list.push_back( MUCListItem( nick, affiliation, reason ) );
75 }
76
77 MUCRoom::MUCAdmin::MUCAdmin( MUCOperation operation, const MUCListItemList& jids )
78 : StanzaExtension( ExtMUCAdmin ), m_list( jids ), m_affiliation( AffiliationInvalid ),
79 m_role( RoleInvalid )
80 {
81 switch( operation )
82 {
83 case StoreVoiceList:
85 m_role = RoleParticipant;
86 break;
89 m_role = RoleModerator;
90 break;
91 case StoreBanList:
92 case RequestBanList:
93 m_affiliation = AffiliationOutcast;
94 break;
95 case StoreMemberList:
97 m_affiliation = AffiliationMember;
98 break;
99 case StoreOwnerList:
100 case RequestOwnerList:
101 m_affiliation = AffiliationOwner;
102 break;
103 case StoreAdminList:
104 case RequestAdminList:
105 m_affiliation = AffiliationAdmin;
106 break;
107 default:
108 return;
109 break;
110 }
111
112 if( m_list.empty() )
113 m_list.push_back( MUCListItem( JID() ) );
114 }
115
116 MUCRoom::MUCAdmin::MUCAdmin( const Tag* tag )
117 : StanzaExtension( ExtMUCAdmin ), m_affiliation( AffiliationInvalid ), m_role( RoleInvalid )
118 {
119 if( !tag || tag->name() != "query" || tag->xmlns() != XMLNS_MUC_ADMIN )
120 return;
121
122 const TagList& items = tag->findChildren( "item" );
123 TagList::const_iterator it = items.begin();
124 for( ; it != items.end(); ++it )
125 {
126 m_list.push_back( MUCListItem( JID( (*it)->findAttribute( "jid" ) ),
127 roleType( (*it)->findAttribute( "role" ) ),
128 affiliationType( (*it)->findAttribute( "affiliation" ) ),
129 (*it)->findAttribute( "nick" ) ) );
130 if( m_role == RoleInvalid )
131 m_role = roleType( (*it)->findAttribute( "role" ) );
132 if( m_affiliation == AffiliationInvalid )
133 m_affiliation = affiliationType( (*it)->findAttribute( "affiliation" ) );
134 }
135 }
136
137 MUCRoom::MUCAdmin::~MUCAdmin()
138 {
139 }
140
141 const std::string& MUCRoom::MUCAdmin::filterString() const
142 {
143 static const std::string filter = "/iq/query[@xmlns='" + XMLNS_MUC_ADMIN + "']";
144 return filter;
145 }
146
147 Tag* MUCRoom::MUCAdmin::tag() const
148 {
149 Tag* t = new Tag( "query" );
150 t->setXmlns( XMLNS_MUC_ADMIN );
151
152 if( m_list.empty() || ( m_affiliation == AffiliationInvalid && m_role == RoleInvalid ) )
153 return t;
154
155 MUCListItemList::const_iterator it = m_list.begin();
156 for( ; it != m_list.end(); ++it )
157 {
158 Tag* i = new Tag( t, "item" );
159 if( (*it).jid() )
160 i->addAttribute( "jid", (*it).jid().bare() );
161 if( !(*it).nick().empty() )
162 i->addAttribute( "nick", (*it).nick() );
163
165 if( (*it).role() != RoleInvalid )
166 rol = (*it).role();
167 else if( m_role != RoleInvalid )
168 rol = m_role;
169 if( rol != RoleInvalid )
170 i->addAttribute( "role", util::lookup( rol, roleValues ) );
171
173 if( (*it).affiliation() != AffiliationInvalid )
174 aff = (*it).affiliation();
175 else if( m_affiliation != AffiliationInvalid )
176 aff = m_affiliation;
177 if( aff != AffiliationInvalid )
178 i->addAttribute( "affiliation", util::lookup( aff, affiliationValues ) );
179 if( !(*it).reason().empty() )
180 new Tag( i, "reason", (*it).reason() );
181 }
182
183 return t;
184 }
185 // ---- ~MUCRoom::MUCAdmin ----
186
187 // ---- MUCRoom::MUCOwner ----
188 MUCRoom::MUCOwner::MUCOwner( QueryType type, DataForm* form )
189 : StanzaExtension( ExtMUCOwner ), m_type( type ), m_form( form )
190 {
191 m_valid = true;
192
193 if( m_form )
194 return;
195
196 switch( type )
197 {
198 case TypeCancelConfig:
199 m_form = new DataForm( TypeCancel );
200 break;
201 case TypeInstantRoom:
202 m_form = new DataForm( TypeSubmit );
203 break;
204 default:
205 break;
206 }
207 }
208
209 MUCRoom::MUCOwner::MUCOwner( const JID& alternate, const std::string& reason,
210 const std::string& password )
211 : StanzaExtension( ExtMUCOwner ), m_type( TypeDestroy ), m_jid( alternate ),
212 m_reason( reason ), m_pwd( password ), m_form( 0 )
213 {
214 m_valid = true;
215 }
216
217 MUCRoom::MUCOwner::MUCOwner( const Tag* tag )
218 : StanzaExtension( ExtMUCOwner ), m_type( TypeIncomingTag ), m_form( 0 )
219 {
220 if( !tag || tag->name() != "query" || tag->xmlns() != XMLNS_MUC_OWNER )
221 return;
222
223 const TagList& l = tag->children();
224 TagList::const_iterator it = l.begin();
225 for( ; it != l.end(); ++it )
226 {
227 const std::string& name = (*it)->name();
228 if( name == "x" && (*it)->xmlns() == XMLNS_X_DATA )
229 {
230 m_form = new DataForm( (*it) );
231 break;
232 }
233 else if( name == "destroy" )
234 {
235 m_type = TypeDestroy;
236 m_jid = (*it)->findAttribute( "jid" );
237 m_pwd = (*it)->findCData( "/query/destroy/password" );
238 m_reason = (*it)->findCData( "/query/destroy/reason" );
239 break;
240 }
241 }
242 m_valid = true;
243 }
244
245 MUCRoom::MUCOwner::~MUCOwner()
246 {
247 delete m_form;
248 }
249
250 const std::string& MUCRoom::MUCOwner::filterString() const
251 {
252 static const std::string filter = "/iq/query[@xmlns='" + XMLNS_MUC_OWNER + "']";
253 return filter;
254 }
255
256 Tag* MUCRoom::MUCOwner::tag() const
257 {
258 if( !m_valid )
259 return 0;
260
261 Tag* t = new Tag( "query" );
262 t->setXmlns( XMLNS_MUC_OWNER );
263
264 switch( m_type )
265 {
266 case TypeInstantRoom:
267 case TypeSendConfig:
268 case TypeCancelConfig:
269 case TypeIncomingTag:
270 if( m_form )
271 t->addChild( m_form->tag() );
272 break;
273 case TypeDestroy:
274 {
275 Tag* d = new Tag( t, "destroy" );
276 if( m_jid )
277 d->addAttribute( "jid", m_jid.bare() );
278
279 if( !m_reason.empty() )
280 new Tag( d, "reason", m_reason );
281
282 if( !m_pwd.empty() )
283 new Tag( d, "password", m_pwd );
284
285 break;
286 }
287 case TypeRequestConfig:
288 case TypeCreate:
289 default:
290 break;
291 }
292
293 return t;
294 }
295 // ---- ~MUCRoom::MUCOwner ----
296
297 // ---- MUCRoom::MUCUser ----
298 MUCRoom::MUCUser::MUCUser( MUCUserOperation operation, const std::string& to,
299 const std::string& reason, const std::string& thread )
300 : StanzaExtension( ExtMUCUser ), m_affiliation( AffiliationInvalid ), m_role( RoleInvalid ),
301 m_jid( new std::string( to ) ), m_actor( 0 ),
302 m_thread( thread.empty() ? 0 : new std::string( thread ) ),
303 m_reason( new std::string( reason ) ), m_newNick( 0 ), m_password( 0 ), m_alternate( 0 ),
304 m_operation( operation ),
305 m_flags( 0 ), m_del( false ), m_continue( !thread.empty() )
306 {
307 }
308
310 : StanzaExtension( ExtMUCUser ), m_affiliation( AffiliationInvalid ), m_role( RoleInvalid ),
311 m_jid( 0 ), m_actor( 0 ), m_thread( 0 ), m_reason( 0 ), m_newNick( 0 ),
312 m_password( 0 ), m_alternate( 0 ), m_operation( OpNone ),
313 m_flags( 0 ), m_del( false ), m_continue( false )
314 {
315 if( !tag || tag->name() != "x" || tag->xmlns() != XMLNS_MUC_USER )
316 return;
317
318 const Tag* t = 0;
319 const TagList& l = tag->children();
320 TagList::const_iterator it = l.begin();
321 for( ; it != l.end(); ++it )
322 {
323 if( (*it)->name() == "item" )
324 {
325 m_affiliation = getEnumAffiliation( (*it)->findAttribute( "affiliation" ) );
326 m_role = getEnumRole( (*it)->findAttribute( "role" ) );
327
328 if( (*it)->hasAttribute( "jid" ) )
329 m_jid = new std::string( (*it)->findAttribute( "jid" ) );
330
331 if( ( t = (*it)->findChild( "actor" ) ) )
332 m_actor = new std::string( t->findAttribute( "jid" ) );
333
334 if( ( t = (*it)->findChild( "reason" ) ) )
335 m_reason = new std::string( t->cdata() );
336
337 if( (*it)->hasAttribute( "nick" ) )
338 m_newNick = new std::string( (*it)->findAttribute( "nick" ) );
339 }
340 else if( (*it)->name() == "status" )
341 {
342 const std::string& code = (*it)->findAttribute( "code" );
343 if( code == "100" )
344 m_flags |= FlagNonAnonymous;
345 else if( code == "101" )
346 m_flags |= UserAffiliationChangedWNR;
347 else if( code == "110" )
348 m_flags |= UserSelf;
349 else if( code == "170" )
350 m_flags |= FlagPublicLogging;
351 else if( code == "201" )
352 m_flags |= UserNewRoom;
353 else if( code == "210" )
354 m_flags |= UserNickAssigned;
355 else if( code == "301" )
356 m_flags |= UserBanned;
357 else if( code == "303" )
358 m_flags |= UserNickChanged;
359 else if( code == "307" )
360 m_flags |= UserKicked;
361 else if( code == "321" )
362 m_flags |= UserAffiliationChanged;
363 else if( code == "322" )
364 m_flags |= UserMembershipRequired;
365 else if( code == "332" )
366 m_flags |= UserRoomShutdown;
367 }
368 else if( (*it)->name() == "destroy" )
369 {
370 m_del = true;
371 if( (*it)->hasAttribute( "jid" ) )
372 m_alternate = new std::string( (*it)->findAttribute( "jid" ) );
373
374 if( ( t = (*it)->findChild( "reason" ) ) )
375 m_reason = new std::string( t->cdata() );
376
377 m_flags |= UserRoomDestroyed;
378 }
379 else if( (*it)->name() == "invite" )
380 {
381 m_operation = OpInviteFrom;
382 m_jid = new std::string( (*it)->findAttribute( "from" ) );
383 if( m_jid->empty() )
384 {
385 m_operation = OpInviteTo;
386 m_jid->assign( (*it)->findAttribute( "to" ) );
387 }
388 if( (*it)->hasChild( "reason" ) )
389 m_reason = new std::string( (*it)->findChild( "reason" )->cdata() );
390 if( (*it)->hasChild( "continue" ) )
391 {
392 m_continue = true;
393 m_thread = new std::string( (*it)->findChild( "continue" )->findAttribute( "thread" ) );
394 }
395 }
396 else if( (*it)->name() == "decline" )
397 {
398 m_operation = OpDeclineFrom;
399 m_jid = new std::string( (*it)->findAttribute( "from" ) );
400 if( m_jid->empty() )
401 {
402 m_operation = OpDeclineTo;
403 m_jid->assign( (*it)->findAttribute( "from" ) );
404 }
405 if( (*it)->hasChild( "reason" ) )
406 m_reason = new std::string( (*it)->findChild( "reason" )->cdata() );
407 }
408 else if( (*it)->name() == "password" )
409 {
410 m_password = new std::string( (*it)->cdata() );
411 }
412 }
413 }
414
416 {
417 delete m_jid;
418 delete m_actor;
419 delete m_thread;
420 delete m_reason;
421 delete m_newNick;
422 delete m_password;
423 delete m_alternate;
424 }
425
426 MUCRoomRole MUCRoom::MUCUser::getEnumRole( const std::string& role )
427 {
428 if( role == "moderator" )
429 return RoleModerator;
430 if( role == "participant" )
431 return RoleParticipant;
432 if( role == "visitor" )
433 return RoleVisitor;
434 return RoleNone;
435 }
436
437 MUCRoomAffiliation MUCRoom::MUCUser::getEnumAffiliation( const std::string& affiliation )
438 {
439 if( affiliation == "owner" )
440 return AffiliationOwner;
441 if( affiliation == "admin" )
442 return AffiliationAdmin;
443 if( affiliation == "member" )
444 return AffiliationMember;
445 if( affiliation == "outcast" )
446 return AffiliationOutcast;
447 return AffiliationNone;
448 }
449
450 const std::string& MUCRoom::MUCUser::filterString() const
451 {
452 static const std::string filter = "/presence/x[@xmlns='" + XMLNS_MUC_USER + "']"
453 "|/message/x[@xmlns='" + XMLNS_MUC_USER + "']";
454 return filter;
455 }
456
458 {
459 Tag* t = new Tag( "x" );
461
462 if( m_affiliation != AffiliationInvalid || m_role != RoleInvalid )
463 {
464 Tag* i = new Tag( t, "item" );
465 if( m_jid )
466 i->addAttribute( "jid", *m_jid );
467 if( m_role != RoleInvalid )
468 i->addAttribute( "role", util::lookup( m_role, roleValues ) );
469 if( m_affiliation != AffiliationInvalid )
470 i->addAttribute( "affiliation", util::lookup( m_affiliation, affiliationValues ) );
471
472 if( m_actor )
473 new Tag( i, "actor", "jid", *m_actor );
474
475 if( m_reason )
476 new Tag( i, "reason", *m_reason );
477
478 if( m_flags & FlagNonAnonymous )
479 new Tag( t, "status", "code", "100" );
480 if( m_flags & UserAffiliationChangedWNR )
481 new Tag( t, "status", "code", "101" );
482 if( m_flags & UserSelf )
483 new Tag( t, "status", "code", "110" );
484 if( m_flags & FlagPublicLogging )
485 new Tag( t, "status", "code", "170" );
486 if( m_flags & UserNewRoom )
487 new Tag( t, "status", "code", "201" );
488 if( m_flags & UserNickAssigned )
489 new Tag( t, "status", "code", "210" );
490 if( m_flags & UserBanned )
491 new Tag( t, "status", "code", "301" );
492 if( m_flags & UserNickChanged )
493 new Tag( t, "status", "code", "303" );
494 if( m_flags & UserKicked )
495 new Tag( t, "status", "code", "307" );
496 if( m_flags & UserAffiliationChanged )
497 new Tag( t, "status", "code", "321" );
498 if( m_flags & UserMembershipRequired )
499 new Tag( t, "status", "code", "322" );
500 if( m_flags & UserRoomShutdown )
501 new Tag( t, "status", "code", "332" );
502 }
503 else if( m_del )
504 {
505 Tag* d = new Tag( t, "destroy" );
506 if( m_alternate )
507 d->addAttribute( "jid", *m_alternate );
508 if( m_reason )
509 new Tag( d, "reason", *m_reason );
510 }
511 else if( m_operation != OpNone && m_jid )
512 {
513 Tag* d = 0;
514 if( m_operation == OpInviteTo )
515 d = new Tag( t, "invite", "to", *m_jid );
516 else if( m_operation == OpInviteFrom )
517 d = new Tag( t, "invite", "from", *m_jid );
518 else if( m_operation == OpDeclineTo )
519 d = new Tag( t, "decline", "to", *m_jid );
520 else if( m_operation == OpDeclineFrom )
521 d = new Tag( t, "decline", "from", *m_jid );
522
523 if( m_reason )
524 new Tag( d, "reason", *m_reason );
525
526 if( m_continue )
527 {
528 Tag* c = new Tag( d, "continue" );
529 if( m_thread )
530 c->addAttribute( "thread", *m_thread );
531 }
532
533 if( m_password )
534 new Tag( t, "password", *m_password );
535
536 }
537
538 return t;
539 }
540 // ---- ~MUCRoom::MUCUser ----
541
542 // ---- MUCRoom::MUC ----
543 MUCRoom::MUC::MUC( const std::string& password,
544 MUCRoom::HistoryRequestType historyType,
545 const std::string& historySince,
546 int historyValue )
548 m_password( password.empty() ? 0 : new std::string( password ) ),
549 m_historySince( new std::string( historySince ) ),
550 m_historyType( historyType ), m_historyValue( historyValue )
551 {
552 }
553
554 MUCRoom::MUC::MUC( const Tag* tag )
556 m_password( 0 ), m_historySince( 0 ),
557 m_historyType( HistoryUnknown ), m_historyValue( 0 )
558 {
559 if( !tag || tag->name() != "x" || tag->xmlns() != XMLNS_MUC_USER )
560 return;
561
562 const TagList& l = tag->children();
563 TagList::const_iterator it = l.begin();
564 for( ; it != l.end(); ++it )
565 {
566 if( (*it)->name() == "history" )
567 {
568 if( (*it)->hasAttribute( "seconds" ) )
569 m_historyValue = atoi( (*it)->findAttribute( "seconds" ).c_str() );
570 else if( (*it)->hasAttribute( "maxstanzas" ) )
571 m_historyValue = atoi( (*it)->findAttribute( "maxstanzas" ).c_str() );
572 else if( (*it)->hasAttribute( "maxchars" ) )
573 m_historyValue = atoi( (*it)->findAttribute( "maxchars" ).c_str() );
574 else if( (*it)->hasAttribute( "since" ) )
575 m_historySince = new std::string( (*it)->findAttribute( "since" ) );
576 }
577 else if( (*it)->name() == "password" )
578 {
579 m_password = new std::string( (*it)->cdata() );
580 }
581 }
582 }
583
585 {
586 delete m_password;
587 delete m_historySince;
588 }
589
590 const std::string& MUCRoom::MUC::filterString() const
591 {
592 static const std::string filter = "/presence/x[@xmlns='" + XMLNS_MUC + "']";
593 return filter;
594 }
595
597 {
598 Tag* t = new Tag( "x" );
599 t->setXmlns( XMLNS_MUC );
600
601 if( m_historyType != HistoryUnknown )
602 {
603 const std::string& histStr = util::lookup( m_historyType, historyTypeValues );
604 Tag* h = new Tag( t, "history" );
605 if( m_historyType == HistorySince && m_historySince )
606 h->addAttribute( histStr, *m_historySince );
607 else
608 h->addAttribute( histStr, m_historyValue );
609 }
610
611 if( m_password )
612 new Tag( t, "password", *m_password );
613
614 return t;
615 }
616 // ---- ~MUCRoom::MUC ----
617
618 // --- MUCRoom ----
621 : m_parent( parent ), m_nick( nick ), m_joined( false ), m_roomHandler( mrh ),
622 m_roomConfigHandler( mrch ), m_session( 0 ), m_affiliation( AffiliationNone ),
623 m_role( RoleNone ), m_historyType( HistoryUnknown ), m_historyValue( 0 ),
624 m_flags( 0 ), m_creationInProgress( false ), m_configChanged( false ),
625 m_publishNick( false ), m_publish( false ), m_unique( false )
626 {
627 if( m_parent )
628 {
629 m_parent->registerStanzaExtension( new MUCAdmin() );
630 m_parent->registerStanzaExtension( new MUCOwner() );
631 m_parent->registerStanzaExtension( new MUCUser() );
632 m_parent->registerStanzaExtension( new MUC() );
633 m_parent->registerStanzaExtension( new DelayedDelivery() );
634 }
635 }
636
638 {
639 if( m_joined )
640 leave();
641
642 if( m_parent )
643 {
644 if( m_publish )
645 m_parent->disco()->removeNodeHandler( this, XMLNS_MUC_ROOMS );
646
647 m_parent->removeIDHandler( this );
648// m_parent->removeStanzaExtension( ExtMUCAdmin ); // don't remove, other rooms might need it
649// m_parent->removeStanzaExtension( ExtMUCOwner );
650 m_parent->removePresenceHandler( m_nick.bareJID(), this );
651 m_parent->disco()->removeDiscoHandler( this );
652 }
653 }
654
655 void MUCRoom::join( Presence::PresenceType type, const std::string& status, int priority )
656 {
657 if( m_joined || !m_parent )
658 return;
659
660 m_parent->registerPresenceHandler( m_nick.bareJID(), this );
661
662 m_session = new MUCMessageSession( m_parent, m_nick.bareJID() );
663 m_session->registerMessageHandler( this );
664
665 Presence pres( type, m_nick.full(), status, priority );
666 pres.addExtension( new MUC( m_password, m_historyType, m_historySince, m_historyValue ) );
667 m_joined = true;
668 m_parent->send( pres );
669 }
670
671 void MUCRoom::leave( const std::string& msg )
672 {
673 if( !m_joined )
674 return;
675
676 if( m_parent )
677 {
678 Presence pres( Presence::Unavailable, m_nick.full(), msg );
679 m_parent->send( pres );
680 m_parent->removePresenceHandler( m_nick.bareJID(), this );
681 m_parent->disposeMessageSession( m_session );
682 }
683
684 m_session = 0;
685 m_joined = false;
686 }
687
688 void MUCRoom::destroy( const std::string& reason, const JID& alternate, const std::string& password )
689 {
690 if( !m_parent )
691 return;
692
693 const std::string& id = m_parent->getID();
694 IQ iq( IQ::Set, m_nick.bareJID(), id );
695 iq.addExtension( new MUCOwner( alternate, reason, password ) );
696 m_parent->send( iq, this, DestroyRoom );
697 }
698
699 void MUCRoom::send( const std::string& message )
700 {
701 if( m_session && m_joined )
702 m_session->send( message );
703 }
704
705 void MUCRoom::send( const std::string& message, const std::string& subject, const StanzaExtensionList& sel )
706 {
707 if( m_session && m_joined )
708 m_session->send( message, subject, sel );
709 }
710
711 void MUCRoom::setSubject( const std::string& subject )
712 {
713 if( m_session && m_joined )
714 m_session->setSubject( subject );
715 }
716
717 void MUCRoom::setNick( const std::string& nick )
718 {
719 if( m_parent && m_joined )
720 {
721 m_newNick = nick;
722
723 Presence p( Presence::Available, m_nick.bare() + "/" + m_newNick );
724 m_parent->send( p );
725 }
726 else
727 m_nick.setResource( nick );
728 }
729
731 {
732 if( m_parent )
733 m_parent->disco()->getDiscoInfo( m_nick.bare(), EmptyString, this, GetRoomInfo );
734 }
735
737 {
738 if( m_parent )
739 m_parent->disco()->getDiscoItems( m_nick.bare(), EmptyString, this, GetRoomItems );
740 }
741
742 void MUCRoom::setPresence( Presence::PresenceType presence, const std::string& msg )
743 {
744 if( m_parent && presence != Presence::Unavailable && m_joined )
745 {
746 Presence p( presence, m_nick.full(), msg );
747 m_parent->send( p );
748 }
749 }
750
751 void MUCRoom::invite( const JID& invitee, const std::string& reason, const std::string& thread )
752 {
753 if( !m_parent || !m_joined )
754 return;
755
756 Message msg( Message::Normal, m_nick.bareJID() );
757 msg.addExtension( new MUCUser( OpInviteTo, invitee.bare(), reason, thread ) );
758 m_parent->send( msg );
759 }
760
761 Message* MUCRoom::declineInvitation( const JID& room, const JID& invitor, const std::string& reason )
762 {
763 Message* msg = new Message( Message::Normal, room.bare() );
764 msg->addExtension( new MUCUser( OpDeclineTo, invitor.bare(), reason ) );
765 return msg;
766 }
767
768 void MUCRoom::setPublish( bool publish, bool publishNick )
769 {
770 m_publish = publish;
771 m_publishNick = publishNick;
772
773 if( !m_parent )
774 return;
775
776 if( m_publish )
777 m_parent->disco()->registerNodeHandler( this, XMLNS_MUC_ROOMS );
778 else
779 m_parent->disco()->removeNodeHandler( this, XMLNS_MUC_ROOMS );
780 }
781
782 void MUCRoom::addHistory( const std::string& message, const JID& from, const std::string& stamp )
783 {
784 if( !m_joined || !m_parent )
785 return;
786
787 Message m( Message::Groupchat, m_nick.bareJID(), message );
788 m.addExtension( new DelayedDelivery( from, stamp ) );
789 m_parent->send( m );
790 }
791
793 {
794 m_historyType = type;
795 m_historySince = EmptyString;
796 m_historyValue = value;
797 }
798
799 void MUCRoom::setRequestHistory( const std::string& since )
800 {
801 m_historyType = HistorySince;
802 m_historySince = since;
803 m_historyValue = 0;
804 }
805
806 Message* MUCRoom::createDataForm( const JID& room, const DataForm* df )
807 {
808 Message* m = new Message( Message::Normal, room.bare() );
809 m->addExtension( df );
810 return m;
811 }
812
814 {
815 if( !m_parent || !m_joined )
816 return;
817
818 DataForm* df = new DataForm( TypeSubmit );
820 df->addField( DataFormField::TypeTextSingle, "muc#role", "participant", "Requested role" );
821
822 Message m( Message::Normal, m_nick.bare() );
823 m.addExtension( df );
824
825 m_parent->send( m );
826 }
827
828 void MUCRoom::setRole( const std::string& nick, MUCRoomRole role,
829 const std::string& reason )
830 {
831 if( !m_parent || !m_joined || nick.empty() || role == RoleInvalid )
832 return;
833
835 switch( role )
836 {
837 case RoleNone:
838 action = SetRNone;
839 break;
840 case RoleVisitor:
841 action = SetVisitor;
842 break;
843 case RoleParticipant:
844 action = SetParticipant;
845 break;
846 case RoleModerator:
847 action = SetModerator;
848 break;
849 default:
850 break;
851 }
852
853 IQ iq( IQ::Set, m_nick.bareJID() );
854 iq.addExtension( new MUCAdmin( role, nick, reason ) );
855
856 m_parent->send( iq, this, action );
857 }
858
859 void MUCRoom::setAffiliation( const std::string& nick, MUCRoomAffiliation affiliation,
860 const std::string& reason )
861 {
862 if( !m_parent || !m_joined || nick.empty() || affiliation == AffiliationInvalid )
863 return;
864
866 switch( affiliation )
867 {
869 action = SetOutcast;
870 break;
871 case AffiliationNone:
872 action = SetANone;
873 break;
875 action = SetMember;
876 break;
877 case AffiliationAdmin:
878 action = SetAdmin;
879 break;
880 case AffiliationOwner:
881 action = SetOwner;
882 break;
883 default:
884 break;
885 }
886
887 IQ iq( IQ::Set, m_nick.bareJID() );
888 iq.addExtension( new MUCAdmin( affiliation, nick, reason ) );
889
890 m_parent->send( iq, this, action );
891 }
892
894 {
895 if( !m_parent || !m_joined || !m_roomConfigHandler )
896 return;
897
898 IQ iq( IQ::Get, m_nick.bareJID() );
899 iq.addExtension( new MUCAdmin( operation ) );
900 m_parent->send( iq, this, operation );
901 }
902
903 void MUCRoom::storeList( const MUCListItemList items, MUCOperation operation )
904 {
905 if( !m_parent || !m_joined )
906 return;
907
908 IQ iq( IQ::Set, m_nick.bareJID() );
909 iq.addExtension( new MUCAdmin( operation , items ) );
910 m_parent->send( iq, this, operation );
911 }
912
913 void MUCRoom::handlePresence( const Presence& presence )
914 {
915 if( ( presence.from().bare() != m_nick.bare() ) || !m_roomHandler )
916 return;
917
918 if( presence.subtype() == Presence::Error )
919 {
920 if( m_newNick.empty() )
921 {
922 m_parent->removePresenceHandler( m_nick.bareJID(), this );
923 m_parent->disposeMessageSession( m_session );
924 m_joined = false;
925 m_session = 0;
926 }
927 else
928 m_newNick = "";
929
930 m_roomHandler->handleMUCError( this, presence.error()
931 ? presence.error()->error()
933 }
934 else
935 {
936 const MUCUser* mu = presence.findExtension<MUCUser>( ExtMUCUser );
937 if( !mu )
938 return;
939
940 MUCRoomParticipant party;
941 party.nick = new JID( presence.from() );
942 party.status = presence.status();
943 party.affiliation = mu->affiliation();
944 party.role = mu->role();
945 party.jid = mu->jid() ? new JID( *(mu->jid()) ) : 0;
946 party.actor = mu->actor() ? new JID( *(mu->actor()) ) : 0;
947 party.reason = mu->reason() ? *(mu->reason()) : EmptyString;
948 party.newNick = mu->newNick() ? *(mu->newNick()) : EmptyString;
949 party.alternate = mu->alternate() ? new JID( *(mu->alternate()) ) : 0;
950 party.flags = mu->flags();
951
952 if( party.flags & FlagNonAnonymous )
953 setNonAnonymous();
954
955 if( party.flags & UserSelf )
956 {
957 m_role = party.role;
958 m_affiliation = party.affiliation;
959 }
960 if( party.flags & UserNewRoom )
961 {
962 m_creationInProgress = true;
963 if( instantRoomHook() || m_roomHandler->handleMUCRoomCreation( this ) )
965 }
966 if( party.flags & UserNickAssigned )
967 m_nick.setResource( presence.from().resource() );
968
969 if( party.flags & UserNickChanged && !party.newNick.empty()
970 && m_nick.resource() == presence.from().resource()
971 && party.newNick == m_newNick )
972 party.flags |= UserSelf;
973
974 if( party.flags & UserNickChanged && party.flags & UserSelf && !party.newNick.empty() )
975 m_nick.setResource( party.newNick );
976
977 if( m_roomHandler )
978 m_roomHandler->handleMUCParticipantPresence( this, party, presence );
979
980 delete party.nick;
981 delete party.jid;
982 delete party.actor;
983 delete party.alternate;
984 }
985 }
986
987 void MUCRoom::instantRoom( int context )
988 {
989 if( !m_creationInProgress || !m_parent || !m_joined )
990 return;
991
992 IQ iq( IQ::Set, m_nick.bareJID() );
993 iq.addExtension( new MUCOwner( context == CreateInstantRoom
994 ? MUCOwner::TypeInstantRoom : MUCOwner::TypeCancelConfig ) );
995
996 m_parent->send( iq, this, context );
997
998 m_creationInProgress = false;
999 }
1000
1002 {
1003 if( !m_parent || !m_joined )
1004 return;
1005
1006 IQ iq( IQ::Get, m_nick.bareJID() );
1007 iq.addExtension( new MUCOwner( MUCOwner::TypeRequestConfig ) );
1008
1009 m_parent->send( iq, this, RequestRoomConfig );
1010
1011 if( m_creationInProgress )
1012 m_creationInProgress = false;
1013 }
1014
1016 {
1017 if( !m_parent || !m_joined )
1018 return;
1019
1020 IQ iq( IQ::Set, m_nick.bareJID() );
1021 iq.addExtension( new MUCOwner( MUCOwner::TypeSendConfig, form ) );
1022
1023 m_parent->send( iq, this, SendRoomConfig );
1024 }
1025
1026 void MUCRoom::setNonAnonymous()
1027 {
1028 m_flags |= FlagNonAnonymous;
1029 m_flags &= ~( FlagSemiAnonymous | FlagFullyAnonymous );
1030 }
1031
1032 void MUCRoom::setSemiAnonymous()
1033 {
1034 m_flags &= ~( FlagNonAnonymous | FlagFullyAnonymous );
1035 m_flags |= FlagSemiAnonymous;
1036 }
1037
1038 void MUCRoom::setFullyAnonymous()
1039 {
1040 m_flags &= ~( FlagNonAnonymous | FlagSemiAnonymous );
1041 m_flags |= FlagFullyAnonymous;
1042 }
1043
1044 void MUCRoom::handleMessage( const Message& msg, MessageSession* /*session*/ )
1045 {
1046 if( !m_roomHandler )
1047 return;
1048
1049 if( msg.subtype() == Message::Error )
1050 {
1051 m_roomHandler->handleMUCError( this, msg.error() ? msg.error()->error() : StanzaErrorUndefined );
1052 }
1053 else
1054 {
1055 const MUCUser* mu = msg.findExtension<MUCUser>( ExtMUCUser );
1056 if( mu )
1057 {
1058 const int flags = mu->flags();
1059 if( flags & FlagNonAnonymous )
1060 setNonAnonymous();
1061 if( flags & FlagPublicLogging )
1062 {
1063 m_flags &= ~FlagPublicLoggingOff;
1064 m_flags |= FlagPublicLogging;
1065 }
1067 {
1068 m_flags &= ~FlagPublicLogging;
1069 m_flags |= FlagPublicLoggingOff;
1070 }
1071 if( flags & FlagSemiAnonymous )
1072 setSemiAnonymous();
1074 setFullyAnonymous();
1075
1076 if( mu->operation() == OpDeclineFrom && mu->jid() )
1077 m_roomHandler->handleMUCInviteDecline( this, JID( *(mu->jid()) ),
1078 mu->reason() ? *(mu->reason()) : EmptyString );
1079 }
1080
1081 const DataForm* df = msg.findExtension<DataForm>( ExtDataForm );
1082 if( m_roomConfigHandler && df )
1083 {
1084 m_roomConfigHandler->handleMUCRequest( this, *df );
1085 return;
1086 }
1087
1088 if( !msg.subject().empty() )
1089 {
1090 m_roomHandler->handleMUCSubject( this, msg.from().resource(), msg.subject() );
1091 }
1092 else if( !msg.body().empty() || !msg.extensions().empty() )
1093 {
1094 std::string when;
1095 bool privMsg = false;
1096 if( msg.when() )
1097 when = msg.when()->stamp();
1098
1099 if( msg.subtype() & ( Message::Chat | Message::Normal ) )
1100 privMsg = true;
1101
1102 m_roomHandler->handleMUCMessage( this, msg, privMsg );
1103 }
1104 }
1105 }
1106
1107 void MUCRoom::handleIqID( const IQ& iq, int context )
1108 {
1109 if( !m_roomConfigHandler )
1110 return;
1111
1112 switch( iq.subtype() )
1113 {
1114 case IQ::Result:
1115 handleIqResult( iq, context );
1116 break;
1117 case IQ::Error:
1118 handleIqError( iq, context );
1119 break;
1120 default:
1121 break;
1122 }
1123 }
1124
1125 void MUCRoom::handleIqResult( const IQ& iq, int context )
1126 {
1127 switch( context )
1128 {
1129 case SetRNone:
1130 case SetVisitor:
1131 case SetParticipant:
1132 case SetModerator:
1133 case SetANone:
1134 case SetOutcast:
1135 case SetMember:
1136 case SetAdmin:
1137 case SetOwner:
1138 case CreateInstantRoom:
1139 case CancelRoomCreation:
1140 case SendRoomConfig:
1141 case DestroyRoom:
1142 case StoreVoiceList:
1143 case StoreBanList:
1144 case StoreMemberList:
1145 case StoreModeratorList:
1146 case StoreAdminList:
1147 m_roomConfigHandler->handleMUCConfigResult( this, true, static_cast<MUCOperation>( context ) );
1148 break;
1149 case RequestRoomConfig:
1150 {
1151 const MUCOwner* mo = iq.findExtension<MUCOwner>( ExtMUCOwner );
1152 if( !mo )
1153 break;
1154
1155 if( mo->form() )
1156 m_roomConfigHandler->handleMUCConfigForm( this, *(mo->form()) );
1157 break;
1158 }
1159 case RequestVoiceList:
1160 case RequestBanList:
1161 case RequestMemberList:
1163 case RequestOwnerList:
1164 case RequestAdminList:
1165 {
1166 const MUCAdmin* ma = iq.findExtension<MUCAdmin>( ExtMUCAdmin );
1167 if( !ma )
1168 break;
1169
1170 m_roomConfigHandler->handleMUCConfigList( this, ma->list(), static_cast<MUCOperation>( context ) );
1171 break;
1172 }
1173 default:
1174 break;
1175 }
1176 }
1177
1178 void MUCRoom::handleIqError( const IQ& /*iq*/, int context )
1179 {
1180 switch( context )
1181 {
1182 case SetRNone:
1183 case SetVisitor:
1184 case SetParticipant:
1185 case SetModerator:
1186 case SetANone:
1187 case SetOutcast:
1188 case SetMember:
1189 case SetAdmin:
1190 case SetOwner:
1191 case CreateInstantRoom:
1192 case CancelRoomCreation:
1193 case RequestRoomConfig:
1194 case SendRoomConfig:
1195 case DestroyRoom:
1196 case RequestVoiceList:
1197 case StoreVoiceList:
1198 case RequestBanList:
1199 case StoreBanList:
1200 case RequestMemberList:
1201 case StoreMemberList:
1203 case StoreModeratorList:
1204 case RequestOwnerList:
1205 case StoreOwnerList:
1206 case RequestAdminList:
1207 case StoreAdminList:
1208 m_roomConfigHandler->handleMUCConfigResult( this, false, static_cast<MUCOperation>( context ) );
1209 break;
1210 }
1211 }
1212
1213 void MUCRoom::handleDiscoInfo( const JID& /*from*/, const Disco::Info& info, int context )
1214 {
1215 switch( context )
1216 {
1217 case GetRoomInfo:
1218 {
1219 int oldflags = m_flags;
1220 m_flags = 0;
1221 if( oldflags & FlagPublicLogging )
1222 m_flags |= FlagPublicLogging;
1223
1224 std::string name;
1225 const StringList& l = info.features();
1226 StringList::const_iterator it = l.begin();
1227 for( ; it != l.end(); ++it )
1228 {
1229 if( (*it) == "muc_hidden" )
1230 m_flags |= FlagHidden;
1231 else if( (*it) == "muc_membersonly" )
1232 m_flags |= FlagMembersOnly;
1233 else if( (*it) == "muc_moderated" )
1234 m_flags |= FlagModerated;
1235 else if( (*it) == "muc_nonanonymous" )
1236 setNonAnonymous();
1237 else if( (*it) == "muc_open" )
1238 m_flags |= FlagOpen;
1239 else if( (*it) == "muc_passwordprotected" )
1240 m_flags |= FlagPasswordProtected;
1241 else if( (*it) == "muc_persistent" )
1242 m_flags |= FlagPersistent;
1243 else if( (*it) == "muc_public" )
1244 m_flags |= FlagPublic;
1245 else if( (*it) == "muc_semianonymous" )
1246 setSemiAnonymous();
1247 else if( (*it) == "muc_temporary" )
1248 m_flags |= FlagTemporary;
1249 else if( (*it) == "muc_fullyanonymous" )
1250 setFullyAnonymous();
1251 else if( (*it) == "muc_unmoderated" )
1252 m_flags |= FlagUnmoderated;
1253 else if( (*it) == "muc_unsecured" )
1254 m_flags |= FlagUnsecured;
1255 }
1256
1257 const Disco::IdentityList& il = info.identities();
1258 if( il.size() )
1259 name = il.front()->name();
1260
1261 if( m_roomHandler )
1262 m_roomHandler->handleMUCInfo( this, m_flags, name, info.form() );
1263 break;
1264 }
1265 default:
1266 break;
1267 }
1268 }
1269
1270 void MUCRoom::handleDiscoItems( const JID& /*from*/, const Disco::Items& items, int context )
1271 {
1272 if( !m_roomHandler )
1273 return;
1274
1275 switch( context )
1276 {
1277 case GetRoomItems:
1278 {
1279 m_roomHandler->handleMUCItems( this, items.items() );
1280 break;
1281 }
1282 default:
1283 break;
1284 }
1285 }
1286
1287 void MUCRoom::handleDiscoError( const JID& /*from*/, const Error* /*error*/, int context )
1288 {
1289 if( !m_roomHandler )
1290 return;
1291
1292 switch( context )
1293 {
1294 case GetRoomInfo:
1295 m_roomHandler->handleMUCInfo( this, 0, EmptyString, 0 );
1296 break;
1297 case GetRoomItems:
1298 m_roomHandler->handleMUCItems( this, Disco::ItemList() );
1299 break;
1300 default:
1301 break;
1302 }
1303 }
1304
1305 StringList MUCRoom::handleDiscoNodeFeatures( const JID& /*from*/, const std::string& /*node*/ )
1306 {
1307 return StringList();
1308 }
1309
1311 const std::string& /*node*/ )
1312 {
1313 return Disco::IdentityList();
1314 }
1315
1316 Disco::ItemList MUCRoom::handleDiscoNodeItems( const JID& /*from*/, const JID& /*to*/,
1317 const std::string& node )
1318 {
1320 if( node == XMLNS_MUC_ROOMS && m_publish )
1321 {
1322 l.push_back( new Disco::Item( m_nick.bareJID(), EmptyString,
1323 m_publishNick ? m_nick.resource() : EmptyString ) );
1324 }
1325 return l;
1326 }
1327
1328}
This is the common base class for a Jabber/XMPP Client and a Jabber Component.
Definition clientbase.h:79
const std::string getID()
void registerPresenceHandler(PresenceHandler *ph)
void removeIDHandler(IqHandler *ih)
void send(Tag *tag)
void disposeMessageSession(MessageSession *session)
virtual Disco * disco() const
Definition clientbase.h:233
void registerStanzaExtension(StanzaExtension *ext)
void removePresenceHandler(PresenceHandler *ph)
virtual void addField(DataFormField *field)
An abstraction of a XEP-0004 Data Form.
Definition dataform.h:57
This is an implementation of XEP-0203 (Delayed Delivery).
const std::string & stamp() const
An abstraction of a Disco Info element (from Service Discovery, XEP-0030) as a StanzaExtension.
Definition disco.h:66
const DataForm * form() const
Definition disco.h:99
const IdentityList & identities() const
Definition disco.h:93
const StringList & features() const
Definition disco.h:80
An abstraction of a Disco item (Service Discovery, XEP-0030).
Definition disco.h:353
An abstraction of a Disco query element (from Service Discovery, XEP-0030) in the disco::items namesp...
Definition disco.h:276
const ItemList & items() const
Definition disco.h:311
void removeDiscoHandler(DiscoHandler *dh)
Definition disco.cpp:481
void removeNodeHandler(DiscoNodeHandler *nh, const std::string &node)
Definition disco.cpp:502
void getDiscoInfo(const JID &to, const std::string &node, DiscoHandler *dh, int context, const std::string &tid=EmptyString)
Definition disco.h:451
void registerNodeHandler(DiscoNodeHandler *nh, const std::string &node)
Definition disco.cpp:497
std::list< Identity * > IdentityList
Definition disco.h:56
void getDiscoItems(const JID &to, const std::string &node, DiscoHandler *dh, int context, const std::string &tid=EmptyString)
Definition disco.h:466
std::list< Item * > ItemList
Definition disco.h:266
A stanza error abstraction implemented as a StanzaExtension.
Definition error.h:35
StanzaError error() const
Definition error.h:75
An abstraction of an IQ stanza.
Definition iq.h:34
IqType subtype() const
Definition iq.h:74
@ Set
Definition iq.h:46
@ Error
Definition iq.h:49
@ Result
Definition iq.h:48
@ Get
Definition iq.h:45
An abstraction of a JID.
Definition jid.h:31
const std::string & resource() const
Definition jid.h:116
const std::string & full() const
Definition jid.h:61
bool setResource(const std::string &resource)
Definition jid.cpp:64
JID bareJID() const
Definition jid.h:74
const std::string & bare() const
Definition jid.h:67
This is a MessageSession, adapted to be used in a MUC context.
virtual void send(const std::string &message)
virtual void setSubject(const std::string &subject)
An abstract interface that can be implemented for MUC room configuration.
virtual void handleMUCConfigResult(MUCRoom *room, bool success, MUCOperation operation)=0
virtual void handleMUCConfigList(MUCRoom *room, const MUCListItemList &items, MUCOperation operation)=0
virtual void handleMUCRequest(MUCRoom *room, const DataForm &form)=0
virtual void handleMUCConfigForm(MUCRoom *room, const DataForm &form)=0
This interface enables inheriting classes to be notified about certain events in a MUC room.
virtual void handleMUCParticipantPresence(MUCRoom *room, const MUCRoomParticipant participant, const Presence &presence)=0
virtual void handleMUCInfo(MUCRoom *room, int features, const std::string &name, const DataForm *infoForm)=0
virtual void handleMUCMessage(MUCRoom *room, const Message &msg, bool priv)=0
virtual void handleMUCSubject(MUCRoom *room, const std::string &nick, const std::string &subject)=0
virtual void handleMUCInviteDecline(MUCRoom *room, const JID &invitee, const std::string &reason)=0
virtual void handleMUCError(MUCRoom *room, StanzaError error)=0
virtual void handleMUCItems(MUCRoom *room, const Disco::ItemList &items)=0
virtual bool handleMUCRoomCreation(MUCRoom *room)=0
An abstraction of a MUC user query.
Definition mucroom.h:202
MUCRoomAffiliation affiliation() const
Definition mucroom.h:237
const std::string * alternate() const
Definition mucroom.h:279
MUCUser(MUCUserOperation operation, const std::string &to, const std::string &reason, const std::string &thread=EmptyString)
Definition mucroom.cpp:298
virtual const std::string & filterString() const
Definition mucroom.cpp:450
MUCUserOperation operation() const
Definition mucroom.h:291
MUCRoomRole role() const
Definition mucroom.h:243
virtual Tag * tag() const
Definition mucroom.cpp:457
An abstraction of a MUC query.
Definition mucroom.h:128
virtual const std::string & filterString() const
Definition mucroom.cpp:590
MUC(const std::string &password, HistoryRequestType historyType=HistoryUnknown, const std::string &historySince=EmptyString, int historyValue=0)
Definition mucroom.cpp:543
virtual Tag * tag() const
Definition mucroom.cpp:596
void setPublish(bool publish, bool publishNick)
Definition mucroom.cpp:768
MUCRoomAffiliation affiliation() const
Definition mucroom.h:435
virtual bool instantRoomHook() const
Definition mucroom.h:786
void requestVoice()
Definition mucroom.cpp:813
MUCRoom(ClientBase *parent, const JID &nick, MUCRoomHandler *mrh, MUCRoomConfigHandler *mrch=0)
Definition mucroom.cpp:619
void setPresence(Presence::PresenceType presence, const std::string &msg=EmptyString)
Definition mucroom.cpp:742
virtual void handleIqID(const IQ &iq, int context)
Definition mucroom.cpp:1107
void send(const std::string &message)
Definition mucroom.cpp:699
void requestRoomConfig()
Definition mucroom.cpp:1001
void setRequestHistory(int value, HistoryRequestType type)
Definition mucroom.cpp:792
virtual void handleDiscoInfo(const JID &from, const Disco::Info &info, int context)
Definition mucroom.cpp:1213
void acknowledgeInstantRoom()
Definition mucroom.h:673
void requestList(MUCOperation operation)
Definition mucroom.cpp:893
void setRoomConfig(DataForm *form)
Definition mucroom.cpp:1015
void getRoomItems()
Definition mucroom.cpp:736
virtual void handlePresence(const Presence &presence)
Definition mucroom.cpp:913
void setAffiliation(const std::string &nick, MUCRoomAffiliation affiliation, const std::string &reason)
Definition mucroom.cpp:859
static Message * declineInvitation(const JID &room, const JID &invitor, const std::string &reason=EmptyString)
Definition mucroom.cpp:761
virtual void join(Presence::PresenceType type=Presence::Available, const std::string &status=EmptyString, int priority=0)
Definition mucroom.cpp:655
virtual void handleDiscoError(const JID &from, const Error *error, int context)
Definition mucroom.cpp:1287
virtual ~MUCRoom()
Definition mucroom.cpp:637
virtual Disco::ItemList handleDiscoNodeItems(const JID &from, const JID &to, const std::string &node=EmptyString)
Definition mucroom.cpp:1316
int flags() const
Definition mucroom.h:740
virtual void handleDiscoItems(const JID &from, const Disco::Items &items, int context)
Definition mucroom.cpp:1270
void addHistory(const std::string &message, const JID &from, const std::string &stamp)
Definition mucroom.cpp:782
void destroy(const std::string &reason=EmptyString, const JID &alternate=JID(), const std::string &password=EmptyString)
Definition mucroom.cpp:688
static Message * createDataForm(const JID &room, const DataForm *df)
Definition mucroom.cpp:806
void leave(const std::string &msg=EmptyString)
Definition mucroom.cpp:671
virtual Disco::IdentityList handleDiscoNodeIdentities(const JID &from, const std::string &node)
Definition mucroom.cpp:1310
MUCRoomRole role() const
Definition mucroom.h:441
void setSubject(const std::string &subject)
Definition mucroom.cpp:711
virtual StringList handleDiscoNodeFeatures(const JID &from, const std::string &node)
Definition mucroom.cpp:1305
void getRoomInfo()
Definition mucroom.cpp:730
void setRole(const std::string &nick, MUCRoomRole role, const std::string &reason=EmptyString)
Definition mucroom.cpp:828
void storeList(const MUCListItemList items, MUCOperation operation)
Definition mucroom.cpp:903
void invite(const JID &invitee, const std::string &reason, const std::string &thread=EmptyString)
Definition mucroom.cpp:751
virtual void handleMessage(const Message &msg, MessageSession *session=0)
Definition mucroom.cpp:1044
const std::string name() const
Definition mucroom.h:376
const std::string nick() const
Definition mucroom.h:389
void setNick(const std::string &nick)
Definition mucroom.cpp:717
An abstraction of a message session between any two entities.
void registerMessageHandler(MessageHandler *mh)
An abstraction of a message stanza.
Definition message.h:34
const std::string subject(const std::string &lang="default") const
Definition message.h:101
const std::string body(const std::string &lang="default") const
Definition message.h:87
const DelayedDelivery * when() const
Definition message.h:131
MessageType subtype() const
Definition message.h:76
An abstraction of a presence stanza.
Definition presence.h:33
PresenceType subtype() const
Definition presence.h:76
const std::string status(const std::string &lang="default") const
Definition presence.h:106
This class abstracts a stanza extension, which is usually an XML child element in a specific namespac...
void addExtension(const StanzaExtension *se)
Definition stanza.cpp:52
const Error * error() const
Definition stanza.cpp:47
const StanzaExtensionList & extensions() const
Definition stanza.h:113
const JID & from() const
Definition stanza.h:51
const StanzaExtension * findExtension(int type) const
Definition stanza.cpp:57
This is an abstraction of an XML element.
Definition tag.h:47
Tag * findChild(const std::string &name) const
Definition tag.cpp:624
const std::string & name() const
Definition tag.h:394
const std::string xmlns() const
Definition tag.cpp:543
bool addAttribute(Attribute *attr)
Definition tag.cpp:354
const std::string cdata() const
Definition tag.cpp:497
const std::string & findAttribute(const std::string &name) const
Definition tag.cpp:589
const TagList & children() const
Definition tag.cpp:510
bool setXmlns(const std::string &xmlns, const std::string &prefix=EmptyString)
Definition tag.cpp:522
The namespace for the gloox library.
Definition adhoc.cpp:28
std::list< Tag * > TagList
Definition tag.h:31
const std::string XMLNS_MUC_OWNER
Definition gloox.cpp:72
std::list< const StanzaExtension * > StanzaExtensionList
Definition gloox.h:1272
MUCRoomRole
Definition gloox.h:1164
@ RoleParticipant
Definition gloox.h:1167
@ RoleInvalid
Definition gloox.h:1169
@ RoleModerator
Definition gloox.h:1168
@ RoleVisitor
Definition gloox.h:1166
@ RoleNone
Definition gloox.h:1165
std::list< std::string > StringList
Definition gloox.h:1251
const std::string XMLNS_MUC_REQUEST
Definition gloox.cpp:75
const char * historyTypeValues[]
Definition mucroom.cpp:48
const std::string XMLNS_X_DATA
Definition gloox.cpp:49
@ UserBanned
Definition gloox.h:1204
@ UserNewRoom
Definition gloox.h:1210
@ UserRoomDestroyed
Definition gloox.h:1207
@ UserRoomShutdown
Definition gloox.h:1214
@ UserSelf
Definition gloox.h:1201
@ UserNickChanged
Definition gloox.h:1202
@ UserNickAssigned
Definition gloox.h:1208
@ UserKicked
Definition gloox.h:1203
@ UserAffiliationChangedWNR
Definition gloox.h:1216
@ UserMembershipRequired
Definition gloox.h:1211
@ UserAffiliationChanged
Definition gloox.h:1205
std::list< MUCListItem > MUCListItemList
const std::string EmptyString
Definition gloox.cpp:124
@ StanzaErrorUndefined
Definition gloox.h:952
const std::string XMLNS_MUC_USER
Definition gloox.cpp:68
const std::string XMLNS_MUC_ADMIN
Definition gloox.cpp:69
MUCRoomAffiliation
Definition gloox.h:1151
@ AffiliationInvalid
Definition gloox.h:1157
@ AffiliationOwner
Definition gloox.h:1155
@ AffiliationMember
Definition gloox.h:1154
@ AffiliationNone
Definition gloox.h:1152
@ AffiliationAdmin
Definition gloox.h:1156
@ AffiliationOutcast
Definition gloox.h:1153
@ TypeSubmit
Definition dataform.h:37
@ TypeCancel
Definition dataform.h:39
const std::string XMLNS_MUC_ROOMS
Definition gloox.cpp:74
@ FlagPublicLoggingOff
Definition gloox.h:1179
@ FlagHidden
Definition gloox.h:1180
@ FlagMembersOnly
Definition gloox.h:1181
@ FlagTemporary
Definition gloox.h:1188
@ FlagPersistent
Definition gloox.h:1185
@ FlagModerated
Definition gloox.h:1182
@ FlagOpen
Definition gloox.h:1184
@ FlagPublicLogging
Definition gloox.h:1178
@ FlagNonAnonymous
Definition gloox.h:1183
@ FlagPasswordProtected
Definition gloox.h:1177
@ FlagSemiAnonymous
Definition gloox.h:1187
@ FlagUnmoderated
Definition gloox.h:1189
@ FlagFullyAnonymous
Definition gloox.h:1191
@ FlagUnsecured
Definition gloox.h:1190
@ FlagPublic
Definition gloox.h:1186
const std::string XMLNS_MUC
Definition gloox.cpp:67
MUCRoomAffiliation affiliation