src/pedro/pedroxmpp.h

   1 #ifndef __XMPP_H__
   2 #define __XMPP_H__
   3 /*
   4  * API for the Pedro mini-XMPP client.
   5  *
   6  * Authors:
   7  *   Bob Jamison
   8  *
   9  * Copyright (C) 2005-2007 Bob Jamison
  10  *
  11  *  This library is free software; you can redistribute it and/or
  12  *  modify it under the terms of the GNU Lesser General Public
  13  *  License as published by the Free Software Foundation; either
  14  *  version 2.1 of the License, or (at your option) any later version.
  15  *
  16  *  This library is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  *  Lesser General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU Lesser General Public
  22  *  License along with this library; if not, write to the Free Software
  23  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  24  */
  25
  26 #include <stdio.h>
  27 #include <glib.h>
  28 #include <vector>
  29 #include <map>
  30
  31 #include <string>
  32
  33 #include "pedrodom.h"
  34
  35 namespace Pedro
  36 {
  37
  38 typedef std::string DOMString;
  39
  40
  41 //########################################################################
  42 //# X M P P    E V E N T
  43 //########################################################################
  44 class XmppUser
  45 {
  46 public:
  47     XmppUser()
  48         {
  49         }
  50     XmppUser(const DOMString &jidArg, const DOMString &nickArg)
  51         {
  52         jid  = jidArg;
  53         nick = nickArg;
  54         }
  55     XmppUser(const DOMString &jidArg,          const DOMString &nickArg,
  56              const DOMString &subscriptionArg, const DOMString &groupArg)
  57         {
  58         jid          = jidArg;
  59         nick         = nickArg;
  60         subscription = subscriptionArg;
  61         group        = groupArg;
  62         }
  63     XmppUser(const XmppUser &other)
  64         {
  65         jid          = other.jid;
  66         nick         = other.nick;
  67         subscription = other.subscription;
  68         group        = other.group;
  69         show         = other.show;
  70         }
  71     XmppUser &operator=(const XmppUser &other)
  72         {
  73         jid          = other.jid;
  74         nick         = other.nick;
  75         subscription = other.subscription;
  76         group        = other.group;
  77         show         = other.show;
  78         return *this;
  79         }
  80     virtual ~XmppUser()
  81         {}
  82     DOMString jid;
  83     DOMString nick;
  84     DOMString subscription;
  85     DOMString group;
  86     DOMString show;
  87 };
  88
  89
  90
  91
  92
  93 /**
  94  * Class that emits information from a client
  95  */
  96 class XmppEvent
  97 {
  98
  99 public:
 100
 101     /**
 102      * People might want to refer to these docs to understand
 103      * the XMPP terminology used here.
 104      * http://www.ietf.org/rfc/rfc3920.txt      -- Xmpp Core
 105      * http://www.ietf.org/rfc/rfc3921.txt      -- Messaging and presence
 106      * http://www.jabber.org/jeps/jep-0077.html -- In-Band registration
 107      * http://www.jabber.org/jeps/jep-0045.html -- Multiuser Chat
 108      * http://www.jabber.org/jeps/jep-0047.html -- In-Band byte streams
 109      * http://www.jabber.org/jeps/jep-0096.html -- File transfer
 110      */
 111
 112     /**
 113      *  No event type.  Default
 114      */
 115     static const int EVENT_NONE                 =  0;
 116
 117     /**
 118      *  Client emits a status message.  Message is in getData().
 119      */
 120     static const int EVENT_STATUS               =  1;
 121
 122     /**
 123      *  Client emits an error message.  Message is in getData().
 124      */
 125     static const int EVENT_ERROR                =  2;
 126
 127     /**
 128      *  Client has connected to a host.  Host name is in getData().
 129      */
 130     static const int EVENT_CONNECTED            = 10;
 131
 132     /**
 133      *  Client has disconnected from a host.  Host name is in getData().
 134      */
 135     static const int EVENT_DISCONNECTED         = 11;
 136
 137     /**
 138      *  Client has begun speaking to the server in SSL.  This is usually
 139      *  emitted just before EVENT_CONNECTED,  since authorization has not
 140      *  yet taken place.
 141      */
 142     static const int EVENT_SSL_STARTED          = 12;
 143
 144     /**
 145      *  Client has successfully registered a new account on a server.
 146      *  The server is in getFrom(), the user in getTo()
 147      */
 148     static const int EVENT_REGISTRATION_NEW     = 20;
 149
 150     /**
 151      *  Client has successfully changed the password of an existing account on a server.
 152      *  The server is in getFrom(), the user in getTo()
 153      */
 154     static const int EVENT_REGISTRATION_CHANGE_PASS  = 21;
 155
 156     /**
 157      *  Client has successfully cancelled an existing account on a server.
 158      *  The server is in getFrom(), the user in getTo()
 159      */
 160     static const int EVENT_REGISTRATION_CANCEL  = 22;
 161
 162     /**
 163      *  A <presence> packet has been received.
 164      *  getFrom()     returns the full jabber id
 165      *  getPresence() returns the available/unavailable boolean
 166      *  getShow()     returns the jabber 'show' string: 'show', 'away', 'xa', etc
 167      *  getStatus()   returns a status message, sent from a client
 168      *  Note: if a presence packet is determined to be MUC, it is
 169      *    rather sent as an EVENT_MUC_JOIN, LEAVE, or PRESENCE
 170      */
 171     static const int EVENT_PRESENCE             = 30;
 172
 173     /**
 174      *  Client has just received a complete roster.  The collected information
 175      *  can be found at client.getRoster(), and is a std::vector of XmppUser
 176      *  records.
 177      */
 178     static const int EVENT_ROSTER               = 31;
 179
 180     /**
 181      *  Client has just received a message packet.
 182      *  getFrom() returns the full jabber id of the sender
 183      *  getData() returns the text of the message
 184      *  getDom()  returns the DOM treelet for this stanza.  This is provided
 185      *                to make message extension easier.
 186      *  Note: if a message packet is determined to be MUC, it is
 187      *    rather sent as an EVENT_MUC_MESSAGE
 188      */
 189     static const int EVENT_MESSAGE              = 32;
 190
 191     /**
 192      *  THIS user has just joined a multi-user chat group.
 193      *  getGroup()    returns the group name
 194      *  getFrom()     returns the nick of the user in the group
 195      *  getPresence() returns the available/unavailable boolean
 196      *  getShow()     returns the jabber 'show' string: 'show', 'away', 'xa', etc
 197      *  getStatus()   returns a status message, sent from a client
 198      */
 199     static const int EVENT_MUC_JOIN             = 40;
 200
 201     /**
 202      *  THIS user has just left a multi-user chat group.
 203      *  getGroup()    returns the group name
 204      *  getFrom()     returns the nick of the user in the group
 205      *  getPresence() returns the available/unavailable boolean
 206      *  getShow()     returns the jabber 'show' string: 'show', 'away', 'xa', etc
 207      *  getStatus()   returns a status message, sent from a client
 208      */
 209     static const int EVENT_MUC_LEAVE            = 41;
 210
 211     /**
 212      *  Presence for another user in a multi-user chat room.
 213      *  getGroup()    returns the group name
 214      *  getFrom()     returns the nick of the user in the group
 215      *  getPresence() returns the available/unavailable boolean
 216      *  getShow()     returns the jabber 'show' string: 'show', 'away', 'xa', etc
 217      *  getStatus()   returns a status message, sent from a client
 218      */
 219     static const int EVENT_MUC_PRESENCE         = 42;
 220
 221     /**
 222      *  Client has just received a message packet from a multi-user chat room
 223      *  getGroup() returns the group name
 224      *  getFrom()  returns the full jabber id of the sender
 225      *  getData()  returns the text of the message
 226      *  getDom()   returns the DOM treelet for this stanza.  This is provided
 227      *             to make message extension easier.
 228      */
 229     static const int EVENT_MUC_MESSAGE          = 43;
 230
 231     /**
 232      *  Client has begun receiving a stream
 233      */
 234     static const int EVENT_STREAM_RECEIVE_INIT  = 50;
 235
 236     /**
 237      *  Client receives another stream packet.
 238      */
 239     static const int EVENT_STREAM_RECEIVE       = 51;
 240
 241     /**
 242      * Client has received the end of a stream
 243      */
 244     static const int EVENT_STREAM_RECEIVE_CLOSE = 52;
 245
 246     /**
 247      * Other client has accepted a file.
 248      */
 249     static const int EVENT_FILE_ACCEPTED        = 60;
 250
 251     /**
 252      * This client has just received a file.
 253      */
 254     static const int EVENT_FILE_RECEIVE         = 61;
 255
 256     /**
 257      *  Constructs an event with one of the types above.
 258      */
 259     XmppEvent(int type);
 260
 261     /**
 262      *  Copy constructor
 263      */
 264     XmppEvent(const XmppEvent &other);
 265
 266     /**
 267      *  Assignment
 268      */
 269     virtual XmppEvent &operator=(const XmppEvent &other);
 270
 271     /**
 272      *  Destructor
 273      */
 274     virtual ~XmppEvent();
 275
 276     /**
 277      *  Assignment
 278      */
 279     virtual void assign(const XmppEvent &other);
 280
 281     /**
 282      *  Return the event type.
 283      */
 284     virtual int getType() const;
 285
 286
 287     /**
 288      *
 289      */
 290     virtual DOMString getIqId() const;
 291
 292
 293     /**
 294      *
 295      */
 296     virtual void setIqId(const DOMString &val);
 297
 298     /**
 299      *
 300      */
 301     virtual DOMString getStreamId() const;
 302
 303
 304     /**
 305      *
 306      */
 307     virtual void setStreamId(const DOMString &val);
 308
 309     /**
 310      *
 311      */
 312     virtual bool getPresence() const;
 313
 314
 315     /**
 316      *
 317      */
 318     virtual void setPresence(bool val);
 319
 320     /**
 321      *
 322      */
 323     virtual DOMString getShow() const;
 324
 325
 326     /**
 327      *
 328      */
 329     virtual void setShow(const DOMString &val);
 330
 331     /**
 332      *
 333      */
 334     virtual DOMString getStatus() const;
 335
 336     /**
 337      *
 338      */
 339     virtual void setStatus(const DOMString &val);
 340
 341     /**
 342      *
 343      */
 344     virtual DOMString getTo() const;
 345
 346     /**
 347      *
 348      */
 349     virtual void setTo(const DOMString &val);
 350
 351     /**
 352      *
 353      */
 354     virtual DOMString getFrom() const;
 355
 356     /**
 357      *
 358      */
 359     virtual void setFrom(const DOMString &val);
 360
 361     /**
 362      *
 363      */
 364     virtual DOMString getGroup() const;
 365
 366     /**
 367      *
 368      */
 369     virtual void setGroup(const DOMString &val);
 370
 371     /**
 372      *
 373      */
 374     virtual Element *getDOM() const;
 375
 376
 377     /**
 378      *
 379      */
 380     virtual void setDOM(const Element *val);
 381
 382     /**
 383      *
 384      */
 385     virtual std::vector<XmppUser> getUserList() const;
 386
 387     /**
 388      *
 389      */
 390     virtual void setUserList(const std::vector<XmppUser> &userList);
 391
 392     /**
 393      *
 394      */
 395     virtual DOMString getFileName() const;
 396
 397
 398     /**
 399      *
 400      */
 401     virtual void setFileName(const DOMString &val);
 402
 403
 404     /**
 405      *
 406      */
 407     virtual DOMString getFileDesc() const;
 408
 409
 410     /**
 411      *
 412      */
 413     virtual void setFileDesc(const DOMString &val);
 414
 415
 416     /**
 417      *
 418      */
 419     virtual long getFileSize() const;
 420
 421
 422     /**
 423      *
 424      */
 425     virtual void setFileSize(long val);
 426
 427     /**
 428      *
 429      */
 430     virtual DOMString getFileHash() const;
 431
 432     /**
 433      *
 434      */
 435     virtual void setFileHash(const DOMString &val);
 436
 437     /**
 438      *
 439      */
 440     virtual DOMString getData() const;
 441
 442
 443     /**
 444      *
 445      */
 446     virtual void setData(const DOMString &val);
 447
 448 private:
 449
 450     int eventType;
 451
 452     DOMString iqId;
 453
 454     DOMString streamId;
 455
 456     bool      presence;
 457
 458     DOMString show;
 459
 460     DOMString status;
 461
 462     DOMString to;
 463
 464     DOMString from;
 465
 466     DOMString group;
 467
 468     DOMString data;
 469
 470     DOMString fileName;
 471     DOMString fileDesc;
 472     long      fileSize;
 473     DOMString fileHash;
 474
 475     Element *dom;
 476
 477     std::vector<XmppUser>userList;
 478
 479 };
 480
 481
 482
 483
 484
 485
 486 //########################################################################
 487 //# X M P P    E V E N T    L I S T E N E R
 488 //########################################################################
 489
 490 /**
 491  * Class that receives and processes an XmppEvent.  Users should inherit
 492  * from this class, and overload processXmppEvent() to perform their event
 493  * handling
 494  */
 495 class XmppEventListener
 496 {
 497 public:
 498
 499     /**
 500      *  Constructor
 501      */
 502     XmppEventListener()
 503         {}
 504
 505     /**
 506      *  Assignment
 507      */
 508     XmppEventListener(const XmppEventListener &/*other*/)
 509         {}
 510
 511
 512     /**
 513      * Destructor
 514      */
 515     virtual ~XmppEventListener()
 516         {}
 517
 518     /**
 519      *  Overload this method to provide your application-specific
 520      *  event handling.  Use event.getType() to decide what to do
 521      *  with the event.
 522      */
 523     virtual void processXmppEvent(const XmppEvent &/*event*/)
 524         {}
 525
 526 };
 527
 528
 529
 530 //########################################################################
 531 //# X M P P    E V E N T    T A R G E T
 532 //########################################################################
 533
 534 /**
 535  * A base class for classes that emit XmppEvents.
 536  *
 537  * Note: terminology: 'target' is the common term for this, although it
 538  * seems odd that a 'target' is the source of the events.  It is clearer
 539  * if you consider that the greater system targets this class with events,
 540  * and this class delegates the handling to its listeners.
 541  */
 542 class XmppEventTarget
 543 {
 544 public:
 545
 546     /**
 547      * Constructor
 548      */
 549     XmppEventTarget();
 550
 551     /**
 552      *  Copy constructor
 553      */
 554     XmppEventTarget(const XmppEventTarget &other);
 555
 556     /**
 557      * Destructor
 558      */
 559     virtual ~XmppEventTarget();
 560
 561
 562     //###########################
 563     //# M E S S A G E S
 564     //###########################
 565
 566
 567     /**
 568      * Send an error message to all subscribers
 569      */
 570     void error(const char *fmt, ...) G_GNUC_PRINTF(2,3);
 571
 572
 573     /**
 574      * Send a status message to all subscribers
 575      */
 576     void status(const char *fmt, ...) G_GNUC_PRINTF(2,3);
 577
 578     //###########################
 579     //# LISTENERS
 580     //###########################
 581
 582     /**
 583      *  Subscribe a subclass of XmppEventListener to this target's events.
 584      */
 585     virtual void addXmppEventListener(const XmppEventListener &listener);
 586
 587     /**
 588      *  Unsubscribe a subclass of XmppEventListener from this target's events.
 589      */
 590     virtual void removeXmppEventListener(const XmppEventListener &listener);
 591
 592     /**
 593      *  Remove all event subscribers
 594      */
 595     virtual void clearXmppEventListeners();
 596
 597     /**
 598      *  This sends an event to all registered listeners.
 599      */
 600     virtual void dispatchXmppEvent(const XmppEvent &event);
 601
 602     /**
 603      *  By enabling this, you provide an alternate way to get XmppEvents.
 604      *  Any event sent to dispatchXmppEvent() is also sent to this queue,
 605      *  so that it can be later be picked up by eventQueuePop();
 606      *  This can sometimes be good for GUI's which can't always respond
 607      *  repidly or asynchronously.
 608      */
 609     void eventQueueEnable(bool val);
 610
 611     /**
 612      *  Return true if there is one or more XmppEvents waiting in the event
 613      *  queue.  This is used to avoid calling eventQueuePop() when there is
 614      *  nothing in the queue.
 615      */
 616     int eventQueueAvailable();
 617
 618     /**
 619      *  Return the next XmppEvent in the queue.  Users should check that
 620      *  eventQueueAvailable() is greater than 0 before calling this.  If
 621      *  people forget to do this, an event of type XmppEvent::EVENT_NONE
 622      *  is generated and returned.
 623      */
 624     XmppEvent eventQueuePop();
 625
 626
 627 private:
 628
 629     std::vector<XmppEventListener *> listeners;
 630
 631     std::vector<XmppEvent> eventQueue;
 632     bool eventQueueEnabled;
 633 };
 634
 635
 636
 637
 638
 639 //########################################################################
 640 //# X M P P    C L I E N T
 641 //########################################################################
 642
 643 //forward declarations
 644 class TcpSocket;
 645 class XmppChat;
 646 class XmppGroupChat;
 647 class XmppStream;
 648
 649
 650 /**
 651  *  This is the actual XMPP (Jabber) client.
 652  */
 653 class XmppClient : public XmppEventTarget
 654 {
 655
 656 public:
 657
 658     //###########################
 659     //# CONSTRUCTORS
 660     //###########################
 661
 662     /**
 663      * Constructor
 664      */
 665     XmppClient();
 666
 667     /**
 668      *  Copy constructor
 669      */
 670     XmppClient(const XmppClient &other);
 671
 672     /**
 673      *  Assignment
 674      */
 675     void assign(const XmppClient &other);
 676
 677     /**
 678      * Destructor
 679      */
 680     virtual ~XmppClient();
 681
 682
 683     //###########################
 684     //# UTILITY
 685     //###########################
 686
 687     /**
 688      *  Pause execution of the app for a given number of
 689      *  milliseconds.  Use this rarely, only when really needed.
 690      */
 691     virtual bool pause(unsigned long millis);
 692
 693     /**
 694      *  Process a string so that it can safely be
 695      *  placed in XML as PCDATA
 696      */
 697     DOMString toXml(const DOMString &str);
 698
 699     //###########################
 700     //# CONNECTION
 701     //###########################
 702
 703     /**
 704      *
 705      */
 706     virtual bool connect();
 707
 708     /**
 709      *
 710      */
 711     virtual bool connect(DOMString host, int port,
 712                          DOMString userName,
 713                          DOMString password,
 714                          DOMString resource);
 715
 716     /**
 717      *
 718      */
 719     virtual bool disconnect();
 720
 721
 722     /**
 723      *
 724      */
 725     virtual bool write(const char *fmt, ...) G_GNUC_PRINTF(2,3);
 726
 727     //#######################
 728     //# V A R I A B L E S
 729     //#######################
 730
 731     /**
 732      *
 733      */
 734     virtual bool isConnected()
 735         { return connected; }
 736
 737     /**
 738      *
 739      */
 740     virtual DOMString getHost()
 741         { return host; }
 742
 743     /**
 744      *
 745      */
 746     virtual void setHost(const DOMString &val)
 747         { host = val; }
 748
 749     /**
 750      *
 751      */
 752     virtual DOMString getRealm()
 753         { return realm; }
 754
 755     /**
 756      *
 757      */
 758     virtual void setRealm(const DOMString &val)
 759         { realm = val; }
 760
 761     /**
 762      *
 763      */
 764     virtual int getPort()
 765         { return port; }
 766
 767     /**
 768      *
 769      */
 770     virtual void setPort(int val)
 771         { port = val; }
 772
 773     /**
 774      *
 775      */
 776     virtual DOMString getUsername();
 777
 778     /**
 779      *
 780      */
 781     virtual void setUsername(const DOMString &val);
 782
 783     /**
 784      *
 785      */
 786     virtual DOMString getPassword()
 787         { return password; }
 788
 789     /**
 790      *
 791      */
 792     virtual void setPassword(const DOMString &val)
 793         { password = val; }
 794
 795     /**
 796      *
 797      */
 798     virtual DOMString getResource()
 799         { return resource; }
 800
 801     /**
 802      *
 803      */
 804     virtual void setResource(const DOMString &val)
 805         { resource = val; }
 806
 807     /**
 808      *
 809      */
 810     virtual void setJid(const DOMString &val)
 811         { jid = val; }
 812
 813     /**
 814      *
 815      */
 816     virtual DOMString getJid()
 817         { return jid; }
 818
 819
 820
 821     /**
 822      *
 823      */
 824     virtual int getMsgId()
 825         { return msgId++; }
 826
 827
 828
 829     //#######################
 830     //# P R O C E S S I N G
 831     //#######################
 832
 833
 834     /**
 835      *
 836      */
 837     bool processMessage(Element *root);
 838
 839     /**
 840      *
 841      */
 842     bool processPresence(Element *root);
 843
 844     /**
 845      *
 846      */
 847     bool processIq(Element *root);
 848
 849     /**
 850      *
 851      */
 852     virtual bool receiveAndProcess();
 853
 854     /**
 855      *
 856      */
 857     virtual bool receiveAndProcessLoop();
 858
 859     //#######################
 860     //# ROSTER
 861     //#######################
 862
 863     /**
 864      *
 865      */
 866     bool rosterAdd(const DOMString &rosterGroup,
 867                    const DOMString &otherJid,
 868                    const DOMString &name);
 869
 870     /**
 871      *
 872      */
 873     bool rosterDelete(const DOMString &otherJid);
 874
 875     /**
 876      *
 877      */
 878     std::vector<XmppUser> getRoster();
 879
 880     /**
 881      *
 882      */
 883     virtual void rosterShow(const DOMString &jid, const DOMString &show);
 884
 885     //#######################
 886     //# REGISTRATION
 887     //#######################
 888
 889     /**
 890      *  Set whether the client should to in-band registration
 891      *  before authentication.  Causes inBandRegistrationNew() to be called
 892      *  synchronously, before async is started.
 893      */
 894     virtual void setDoRegister(bool val)
 895         { doRegister = val; }
 896
 897     /**
 898      * Change the password of an existing account with a server
 899      */
 900     bool inBandRegistrationChangePassword(const DOMString &newPassword);
 901
 902     /**
 903      * Cancel an existing account with a server
 904      */
 905     bool inBandRegistrationCancel();
 906
 907
 908     //#######################
 909     //# CHAT (individual)
 910     //#######################
 911
 912     /**
 913      *
 914      */
 915     virtual bool message(const DOMString &user, const DOMString &subj,
 916                          const DOMString &text);
 917
 918     /**
 919      *
 920      */
 921     virtual bool message(const DOMString &user, const DOMString &text);
 922
 923     /**
 924      *
 925      */
 926     virtual bool presence(const DOMString &presence);
 927
 928     //#######################
 929     //# GROUP CHAT
 930     //#######################
 931
 932     /**
 933      *
 934      */
 935     virtual bool groupChatCreate(const DOMString &groupJid);
 936
 937     /**
 938      *
 939      */
 940     virtual void groupChatDelete(const DOMString &groupJid);
 941
 942     /**
 943      *
 944      */
 945     bool groupChatExists(const DOMString &groupJid);
 946
 947     /**
 948      *
 949      */
 950     virtual void groupChatsClear();
 951
 952     /**
 953      *
 954      */
 955     virtual void groupChatUserAdd(const DOMString &groupJid,
 956                                   const DOMString &nick,
 957                                   const DOMString &jid);
 958     /**
 959      *
 960      */
 961     virtual void groupChatUserShow(const DOMString &groupJid,
 962                                    const DOMString &nick,
 963                                    const DOMString &show);
 964
 965     /**
 966      *
 967      */
 968     virtual void groupChatUserDelete(const DOMString &groupJid,
 969                                      const DOMString &nick);
 970
 971     /**
 972      *
 973      */
 974     virtual std::vector<XmppUser>
 975              groupChatGetUserList(const DOMString &groupJid);
 976
 977     /**
 978      *
 979      */
 980     virtual bool groupChatJoin(const DOMString &groupJid,
 981                                const DOMString &nick,
 982                                const DOMString &pass);
 983
 984     /**
 985      *
 986      */
 987     virtual bool groupChatLeave(const DOMString &groupJid,
 988                                 const DOMString &nick);
 989
 990     /**
 991      *
 992      */
 993     virtual bool groupChatMessage(const DOMString &groupJid,
 994                                   const DOMString &msg);
 995
 996     /**
 997      *
 998      */
 999     virtual bool groupChatPrivateMessage(const DOMString &groupJid,
1000                                          const DOMString &toNick,
1001                                          const DOMString &msg);
1002
1003     /**
1004      *
1005      */
1006     virtual bool groupChatPresence(const DOMString &groupJid,
1007                                    const DOMString &nick,
1008                                    const DOMString &presence);
1009
1010
1011     //#######################
1012     //# STREAMS
1013     //#######################
1014
1015     typedef enum
1016         {
1017         STREAM_AVAILABLE,
1018         STREAM_OPENING,
1019         STREAM_OPEN,
1020         STREAM_CLOSING,
1021         STREAM_CLOSED,
1022         STREAM_ERROR
1023         } StreamStates;
1024
1025     /**
1026      *
1027      */
1028     virtual bool outputStreamOpen(const DOMString &jid,
1029                                  const DOMString &streamId);
1030
1031     /**
1032      *
1033      */
1034     virtual bool outputStreamWrite(const DOMString &streamId,
1035                const std::vector<unsigned char> &buf);
1036
1037     /**
1038      *
1039      */
1040     virtual bool outputStreamClose(const DOMString &streamId);
1041
1042     /**
1043      *
1044      */
1045     virtual bool inputStreamOpen(const DOMString &jid,
1046                                 const DOMString &streamId,
1047                                 const DOMString &iqId);
1048
1049     /**
1050      *
1051      */
1052     virtual bool inputStreamClose(const DOMString &streamId);
1053
1054
1055     //#######################
1056     //# FILE   TRANSFERS
1057     //#######################
1058
1059     /**
1060      *
1061      */
1062     virtual bool fileSend(const DOMString &destJid,
1063                           const DOMString &offeredName,
1064                           const DOMString &fileName,
1065                           const DOMString &description);
1066
1067     /**
1068      *
1069      */
1070     virtual bool fileSendBackground(const DOMString &destJid,
1071                                     const DOMString &offeredName,
1072                                     const DOMString &fileName,
1073                                     const DOMString &description);
1074
1075     /**
1076      *
1077      */
1078     virtual bool fileReceive(const DOMString &fromJid,
1079                              const DOMString &iqId,
1080                              const DOMString &streamId,
1081                              const DOMString &fileName,
1082                              long  fileSize,
1083                              const DOMString &fileHash);
1084     /**
1085      *
1086      */
1087     virtual bool fileReceiveBackground(const DOMString &fromJid,
1088                                        const DOMString &iqId,
1089                                        const DOMString &streamId,
1090                                        const DOMString &fileName,
1091                                        long  fileSize,
1092                                        const DOMString &fileHash);
1093
1094
1095 private:
1096
1097     void init();
1098
1099     DOMString host;
1100
1101     /**
1102      * will be same as host, unless username is
1103      * user@realm
1104      */
1105     DOMString realm;
1106
1107     int port;
1108
1109     DOMString username;
1110
1111     DOMString password;
1112
1113     DOMString resource;
1114
1115     DOMString jid;
1116
1117     int msgId;
1118
1119     TcpSocket *sock;
1120
1121     bool connected;
1122
1123     bool createSession();
1124
1125     bool checkConnect();
1126
1127     DOMString readStanza();
1128
1129     bool saslMd5Authenticate();
1130
1131     bool saslPlainAuthenticate();
1132
1133     bool saslAuthenticate(const DOMString &streamId);
1134
1135     bool iqAuthenticate(const DOMString &streamId);
1136
1137     /**
1138      * Register a new account with a server.  Not done by user
1139      */
1140     bool inBandRegistrationNew();
1141
1142     bool keepGoing;
1143
1144     bool doRegister;
1145
1146     std::vector<XmppGroupChat *>groupChats;
1147
1148     //#### Roster
1149     std::vector<XmppUser>roster;
1150
1151
1152     //#### Streams
1153
1154     bool processInBandByteStreamMessage(Element *root);
1155
1156     DOMString streamPacket;
1157
1158     std::map<DOMString, XmppStream *> outputStreams;
1159
1160     std::map<DOMString, XmppStream *> inputStreams;
1161
1162
1163     //#### File send
1164
1165     bool processFileMessage(Element *root);
1166
1167     std::map<DOMString, XmppStream *> fileSends;
1168
1169 };
1170
1171
1172
1173
1174 //########################################################################
1175 //# X M P P    G R O U P    C H A T
1176 //########################################################################
1177
1178 /**
1179  *
1180  */
1181 class XmppGroupChat
1182 {
1183 public:
1184
1185     /**
1186      *
1187      */
1188     XmppGroupChat(const DOMString &groupJid);
1189
1190     /**
1191      *
1192      */
1193     XmppGroupChat(const XmppGroupChat &other);
1194
1195     /**
1196      *
1197      */
1198     virtual ~XmppGroupChat();
1199
1200     /**
1201      *
1202      */
1203     virtual DOMString getGroupJid();
1204
1205     /**
1206      *
1207      */
1208     virtual void userAdd(const DOMString &nick,
1209                          const DOMString &jid);
1210     /**
1211      *
1212      */
1213     virtual void userShow(const DOMString &nick,
1214                           const DOMString &show);
1215
1216     /**
1217      *
1218      */
1219     virtual void userDelete(const DOMString &nick);
1220
1221     /**
1222      *
1223      */
1224     virtual std::vector<XmppUser> getUserList() const;
1225
1226
1227 private:
1228
1229     DOMString groupJid;
1230
1231     std::vector<XmppUser>userList;
1232
1233 };
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244 } //namespace Pedro
1245
1246 #endif /* __XMPP_H__ */
1247
1248 //########################################################################
1249 //# E N D    O F     F I L E
1250 //########################################################################
1251