XML::Stream(3pm)

NAME
XML::Stream - Creates an XML Stream connection and parses return data

SYNOPSIS
XML::Stream is an attempt at solidifying the use of XML via streaming.

DESCRIPTION
This module provides the user with methods to connect to a remote server, send a stream of XML to the server, and receive/parse an XML stream from the server. It is primarily based work for the Etherx XML router developed by the Jabber Development Team. For more information about this project visit http://xmpp.org/protocols/streams/.

XML::Stream gives the user the ability to define a central callback that will be used to handle the tags received from the server. These tags are passed in the format defined at instantiation time. the closing tag of an object is seen, the tree is finished and passed to the call back function. What the user does with it from there is up to them.

For a detailed description of how this module works, and about the data structure that it returns, please view the source of Stream.pm and look at the detailed description at the end of the file.

NOTE: The parser that XML::Stream::Parser provides, as are most Perl parsers, is synchronous. If you are in the middle of parsing a packet and call a user defined callback, the Parser is blocked until your callback finishes. This means you cannot be operating on a packet, send out another packet and wait for a response to that packet. It will never get to you. Threading might solve this, but as we all know threading in Perl is not quite up to par yet. This issue will be revisted in the future.

METHODS

  new
  new(
      debug      => string,
      debugfh    => FileHandle,
      debuglevel => 0|1|N,
      debugtime  => 0|1,
      style      => string)

Creates the XML::Stream object. debug should be set to the path for the debug log to be written. If set to "stdout" then the debug will go there. Also, you can specify a filehandle that already exists by using debugfh.

debuglevel determines the amount of debug to generate. 0 is the least, 1 is a little more, N is the limit you want.

debugtime determines wether a timestamp should be preappended to the entry. style defines the way the data structure is returned. The two available styles are:

  tree - L<XML::Parser> Tree format
  node - L<XML::Stream::Node> format

For more information see the respective man pages.

  Listen
Starts the stream by listening on a port for someone to connect, and send the opening stream tag, and then sending a response based on if the received header was correct for this stream. Server name, port, and namespace are required otherwise we don't know where to listen and what namespace to accept.

  ConnectionAccept
Accept an incoming connection.

  Respond
If this is a listening socket then we need to respond to the opening <stream:stream/>.

  Connect
Starts the stream by connecting to the server, sending the opening stream tag, and then waiting for a response and verifying that it is correct for this stream. Server name, port, and namespace are required otherwise we don't know where to send the stream to...

  Connect(hostname=>string,
          port=>integer,
          to=>string,
          from=>string,
          myhostname=>string,
          namespace=>string,
          namespaces=>array,
          connectiontype=>string,
          ssl=>0|1,
          ssl_verify =>0x00|0x01|0x02|0x04,
          ssl_ca_path=>string,
          srv=>string)

Opens a tcp connection to the specified server and sends the proper opening XML Stream tag. "hostname", "port", and "namespace" are required. namespaces allows you to use XML::Stream::Namespace objects.

"to" is needed if you want the stream to attribute to be something other than the hostname you are connecting to.

"from" is needed if you want the stream from attribute to be something other than the hostname you are connecting from.

"myhostname" should not be needed but if the module cannot determine your hostname properly (check the debug log), set this to the correct value, or if you want the other side of the stream to think that you are someone else. The type determines the kind of connection that is made:

  "tcpip"    - TCP/IP (default)
  "stdinout" - STDIN/STDOUT
  "http"     - HTTP

HTTP recognizes proxies if the ENV variables http_proxy or https_proxy are set.

"ssl" specifies whether an SSL socket should be used for encrypted co- mmunications.

"ssl_verify" determines whether peer certificate verification takes place. See the documentation for the SSL_verify_mode parameter to IO::Socket::SSL-new()|IO::Socket::SSL>. The default value is 0x01 causing the server certificate to be verified, and requiring that ssl_ca_path be set.

"ssl_ca_path" should be set to the path to either a directory containing hashed CA certificates, or a single file containing acceptable CA certifictes concatenated together. This parameter is required if ssl_verify is set to anything other than 0x00 (no verification).

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.

This function returns the same hash from GetRoot() below. Make sure you get the SID (Session ID) since you have to use it to call most other functions in here.

  OpenStream
Send the opening stream and save the root element info.

  OpenFile
Starts the stream by opening a file and setting it up so that Process reads from the filehandle to get the incoming stream.

 OpenFile(string)

Opens a filehandle to the argument specified, and pretends that it is a stream. It will ignore the outer tag, and not check if it was a <stream:stream/>. This is useful for writing a program that has to parse any XML file that is basically made up of small packets (like RDF).

  Disconnect
Sends the closing XML tag and shuts down the socket.

  Disconnect(sid)

Sends the proper closing XML tag and closes the specified socket down.

  InitConnection
Initialize the connection data structure

  ParseStream
Takes the incoming stream and makes sure that only full XML tags gets passed to the parser. If a full tag has not read yet, then the Stream saves the incomplete part and sends the rest to the parser.

  Process
Checks for data on the socket and returns a status code depending on if there was data or not. If a timeout is not defined in the call then the timeout defined in Connect() is used. If a timeout of 0 is used then the call blocks until it gets some data, otherwise it returns after the timeout period.

  Process(integer)

Waits for data to be available on the socket. If a timeout is specified then the Process function waits that period of time before returning nothing. If a timeout period is not specified then the function blocks until data is received. The function returns a hash with session ids as the key, and status values or data as the hash values.

  Read
Takes the data from the server and returns a string

  Send
Takes the data string and sends it to the server

  Send(sid, string);

Sends the string over the specified connection as is. This does no checking if valid XML was sent or not. Best behavior when sending information.

  ProcessStreamFeatures
Process the <stream:featutres/> block.

  GetStreamFeature
Return the value of the stream feature (if any).

  ReceivedStreamFeatures
Have we received the stream:features yet?

  ProcessTLSPacket
Process a TLS based packet.

  StartTLS
Client function to have the socket start TLS.

  TLSStartTLS
Send a <starttls/> in the TLS namespace.

  TLSClientProceed
Handle a <proceed/> packet.

  TLSClientSecure
Return 1 if the socket is secure, 0 otherwise.

  TLSClientDone
Return 1 if the TLS process is done

  TLSClientError
return the TLS error if any

  TLSClientFailure
Handle a <failure/>

  TLSFailure
Send a <failure/> in the TLS namespace

  ProcessSASLPacket
Process a SASL based packet.

  SASLAnswerChallenge
When we get a <challenge/> we need to do the grunt work to return a <response/>.

  SASLAuth
Send an <auth/> in the SASL namespace

  SASLChallenge
Send a <challenge/> in the SASL namespace

  SASLClient
This is a helper function to perform all of the required steps for doing SASL with the server.

  SASLClientAuthed
Return 1 if we authed via SASL, 0 otherwise

  SASLClientDone
Return 1 if the SASL process is finished

  SASLClientError
Return the error if any

  SASLClientFailure
Handle a received <failure/>

  SASLClientSuccess
handle a received <success/>

  SASLFailure
Send a <failure/> tag in the SASL namespace

  SASLResponse
Send a <response/> tag in the SASL namespace

  GetErrorCode
if you are returned an undef, you can call this function and hopefully learn more information about the problem.

  GetErrorCode(sid)

returns a string for the specified session that will hopefully contain some useful information about why Process or Connect returned an undef to you.

  StreamError
Given a type and text, generate a <stream:error/> packet to send back to the other side.

  SetXMLData
Takes a host of arguments and sets a portion of the specified data strucure with that data. The function works in two modes "single" or "multiple". "single" denotes that the function should locate the current tag that matches this data and overwrite it's contents with data passed in. "multiple" denotes that a new tag should be created even if others exist.

type - single or multiple XMLTree - pointer to XML::Stream data object (tree or node) tag - name of tag to create/modify (if blank assumes
          working with top level tag) data - CDATA to set for tag attribs - attributes to ADD to tag

  GetXMLData
Takes a host of arguments and returns various data structures that match them.

type "existence" - returns 1 or 0 if the tag exists in the top level.

"value" - returns either the CDATA of the tag, or the value of the attribute depending on which is sought. This ignores any mark ups to the data and just returns the raw CDATA.

"value array" returns an array of strings representing all of the CDATA in the specified tag. This ignores any mark ups to the data and just returns the raw CDATA.

"tree" - returns a data structure that represents the XML with the specified tag as the root tag. Depends on the format that you are working with.

"tree array" returns an array of data structures each with the specified tag as the root tag.

"child array" - returns a list of all children nodes
                not including CDATA nodes.

"attribs" - returns a hash with the attributes, and
            their values, for the things that match
            the parameters

"count" - returns the number of things that match
          the arguments

"tag" - returns the root tag of this tree

XMLTree - pointer to XML::Stream data structure

"tag" - tag to pull data from. If blank then the top level
          tag is accessed. "attrib" - attribute value to retrieve. Ignored for types
          "value array", "tree", "tree array". If paired
          with value can be used to filter tags based on
          attributes and values. "value" - only valid if an attribute is supplied. Used to
          filter for tags that only contain this attribute.
          Useful to search through multiple tags that all
          reference different name spaces.

  XPath
Run an xpath query on a node and return back the result.

XPath(node,path) returns an array of results that match the xpath. node can be any of the three types (Tree, Node).

  XPathCheck
Run an xpath query on a node and return 1 or 0 if the path is valid.

  XML2Config
Takes an XML data tree and turns it into a hash of hashes. This only works for certain kinds of XML trees like this:

                <foo>
                  <bar>1</bar>
                  <x>
                    <y>foo</y>
                  </x>
                  <z>5</z>
                  <z>6</z>
                </foo>

The resulting hash would be:

                $hash{bar} = 1;
                $hash{x}->{y} = "foo";
                $hash{z}->[0] = 5;
                $hash{z}->[1] = 6;

Good for config files.

  Config2XML
Takes a hash and produces an XML string from it. If the hash looks like this:

                $hash{bar} = 1;
                $hash{x}->{y} = "foo";
                $hash{z}->[0] = 5;
                $hash{z}->[1] = 6;

The resulting xml would be:

                <foo>
                  <bar>1</bar>
                  <x>
                    <y>foo</y>
                  </x>
                  <z>5</z>
                  <z>6</z>
                </foo>

Good for config files.

  EscapeXML
Simple function to make sure that no bad characters make it into in the XML string that might cause the string to be misinterpreted.

  UnescapeXML
Simple function to take an escaped string and return it to normal.

  BuildXML
Takes one of the data formats that XML::Stream supports and call the proper BuildXML_xxx function on it.

  ConstXMLNS
Return the namespace from the constant string.

  GetRoot
Returns the hash of attributes for the root <stream:stream/> tag so that any attributes returned can be accessed. from and any xmlns:foobar might be important.

  GetRoot(sid)

Returns the attributes that the stream:stream tag sent by the other end listed in a hash for the specified session.

  GetSock
returns the Socket so that an outside function can access it if desired.

  GetSock(sid)

Returns a pointer to the IO::Socket object for the specified session.

  NewSID
Returns a session ID to send to an incoming stream in the return header. By default it just increments a counter and returns that, or you can define a function and set it using the SetCallBacks function.

  SetCallBacks
Takes a hash with top level tags to look for as the keys and pointers to functions as the values.

  SetCallBacks(node=>function, update=>function);

Sets the callback that should be called in various situations.

"node" is used to handle the data structures that are built for each top level tag. "update" is used for when Process is blocking waiting for data, but you want your original code to be updated.

VARIABLES
  $NONBLOCKING

Tells the Parser to enter into a nonblocking state. This might cause some funky behavior since you can get nested callbacks while things are waiting. 1=on, 0=off(default).

EXAMPLES
simple example

  use XML::Stream qw( Tree );

  $stream = XML::Stream->new;

  my $status = $stream->Connect(hostname => "jabber.org",
                                port => 5222,
                                namespace => "jabber:client");

  if (!defined($status)) {
    print "ERROR: Could not connect to server\n";
    print "       (",$stream->GetErrorCode(),")\n";
    exit(0);
  }

  while($node = $stream->Process()) {
    # do something with $node
  }

  $stream->Disconnect();

Example using a handler

  use XML::Stream qw( Tree );

  $stream = XML::Stream->new;
  $stream->SetCallBacks(node=>\&noder);
  $stream->Connect(hostname => "jabber.org",
                   port => 5222,
                   namespace => "jabber:client",
                   timeout => undef) || die $!;

  # Blocks here forever, noder is called for incoming
  # packets when they arrive.
  while(defined($stream->Process())) { }

  print "ERROR: Stream died (",$stream->GetErrorCode(),")\n";

  sub noder
  {
    my $sid = shift;
    my $node = shift;
    # do something with $node
  }

AUTHOR
Tweaked, tuned, and brightness changes by Ryan Eatmon, reatmon@ti.com in May of 2000. Colorized, and Dolby Surround sound added by Thomas Charron, tcharron@jabber.org By Jeremie in October of 1999 for http://etherx.jabber.org/streams/

Currently maintained by Darian Anthony Patrick.

COPYRIGHT
Copyright (C) 1998-2004 Jabber Software Foundation http://jabber.org/

This module licensed under the LGPL, version 2.1.