Net::XMPP::Client(3) XMPP Client Module


Net::XMPP::Client is a module that provides a developer easy access
to the Extensible Messaging and Presence Protocol (XMPP).

DESCRIPTION uses to provide enough high level APIs and
  automation of the low level APIs that writing an XMPP Client in
  Perl is trivial.  For those that wish to work with the low level
  you can do that too, but those functions are covered in the
  documentation for each module.
  Net::XMPP::Client provides functions to connect to an XMPP server,
  login, send and receive messages, set personal information, create
  a new user account, manage the roster, and disconnect.  You can use
  all or none of the functions, there is no requirement.
  For more information on how the details for how Net::XMPP is written
  please see the help for Net::XMPP itself.
  For a full list of high level functions available please see

Basic Functions

    use Net::XMPP;
    $Con = new Net::XMPP::Client();
    # For the list of available functions see Net::XMPP::Protocol.


Basic Functions

    new(debuglevel=>0|1|2, - creates the Client object.  debugfile
        debugfile=>string,   should be set to the path for the debug
        debugtime=>0|1)      log to be written.  If set to "stdout"
                             then the debug will go there.  debuglevel
                             controls the amount of debug.  For more
                             information about the valid setting for
                             debuglevel, debugfile, and debugtime see
    Connect(hostname=>string,      - opens a connection to the server
            port=>integer,           listed in the hostname (default
            timeout=>int             localhost), on the port (default
            connectiontype=>string,  5222) listed, using the
            tls=>0|1,                connectiontype listed (default
            srv=>0|1,                tcpip).  The two connection types
            componentname=>string)   available are:
                                       tcpip  standard TCP socket
                                       http   TCP socket, but with the
                                              headers needed to talk
                                              through a web proxy
                                     If you specify tls, then it TLS
                                     will be used if it is available
                                     as a feature.
                                     If srv is specified AND Net::DNS is
                                     installed and can be loaded, then
                                     an SRV query is sent to srv.hostname
                                     and the results processed to replace
                                     the hostname and port.  If the lookup
                                     fails, or Net::DNS cannot be loaded,
                                     then hostname and port are left alone
                                     as the defaults.
                                     Alternatively, you may manually specify
                                     componentname as the domain portion of the
                                     jid and leave hostname set to the actual
                                     hostname of the XMPP server.
    Execute(hostname=>string,       - Generic inner loop to handle
            port=>int,                connecting to the server, calling
            tls=>0|1,                 Process, and reconnecting if the
            username=>string,         connection is lost.  There are
            password=>string,         five callbacks available that are
            resource=>string,         called at various places:
            register=>0|1,              onconnect - when the client has
            connectiontype=>string,                 made a connection.
            connecttimeout=>string,     onauth - when the connection is
            connectattempts=>int,                made and user has been
            connectsleep=>int,                   authed.  Essentially,
            processtimeout=>int)                 this is when you can
                                                 start doing things
                                                 as a Client.  Like
                                                 send presence, get your
                                                 roster, etc...
                                        onprocess - this is the most
                                                    inner loop and so
                                                    gets called the most.
                                                    Be very very careful
                                                    what you put here
                                                    since it can
                                                    *DRASTICALLY* affect
                                        ondisconnect - when the client
                                                       disconnects from
                                                       the server.
                                        onexit - when the function gives
                                                 up trying to connect and
                                      The arguments are passed straight
                                      on to the Connect function, except
                                      for connectattempts and connectsleep.
                                      connectattempts is the number of
                                      times that the Component should try
                                      to connect before giving up.  -1
                                      means try forever.  The default is
                                      -1. connectsleep is the number of
                                      seconds to sleep between each
                                      connection attempt.
                                      If you specify register=>1, then the
                                      Client will attempt to register the
                                      sepecified account for you, if it
                                      does not exist.
    Process(integer) - takes the timeout period as an argument.  If no
                       timeout is listed then the function blocks until
                       a packet is received.  Otherwise it waits that
                       number of seconds and then exits so your program
                       can continue doing useful things.  NOTE: This is
                       important for GUIs.  You need to leave time to
                       process GUI commands even if you are waiting for
                       packets.  The following are the possible return
                       values, and what they mean:
                           1   - Status ok, data received.
                           0   - Status ok, no data received.
                         undef - Status not ok, stop processing.
                       IMPORTANT: You need to check the output of every
                       Process.  If you get an undef then the connection
                       died and you should behave accordingly.
    Disconnect() - closes the connection to the server.
    Connected() - returns 1 if the Transport is connected to the server,
                  and 0 if not.


Ryan Eatmon


This module is free software, you can redistribute it and/or modify it under the LGPL.