src/ptclib/xmpp.cxx

   1 /*
   2  * xmpp.cxx
   3  *
   4  * Extensible Messaging and Presence Protocol (XMPP) Core
   5  *
   6  * Portable Windows Library
   7  *
   8  * Copyright (c) 2004 Reitek S.p.A.
   9  *
  10  * The contents of this file are subject to the Mozilla Public License
  11  * Version 1.0 (the "License"); you may not use this file except in
  12  * compliance with the License. You may obtain a copy of the License at
  13  * http://www.mozilla.org/MPL/
  14  *
  15  * Software distributed under the License is distributed on an "AS IS"
  16  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17  * the License for the specific language governing rights and limitations
  18  * under the License.
  19  *
  20  * The Original Code is Portable Windows Library.
  21  *
  22  * The Initial Developer of the Original Code is Post Increment
  23  *
  24  * Contributor(s): ______________________________________.
  25  *
  26  * $Log$
  27  * Revision 1.2  2004/04/26 01:51:58  rjongbloed
  28  * More implementation of XMPP, thanks a lot to Federico Pinna & Reitek S.p.A.
  29  *
  30  * Revision 1.1  2004/04/22 12:31:00  rjongbloed
  31  * Added PNotifier extensions and XMPP (Jabber) support,
  32  *   thanks to Federico Pinna and Reitek S.p.A.
  33  *
  34  *
  35  */
  36
  37 #ifdef __GNUC__
  38 #pragma implementation "xmpp.h"
  39 #endif
  40
  41 #include <ptlib.h>
  42 #include <ptclib/xmpp.h>
  43
  44 #if P_EXPAT
  45
  46 ///////////////////////////////////////////////////////
  47
  48 const PString XMPP::Language("xml:lang");
  49 const PString XMPP::Namespace("xmlns");
  50 const PString XMPP::MessageStanza("message");
  51 const PString XMPP::PresenceStanza("presence");
  52 const PString XMPP::IQStanza("iq");
  53 const PString XMPP::IQQuery("query");
  54
  55 ///////////////////////////////////////////////////////
  56
  57 XMPP::JID::JID(const char * jid)
  58 {
  59   ParseJID(jid);
  60 }
  61
  62
  63 XMPP::JID::JID(const PString& jid)
  64 {
  65   ParseJID(jid);
  66 }
  67
  68
  69 XMPP::JID::JID(const PString& user, const PString& server, const PString& resource)
  70   : m_User(user), m_Server(server), m_Resource(resource), m_IsDirty(TRUE)
  71 {
  72   BuildJID();
  73 }
  74
  75
  76 PObject::Comparison XMPP::JID::Compare(const PObject & obj) const
  77 {
  78   if (PIsDescendant(&obj, XMPP::JID))
  79     return m_JID.Compare((const PString&)((const XMPP::JID&)obj));
  80   else if (PIsDescendant(&obj, PString))
  81     return m_JID.Compare((const PString&)obj);
  82
  83   PAssertAlways(PInvalidCast);
  84   return PObject::LessThan;
  85 }
  86
  87
  88 PString& XMPP::JID::operator=(const PString & jid)
  89 {
  90   ParseJID(jid);
  91   return m_JID;
  92 }
  93
  94
  95 XMPP::JID::operator const PString&() const
  96 {
  97   if (m_IsDirty)
  98     BuildJID();
  99
 100   return m_JID;
 101 }
 102
 103
 104 void XMPP::JID::SetUser(const PString& user)
 105 {
 106   m_IsDirty = TRUE;
 107   m_User = user;
 108 }
 109
 110
 111 void XMPP::JID::SetServer(const PString& server)
 112 {
 113   m_IsDirty = TRUE;
 114   m_Server = server;
 115 }
 116
 117
 118 void XMPP::JID::SetResource(const PString& resource)
 119 {
 120   m_IsDirty = TRUE;
 121   m_Resource = resource;
 122 }
 123
 124
 125 void XMPP::JID::ParseJID(const PString& jid)
 126 {
 127   m_User[0] = m_Server[0] = m_Resource[0] = 0;
 128
 129   PINDEX i = jid.Find('@');
 130
 131   if (i == P_MAX_INDEX || i == 0 || i == (jid.GetLength() - 1))
 132     return;
 133
 134   m_User = jid.Left(i);
 135   m_Server = jid.Mid(i + 1);
 136
 137   i = m_Server.Find('/');
 138
 139   if (i == P_MAX_INDEX || i == 0)
 140     return;
 141
 142   m_Resource = m_Server.Mid(i + 1);
 143   m_Server = m_Server.Left(i);
 144   BuildJID();
 145 }
 146
 147
 148 void XMPP::JID::BuildJID() const
 149 {
 150   m_JID = m_User + "@" + m_Server;
 151
 152   if (!m_Resource.IsEmpty())
 153     m_JID += "/" + m_Resource;
 154
 155   m_IsDirty = FALSE;
 156 }
 157
 158 ///////////////////////////////////////////////////////
 159
 160 XMPP::Stream::Stream(XMPP::Transport * transport)
 161   : m_Parser(new PXMLStreamParser)
 162 {
 163   if (transport)
 164     Open(transport);
 165 }
 166
 167
 168 XMPP::Stream::~Stream()
 169 {
 170   delete m_Parser;
 171   Close();
 172 }
 173
 174
 175 BOOL XMPP::Stream::Close()
 176 {
 177   if (IsOpen()) {
 178     OnClose();
 179     return PIndirectChannel::Close();
 180   }
 181
 182   return FALSE;
 183 }
 184
 185
 186 BOOL XMPP::Stream::Write(const void * buf, PINDEX len)
 187 {
 188   PTRACE(5, "XMPP\tSND: " << (const char *)buf);
 189   return PIndirectChannel::Write(buf, len);
 190 }
 191
 192
 193 BOOL XMPP::Stream::Write(const PString& data)
 194 {
 195   return Write((const char *)data, data.GetLength());
 196 }
 197
 198
 199 BOOL XMPP::Stream::Write(const PXML& pdu)
 200 {
 201   PXMLElement * root = pdu.GetRootElement();
 202
 203   if (root == NULL)
 204     return FALSE;
 205
 206   PStringStream os;
 207   root->Output(os, pdu, 0);
 208   return Write(os.GetPointer(), os.GetLength());
 209 }
 210
 211
 212 PXML * XMPP::Stream::Read()
 213 {
 214   return m_Parser->Read(this);
 215 }
 216
 217
 218 void XMPP::Stream::Reset()
 219 {
 220   delete m_Parser;
 221   m_Parser = new PXMLStreamParser;
 222 }
 223
 224 ///////////////////////////////////////////////////////
 225
 226 XMPP::BaseStreamHandler::BaseStreamHandler()
 227   : PThread(0x1000),
 228     m_Stream(NULL),
 229     m_AutoReconnect(TRUE),
 230     m_ReconnectTimeout(1000)
 231 {
 232 }
 233
 234
 235 XMPP::BaseStreamHandler::~BaseStreamHandler()
 236 {
 237   Stop();
 238 }
 239
 240
 241 BOOL XMPP::BaseStreamHandler::Start(XMPP::Transport * transport)
 242 {
 243   if (m_Stream != NULL)
 244     Stop();
 245
 246   m_Stream = new XMPP::Stream();
 247   m_Stream->OpenHandlers().Add(new PCREATE_NOTIFIER(OnOpen));
 248   m_Stream->CloseHandlers().Add(new PCREATE_NOTIFIER(OnClose));
 249
 250   if (!transport->IsOpen() && !transport->Open())
 251     return FALSE;
 252
 253   if (m_Stream->Open(transport))
 254   {
 255     if (IsSuspended())
 256       Resume();
 257     else
 258       Restart();
 259     return TRUE;
 260   }
 261
 262   return FALSE;
 263 }
 264
 265
 266 BOOL XMPP::BaseStreamHandler::Stop(const PString& _error)
 267 {
 268   if (m_Stream == NULL)
 269     return FALSE;
 270
 271   if (!_error.IsEmpty())
 272   {
 273     PString error = "<stream:error><";
 274     error += _error;
 275     error += " xmlns='urn:ietf:params:xml:ns:xmpp-streams'/></stream:error>";
 276     m_Stream->Write((const char *)error, error.GetLength());
 277   }
 278
 279   m_Stream->Close();
 280
 281   if (PThread::Current() != this)
 282     WaitForTermination(10000);
 283
 284   return FALSE;
 285 }
 286
 287
 288 void XMPP::BaseStreamHandler::OnOpen(XMPP::Stream&, INT)
 289 {
 290 }
 291
 292
 293 void XMPP::BaseStreamHandler::OnClose(XMPP::Stream&, INT)
 294 {
 295 }
 296
 297
 298 void XMPP::BaseStreamHandler::SetAutoReconnect(BOOL b, long t)
 299 {
 300   m_AutoReconnect = b;
 301   m_ReconnectTimeout = t;
 302 }
 303
 304
 305 BOOL XMPP::BaseStreamHandler::Write(const void * buf, PINDEX len)
 306 {
 307   if (m_Stream == NULL)
 308     return FALSE;
 309
 310   return m_Stream->Write(buf, len);
 311 }
 312
 313
 314 BOOL XMPP::BaseStreamHandler::Write(const PString& data)
 315 {
 316   if (m_Stream == NULL)
 317     return FALSE;
 318
 319   return m_Stream->Write(data);
 320 }
 321
 322
 323 BOOL XMPP::BaseStreamHandler::Write(const PXML& pdu)
 324 {
 325   if (m_Stream == NULL)
 326     return FALSE;
 327
 328   return m_Stream->Write(pdu);
 329 }
 330
 331
 332 void XMPP::BaseStreamHandler::OnElement(PXML& pdu)
 333 {
 334   m_ElementHandlers.Fire(pdu);
 335 }
 336
 337
 338 void XMPP::BaseStreamHandler::Main()
 339 {
 340   PXML * pdu;
 341
 342   for (;;)
 343   {
 344     if (!m_Stream || !m_Stream->IsOpen())
 345       break;
 346
 347     pdu = m_Stream->Read();
 348
 349     if (pdu != NULL)
 350     {
 351       if (PTrace::CanTrace(5)) {
 352         ostream& os = PTrace::Begin(5, __FILE__, __LINE__);
 353         pdu->GetRootElement()->Output(os, *pdu, 0);
 354         os << PTrace::End;
 355       }
 356
 357       OnElement(*pdu);
 358     }
 359
 360     delete pdu;
 361   }
 362
 363   delete m_Stream;
 364   m_Stream = NULL;
 365 }
 366
 367 ///////////////////////////////////////////////////////
 368
 369 const PString XMPP::Stanza::ID("id");
 370 const PString XMPP::Stanza::From("from");
 371 const PString XMPP::Stanza::To("to");
 372
 373 void XMPP::Stanza::SetID(const PString& id)
 374 {
 375   if (!id.IsEmpty())
 376     PAssertNULL(rootElement)->SetAttribute(XMPP::Stanza::ID, id);
 377 }
 378
 379 void XMPP::Stanza::SetFrom(const PString& from)
 380 {
 381   if (!from.IsEmpty())
 382     PAssertNULL(rootElement)->SetAttribute(XMPP::Stanza::From, from);
 383 }
 384
 385 void XMPP::Stanza::SetTo(const PString& to)
 386 {
 387   if (!to.IsEmpty())
 388     PAssertNULL(rootElement)->SetAttribute(XMPP::Stanza::To, to);
 389 }
 390
 391 PString XMPP::Stanza::GetID() const
 392 { return PAssertNULL(rootElement)->GetAttribute(XMPP::Stanza::ID); }
 393
 394 PString XMPP::Stanza::GetFrom() const
 395 { return PAssertNULL(rootElement)->GetAttribute(XMPP::Stanza::From); }
 396
 397 PString XMPP::Stanza::GetTo() const
 398 { return PAssertNULL(rootElement)->GetAttribute(XMPP::Stanza::To); }
 399
 400 ///////////////////////////////////////////////////////
 401
 402 const PString XMPP::Message::Type("type");
 403 const PString XMPP::Message::Subject("subject");
 404 const PString XMPP::Message::Body("body");
 405 const PString XMPP::Message::Thread("thread");
 406
 407 XMPP::Message::Message()
 408 {
 409   SetRootElement(new PXMLElement(NULL, XMPP::MessageStanza));
 410   PWaitAndSignal m(rootMutex);
 411   rootElement->SetAttribute(XMPP::Message::Type, "normal");
 412 }
 413
 414
 415 XMPP::Message::Message(PXML& pdu)
 416 {
 417   if (XMPP::Message::IsValid(&pdu)) {
 418     PWaitAndSignal m(pdu.GetMutex());
 419     PXMLElement * elem = pdu.GetRootElement();
 420     if (elem != NULL)
 421       SetRootElement((PXMLElement *)elem->Clone(0));
 422   }
 423 }
 424
 425
 426 XMPP::Message::Message(PXML * pdu)
 427 {
 428   if (XMPP::Message::IsValid(pdu)) {
 429     PWaitAndSignal m(PAssertNULL(pdu)->GetMutex());
 430     PXMLElement * elem = pdu->GetRootElement();
 431
 432     if (elem != NULL)
 433       SetRootElement((PXMLElement *)elem->Clone(0));
 434   }
 435 }
 436
 437
 438 BOOL XMPP::Message::IsValid() const
 439 {
 440   return XMPP::Message::IsValid(this);
 441 }
 442
 443
 444 BOOL XMPP::Message::IsValid(const PXML * pdu)
 445 {
 446   PXMLElement * elem = PAssertNULL(pdu)->GetRootElement();
 447   return elem != NULL && elem->GetName() == XMPP::MessageStanza;
 448 }
 449
 450
 451 XMPP::Message::MessageType XMPP::Message::GetType(PString * typeName) const
 452 {
 453   PString t = PAssertNULL(rootElement)->GetAttribute(XMPP::Message::Type);
 454
 455   if (typeName != NULL)
 456     *typeName = t;
 457
 458   if (t *= "normal")
 459     return XMPP::Message::Normal;
 460   else if (t *= "chat")
 461     return XMPP::Message::Chat;
 462   else if (t *= "error")
 463     return XMPP::Message::Error;
 464   else if (t *= "groupchat")
 465     return XMPP::Message::GroupChat;
 466   else if (t *= "headline")
 467     return XMPP::Message::HeadLine;
 468   else
 469     return XMPP::Message::Unknown;
 470 }
 471
 472
 473 PString XMPP::Message::GetLanguage() const
 474 {
 475   return PAssertNULL(rootElement)->GetAttribute(XMPP::Language);
 476 }
 477
 478
 479 PXMLElement * XMPP::Message::GetSubjectElement(const PString& lang)
 480 {
 481   PAssertNULL(rootElement);
 482
 483   PXMLElement * dfltSubj = NULL;
 484   PINDEX i = 0;
 485   PXMLElement * subj;
 486   PString l;
 487
 488   while ((subj = rootElement->GetElement(XMPP::Message::Subject, i)) != NULL) {
 489     i = rootElement->FindObject(subj) + 1;
 490     l = subj->GetAttribute(XMPP::Language);
 491
 492     if (l == lang)
 493       return subj;
 494     else if (l.IsEmpty() && dfltSubj == NULL)
 495       dfltSubj = subj;
 496   }
 497
 498   return dfltSubj;
 499 }
 500
 501
 502 PString XMPP::Message::GetSubject(const PString& lang)
 503 {
 504   PXMLElement * elem = GetSubjectElement(lang);
 505   return elem != NULL ? elem->GetData() : PString::Empty();
 506 }
 507
 508
 509 PXMLElement * XMPP::Message::GetBodyElement(const PString& lang)
 510 {
 511   PAssertNULL(rootElement);
 512
 513   PXMLElement * dfltBody = NULL;
 514   PINDEX i = 0;
 515   PXMLElement * body;
 516   PString l;
 517
 518   while ((body = rootElement->GetElement(XMPP::Message::Body, i)) != NULL) {
 519     i = rootElement->FindObject(body) + 1;
 520     l = body->GetAttribute(XMPP::Language);
 521
 522     if (l == lang)
 523       return body;
 524     else if (l.IsEmpty() && dfltBody == NULL)
 525       dfltBody = body;
 526   }
 527
 528   return dfltBody;
 529 }
 530
 531
 532 PString XMPP::Message::GetBody(const PString& lang)
 533 {
 534   PXMLElement * elem = GetBodyElement(lang);
 535   return elem != NULL ? elem->GetData() : PString::Empty();
 536 }
 537
 538
 539 PString XMPP::Message::GetThread()
 540 {
 541   PXMLElement * elem = PAssertNULL(rootElement)->GetElement(XMPP::Message::Thread);
 542   return elem != NULL ? elem->GetData() : PString::Empty();
 543 }
 544
 545
 546 void XMPP::Message::SetType(MessageType type)
 547 {
 548   switch (type) {
 549   case XMPP::Message::Normal:
 550     SetType("normal");
 551     break;
 552   case XMPP::Message::Chat:
 553     SetType("chat");
 554     break;
 555   case XMPP::Message::Error:
 556     SetType("error");
 557     break;
 558   case XMPP::Message::GroupChat:
 559     SetType("groupchat");
 560     break;
 561   case XMPP::Message::HeadLine:
 562     SetType("headline");
 563     break;
 564   }
 565 }
 566
 567
 568 void XMPP::Message::SetType(const PString& type)
 569 {
 570   PAssertNULL(rootElement)->SetAttribute(XMPP::Message::Type, type);
 571 }
 572
 573
 574 void XMPP::Message::SetLanguage(const PString& lang)
 575 {
 576   PAssertNULL(rootElement)->SetAttribute(XMPP::Language, lang);
 577 }
 578
 579
 580 void XMPP::Message::SetSubject(const PString& subj, const PString& lang)
 581 {
 582   PXMLElement * elem = GetSubjectElement(lang);
 583
 584   if (elem == NULL) {
 585     elem = PAssertNULL(rootElement)->AddChild(new PXMLElement(rootElement, XMPP::Message::Subject));
 586
 587     if (!lang.IsEmpty())
 588       elem->SetAttribute(XMPP::Language, lang);
 589   }
 590   elem->AddChild(new PXMLData(elem, subj));
 591 }
 592
 593
 594 void XMPP::Message::SetBody(const PString& body, const PString& lang)
 595 {
 596   PXMLElement * elem = GetBodyElement(lang);
 597
 598   if (elem == NULL) {
 599     elem = PAssertNULL(rootElement)->AddChild(new PXMLElement(rootElement, XMPP::Message::Body));
 600
 601     if (!lang.IsEmpty())
 602       elem->SetAttribute(XMPP::Language, lang);
 603   }
 604
 605   elem->AddChild(new PXMLData(elem, body));
 606 }
 607
 608
 609 void XMPP::Message::SetThread(const PString& thrd)
 610 {
 611   PXMLElement * elem = PAssertNULL(rootElement)->GetElement(XMPP::Message::Thread);
 612
 613   if (elem == NULL)
 614     elem = PAssertNULL(rootElement)->AddChild(new PXMLElement(rootElement, XMPP::Message::Thread));
 615
 616   elem->AddChild(new PXMLData(elem, thrd));
 617 }
 618
 619 ///////////////////////////////////////////////////////
 620
 621 const PString XMPP::Presence::Type("type");
 622 const PString XMPP::Presence::Show("show");
 623 const PString XMPP::Presence::Status("status");
 624 const PString XMPP::Presence::Priority("priority");
 625
 626 XMPP::Presence::Presence()
 627 {
 628   SetRootElement(new PXMLElement(0, XMPP::PresenceStanza));
 629 }
 630
 631
 632 XMPP::Presence::Presence(PXML& pdu)
 633 {
 634   if (XMPP::Presence::IsValid(&pdu)) {
 635     PWaitAndSignal m(pdu.GetMutex());
 636     PXMLElement * elem = pdu.GetRootElement();
 637     if (elem != NULL)
 638       SetRootElement((PXMLElement *)elem->Clone(0));
 639   }
 640 }
 641
 642
 643 XMPP::Presence::Presence(PXML * pdu)
 644 {
 645   if (XMPP::Presence::IsValid(pdu)) {
 646     PWaitAndSignal m(PAssertNULL(pdu)->GetMutex());
 647     PXMLElement * elem = pdu->GetRootElement();
 648     if (elem != NULL)
 649       SetRootElement((PXMLElement *)elem->Clone(0));
 650   }
 651 }
 652
 653
 654 BOOL XMPP::Presence::IsValid() const
 655 {
 656   return XMPP::Presence::IsValid(this);
 657 }
 658
 659
 660 BOOL XMPP::Presence::IsValid(const PXML * pdu)
 661 {
 662   PXMLElement * elem = PAssertNULL(pdu)->GetRootElement();
 663   return elem != NULL && elem->GetName() == XMPP::PresenceStanza;
 664 }
 665
 666
 667 XMPP::Presence::PresenceType XMPP::Presence::GetType(PString * typeName) const
 668 {
 669   PString t = PAssertNULL(rootElement)->GetAttribute(XMPP::Presence::Type);
 670
 671   if (typeName != NULL)
 672     *typeName = t;
 673
 674   if (t.IsEmpty())
 675     return XMPP::Presence::Available;
 676   else if (t *= "unavailable")
 677     return XMPP::Presence::Unavailable;
 678   else if (t *= "subscribe")
 679     return XMPP::Presence::Subscribe;
 680   else if (t *= "subscribed")
 681     return XMPP::Presence::Subscribed;
 682   else if (t *= "unsubscribe")
 683     return XMPP::Presence::Unsubscribe;
 684   else if (t *= "unsubscribed")
 685     return XMPP::Presence::Unsubscribed;
 686   else if (t *= "probe")
 687     return XMPP::Presence::Probe;
 688   else if (t *= "error")
 689     return XMPP::Presence::Error;
 690   else
 691     return XMPP::Presence::Unknown;
 692 }
 693
 694
 695 XMPP::Presence::ShowType XMPP::Presence::GetShow(PString * showName) const
 696 {
 697   PXMLElement * elem = PAssertNULL(rootElement)->GetElement(XMPP::Presence::Show);
 698
 699   if (elem == NULL)
 700     return XMPP::Presence::Online;
 701
 702   PString s = elem->GetData();
 703
 704   if (showName != NULL)
 705     *showName = s;
 706
 707   if (s.IsEmpty())
 708     return XMPP::Presence::Online;
 709   else if (s *= "away")
 710     return XMPP::Presence::Away;
 711   else if (s *= "chat")
 712     return XMPP::Presence::Chat;
 713   else if (s *= "dnd")
 714     return XMPP::Presence::DND;
 715   else if (s *= "xa")
 716     return XMPP::Presence::XA;
 717   else
 718     return XMPP::Presence::Other;
 719 }
 720
 721
 722 BYTE XMPP::Presence::GetPriority() const
 723 {
 724   PXMLElement * elem = PAssertNULL(rootElement)->GetElement(XMPP::Presence::Priority);
 725   return elem == NULL ? (BYTE)0 : (BYTE)elem->GetData().AsInteger();
 726 }
 727
 728
 729 PXMLElement * XMPP::Presence::GetStatusElement(const PString& lang)
 730 {
 731   PAssertNULL(rootElement);
 732
 733   PXMLElement * dfltStatus = NULL;
 734   PINDEX i = 0;
 735   PXMLElement * status;
 736   PString l;
 737
 738   while ((status = rootElement->GetElement(XMPP::Presence::Status, i)) != NULL) {
 739     i = rootElement->FindObject(status) + 1;
 740     l = status->GetAttribute(XMPP::Language);
 741
 742     if (l == lang)
 743       return status;
 744     else if (l.IsEmpty() && dfltStatus == NULL)
 745       dfltStatus = status;
 746   }
 747
 748   return dfltStatus;
 749 }
 750
 751
 752 PString XMPP::Presence::GetStatus(const PString& lang)
 753 {
 754   PXMLElement * elem = GetStatusElement(lang);
 755   return elem != NULL ? elem->GetData() : PString::Empty();
 756 }
 757
 758
 759 void XMPP::Presence::SetType(PresenceType type)
 760 {
 761   switch (type) {
 762   case XMPP::Presence::Available:
 763     PAssertNULL(rootElement)->SetAttribute(XMPP::Presence::Type, PString::Empty());
 764     break;
 765   case XMPP::Presence::Unavailable:
 766     SetType("unavailable");
 767     break;
 768   case XMPP::Presence::Subscribe:
 769     SetType("subscribe");
 770     break;
 771   case XMPP::Presence::Subscribed:
 772     SetType("subscribed");
 773     break;
 774   case XMPP::Presence::Unsubscribe:
 775     SetType("unsubscribe");
 776     break;
 777   case XMPP::Presence::Unsubscribed:
 778     SetType("unsubscribed");
 779     break;
 780   case XMPP::Presence::Probe:
 781     SetType("probe");
 782     break;
 783   case XMPP::Presence::Error:
 784     SetType("error");
 785     break;
 786   }
 787 }
 788
 789
 790 void XMPP::Presence::SetType(const PString& type)
 791 {
 792   PAssertNULL(rootElement)->SetAttribute(XMPP::Presence::Type, type);
 793 }
 794
 795
 796 void XMPP::Presence::SetShow(ShowType show)
 797 {
 798   switch (show) {
 799   case XMPP::Presence::Online:
 800     {
 801       PXMLElement * elem = PAssertNULL(rootElement)->GetElement(XMPP::Presence::Show);
 802       if (elem)
 803         rootElement->RemoveElement(rootElement->FindObject(elem));
 804     }
 805     break;
 806   case XMPP::Presence::Away:
 807     SetType("away");
 808     break;
 809   case XMPP::Presence::Chat:
 810     SetType("chat");
 811     break;
 812   case XMPP::Presence::DND:
 813     SetType("dnd");
 814     break;
 815   case XMPP::Presence::XA:
 816     SetType("xa");
 817     break;
 818   }
 819 }
 820
 821
 822 void XMPP::Presence::SetShow(const PString& show)
 823 {
 824   PXMLElement * elem = PAssertNULL(rootElement)->GetElement(XMPP::Presence::Show);
 825
 826   if (elem == NULL)
 827     elem = PAssertNULL(rootElement)->AddChild(new PXMLElement(rootElement, XMPP::Presence::Show));
 828
 829   elem->AddChild(new PXMLData(elem, show));
 830 }
 831
 832
 833 void XMPP::Presence::SetPriority(BYTE priority)
 834 {
 835   PXMLElement * elem = PAssertNULL(rootElement)->GetElement(XMPP::Presence::Priority);
 836
 837   if (elem == NULL)
 838     elem = PAssertNULL(rootElement)->AddChild(new PXMLElement(rootElement, XMPP::Presence::Priority));
 839
 840   elem->AddChild(new PXMLData(elem, PString((PINDEX)priority)));
 841 }
 842
 843
 844 void XMPP::Presence::SetStatus(const PString& status, const PString& lang)
 845 {
 846   PXMLElement * elem = GetStatusElement(lang);
 847
 848   if (elem == NULL) {
 849     elem = PAssertNULL(rootElement)->AddChild(new PXMLElement(rootElement, XMPP::Presence::Status));
 850
 851     if (!lang.IsEmpty())
 852       elem->SetAttribute(XMPP::Language, lang);
 853   }
 854   elem->AddChild(new PXMLData(elem, status));
 855 }
 856
 857 ///////////////////////////////////////////////////////
 858
 859 const PString XMPP::IQ::Type("type");
 860
 861
 862 XMPP::IQ::IQ(XMPP::IQ::IQType type, PXMLElement * body)
 863   : m_Processed(FALSE),
 864     m_OriginalIQ(NULL)
 865 {
 866   SetRootElement(new PXMLElement(NULL, XMPP::IQStanza));
 867   SetType(type);
 868   SetID(GenerateID());
 869   SetBody(body);
 870   rootElement->SetAttribute(XMPP::Namespace, "jabber:client");
 871 }
 872
 873
 874 XMPP::IQ::IQ(PXML& pdu)
 875   : m_Processed(FALSE),
 876     m_OriginalIQ(NULL)
 877 {
 878   if (XMPP::IQ::IsValid(&pdu)) {
 879     PWaitAndSignal m(pdu.GetMutex());
 880     PXMLElement * elem = pdu.GetRootElement();
 881     if (elem != NULL)
 882       SetRootElement((PXMLElement *)elem->Clone(0));
 883   }
 884 }
 885
 886
 887 XMPP::IQ::IQ(PXML * pdu)
 888   : m_Processed(FALSE),
 889     m_OriginalIQ(NULL)
 890 {
 891   if (XMPP::IQ::IsValid(pdu)) {
 892     PWaitAndSignal m(PAssertNULL(pdu)->GetMutex());
 893     PXMLElement * elem = pdu->GetRootElement();
 894     if (elem != NULL)
 895       SetRootElement((PXMLElement *)elem->Clone(0));
 896   }
 897 }
 898
 899
 900 XMPP::IQ::~IQ()
 901 {
 902   delete m_OriginalIQ;
 903 }
 904
 905
 906 BOOL XMPP::IQ::IsValid() const
 907 {
 908   return XMPP::IQ::IsValid(this);
 909 }
 910
 911
 912 BOOL XMPP::IQ::IsValid(const PXML * pdu)
 913 {
 914   PXMLElement * elem = PAssertNULL(pdu)->GetRootElement();
 915
 916   if (elem == NULL || elem->GetName() != XMPP::IQStanza)
 917     return FALSE;
 918
 919   PString s = elem->GetAttribute(XMPP::IQ::Type);
 920
 921   if (s.IsEmpty() || (s != "get" && s != "set" && s != "result" && s != "error"))
 922     return FALSE;
 923
 924   /* Appartently when a server sends a set to us there's no id...
 925   s = elem->GetAttribute(XMPP::IQ::ID);
 926   return !s.IsEmpty();
 927   */
 928   return TRUE;
 929 }
 930
 931
 932 XMPP::IQ::IQType XMPP::IQ::GetType(PString * typeName) const
 933 {
 934   PString t = PAssertNULL(rootElement)->GetAttribute(XMPP::IQ::Type);
 935
 936   if (typeName != NULL)
 937     *typeName = t;
 938
 939   if (t *= "get")
 940     return XMPP::IQ::Get;
 941   else if (t *= "set")
 942     return XMPP::IQ::Set;
 943   else if (t *= "result")
 944     return XMPP::IQ::Result;
 945   else if (t *= "error")
 946     return XMPP::IQ::Error;
 947   else
 948     return XMPP::IQ::Unknown;
 949 }
 950
 951
 952 PXMLElement * XMPP::IQ::GetBody()
 953 {
 954   PXMLObject * elem = PAssertNULL(rootElement)->GetElement(0);
 955   return PIsDescendant(elem, PXMLElement) ? (PXMLElement *)elem : NULL;
 956 }
 957
 958
 959 void XMPP::IQ::SetType(XMPP::IQ::IQType type)
 960 {
 961   switch (type) {
 962   case XMPP::IQ::Get:
 963     SetType("get");
 964     break;
 965   case XMPP::IQ::Set:
 966     SetType("set");
 967     break;
 968   case XMPP::IQ::Result:
 969     SetType("result");
 970     break;
 971   case XMPP::IQ::Error:
 972     SetType("error");
 973     break;
 974   }
 975 }
 976
 977
 978 void XMPP::IQ::SetType(const PString& type)
 979 {
 980   PAssertNULL(rootElement)->SetAttribute(XMPP::IQ::Type, type);
 981 }
 982
 983
 984 void XMPP::IQ::SetBody(PXMLElement * body)
 985 {
 986   PAssertNULL(rootElement);
 987
 988   while(rootElement->HasSubObjects())
 989     rootElement->RemoveElement(0);
 990
 991   if (body != NULL) {
 992     body->SetParent(rootElement);
 993     rootElement->AddChild(body);
 994   }
 995 }
 996
 997
 998 void XMPP::IQ::SetOriginalMessage(IQ * iq)
 999 {
1000   delete m_OriginalIQ;
1001   m_OriginalIQ = iq;
1002 }
1003
1004
1005 XMPP::IQ * XMPP::IQ::BuildResult() const
1006 {
1007   IQType iq_type = GetType();
1008
1009   if (iq_type != XMPP::IQ::Get && iq_type != XMPP::IQ::Set)
1010     return NULL;
1011
1012   IQ * result = new IQ(XMPP::IQ::Result);
1013   result->SetID(GetID());
1014   result->SetTo(GetFrom());
1015   return result;
1016 }
1017
1018
1019 XMPP::IQ * XMPP::IQ::BuildError(const PString& type, const PString& code) const
1020 {
1021   IQType iq_type = GetType();
1022
1023   if (iq_type != XMPP::IQ::Get && iq_type != XMPP::IQ::Set)
1024     return NULL;
1025
1026   IQ * error = new IQ(XMPP::IQ::Error);
1027   error->SetID(GetID());
1028   error->SetTo(GetFrom());
1029
1030   PXMLElement * body = error->GetRootElement()->AddChild(new PXMLElement(error->GetRootElement(), "error"));
1031   body->SetAttribute("type", type);
1032   PXMLElement * codeElem = body->AddChild(new PXMLElement(body, code));
1033   codeElem->SetAttribute(XMPP::Namespace, "urn:ietf:params:xml:ns:xmpp-stanzas");
1034
1035   const PXMLElement * originalBody = (PXMLElement *)rootElement->GetElement(0);
1036   if (originalBody != NULL)
1037     error->GetRootElement()->AddChild((PXMLElement *)originalBody->Clone(error->GetRootElement()));
1038
1039   return error;
1040 }
1041
1042
1043 PString XMPP::IQ::GenerateID()
1044 {
1045   static PAtomicInteger s_id;
1046
1047   return PString(PString::Printf, "iq%d", (int)++s_id);
1048 }
1049
1050
1051 #endif // P_EXPAT
1052
1053 // End of File ///////////////////////////////////////////////////////////////
1054
1055