jabberconnection.pm

Punjab is a jabber XMLRPC/SOAP/REST client. It is a xmlrpc, soap, or REST server that allows for p

package PunJab::JabberConnection;
use POE::Preprocessor;
const XNode POE::Filter::XML::Node
use strict;
use warnings;
use POE qw/ Component::Jabber::Client::Legacy Component::Jabber::Error 
    Component::Jabber::Client::XMPP Wheel::Run Filter::Reference /;
use POE::Filter::XML;
use POE::Filter::XML::Node;
use POE::Filter::XML::NS qw/ :JABBER :IQ /;
use POE::Filter::XML::Utils;
use POE::Component::Jabber;

use PunJab;
use PunJab::Util;
use PunJab::Manager;

use POSIX qw(strftime);
use Data::Uniqid qw ( suniqid uniqid luniqid );



sub new {
    my $class      = shift;
    my $me         = $class . '->new()';
    #die "$me requires an even number of arguments" if(@_ & 1);    
    my $session_id = shift;
    my $jid        = shift;
    my $pass       = shift;
    my $username   = shift;
    my $resource   = shift;
    my $hostname   = shift;
    my $port       = shift;
    my $config     = shift;
    my $soap_call  = shift; # only used in the new method
    my $init_event = shift;
    my $error_event = shift; # I should do a loop here

    if (not defined $jid or not defined $pass) {
	$soap_call->error("Error in username and password");
	return;
    }
    if (not defined $init_event or not defined $error_event) {
	$soap_call->error("Error in events, none defined");
	return;
    }

    my $error = TRUE;
    $config->{'timeout'} = 100 if not defined $config->{'timeout'};
    
    POE::Session->create(
			 options => {  debug    => $config->{debug}, 
				       trace    => $config->{debug}
			             },
			 heap => { CONFIG      => $config,
			           jid         => $jid,
				   sid         => $session_id, # I need help with this 
				   username    => $username,
				   hostname    => $hostname,
                                   pass        => $pass,
                                   res         => $resource,
				   soap_call   => $soap_call,
				   init_event  => $init_event,
				   error_event => $error_event,
			       },
			 inline_states => {
			     _start =>
				 sub
			     {
				 my $kernel = $_[KERNEL];
				 $kernel->alias_set($session_id);

				 $_[HEAP]->{'manager'} = PunJab::Manager->new(
									      debug => $config->{'debug'}, 
									      trace => $config->{'debug'},
									      sid   => $session_id,
									      alias => "Manager".$session_id,
									      database => $config->{'database'});
				 if ($config->{'client'} eq "legacy") {
				     
				     $_[HEAP]->{'jabber'} = POE::Component::Jabber::Client::Legacy->new(
							     IP => $hostname,
							     PORT => $port,
							     HOSTNAME => $hostname,
							     XMLNS => +NS_JABBER_CLIENT,
							     STREAM => +XMLNS_STREAM,
							     ALIAS => 'JABBER'.$session_id, # I do not know if this is correct
                                                             DEBUG => $config->{debug},
							     STATE_PARENT => $session_id,
							     USERNAME => $username,
							     PASSWORD => $pass,
							     RESOURCE => $resource,
							     STATES => {
								 InitFinish => 'init_finished',
								 InputEvent => 'input_event',
								 ErrorEvent => 'error_event',
							     },
							     PLAINTEXT => $config->{'plaintext'}
							     );
				 } elsif ($config->{'client'} eq "xmpp") {
				     # this is not fully supported yet. 
				     
				     $_[HEAP]->{'jabber'} = POE::Component::Jabber::Client::XMPP->new(
							     IP => $hostname,
							     PORT => $port,
							     HOSTNAME => $hostname,
							     XMLNS => +NS_JABBER_CLIENT,
							     STREAM => +XMLNS_STREAM,
							     ALIAS => 'JABBER'.$session_id, # I do not know if this is correct
                                                             DEBUG => $config->{debug},
							     STATE_PARENT => $session_id,
							     USERNAME => $username,
							     PASSWORD => $pass,
			                                     RESOURCE => $resource,
							     STATES => {
								 InitFinish => 'init_finished',
								 InputEvent => 'input_event',
								 ErrorEvent => 'error_event',
							     },
							     PLAINTEXT => $config->{'plaintext'}
							     );
				 }
			     },
                            _stop =>
                             sub
                                 {
                                    my $kernel = $_[KERNEL];
				    if ($_[HEAP]->{'CONFIG'}->{debug}>0) {
					&debug("JABBER CONNECTION STOPED!");
				    }
				    delete $_[HEAP]->{'jabber'};
				    delete $_[HEAP]->{'manager'};
				    
                                 } ,
                        shutdown => 
                                sub {
				    my ($kernel, $heap) = @_[KERNEL, HEAP];
				    $heap->{shutdown} = 1;
				    $kernel->alias_remove($session_id) if defined $session_id;
				},
                input_event        => \&input_event,
                error_event        => \&error_event,
                init_finished      => \&init_finished,
                get_error          => \&get_error,
                send_xml           => \&send_xml,
                send_presence      => \&send_presence,
                start_browse       => \&start_browse,
                start_vcard        => \&start_vcard,
                set_vcard          => \&set_vcard,
                disconnect         => \&disconnect,              
                jabber_timeout     => \&jabber_timeout,   
	},
    
     );

    return $session_id;

}


### Handlers for the jabber client.

sub init_finished()
{
	my ($kernel, $heap) = @_[KERNEL, HEAP];
	
	if (defined($heap->{'init_event'})) {	    
	    $kernel->post($heap->{'CONFIG'}->{type},$heap->{'init_event'},$heap->{'sid'});
	    delete $heap->{'init_event'};
	}

	if (defined($heap->{'soap_call'})) {
	    $heap->{'soap_call'}->return($heap->{'sid'});
	}

	delete $heap->{'soap_call'};
}

sub input_event()
{
	my ($kernel,$heap,$node) = @_[KERNEL, HEAP, ARG0];
	
	# pass it to the manager
	$kernel->post('Manager'.$heap->{'sid'},'input_event',$node);
}

sub error_event()
{
	my ($kernel,$heap,$error) = @_[KERNEL, HEAP, ARG0];
	
	if($error == +PCJ_SOCKFAIL)                                                                 
        { 
	    my ($call, $code, $err) = @_[ARG1..ARG3];                                             
	    if ($heap->{'CONFIG'}->{debug}>0) {
		debug( "Socket error: $call, $code, $err\n" );
	    }
	} elsif ($error == +PCJ_SOCKDISC) { 
	    if ($heap->{'CONFIG'}->{debug}>0) {
		&debug("We got disconneted");
	    }
        } elsif ($error == +PCJ_AUTHFAIL) { 
	    if ($heap->{'CONFIG'}->{debug}>0) {
		&debug("Failed to authenticate");
	    }
	    if (defined $_[HEAP]->{'soap_call'}) {
		$heap->{'soap_call'}->auth("failed to auth");
		delete $heap->{'soap_call'};
	    }
        } elsif ($error == +PCJ_BINDFAIL) { 
	    if ($heap->{'CONFIG'}->{debug}>0) {
		&debug("Failed to bind a resource"); # XMPP/J2 Only
	    }
        } elsif ($error == +PCJ_SESSFAIL) {
	    if ($heap->{'CONFIG'}->{debug}>0) {
		&debug("Failed to establish a session"); # XMPP Only 
	    }
	}
	if (defined($heap->{'error_event'})) {
	    $kernel->post($heap->{'CONFIG'}->{type},$heap->{'error_event'},$heap->{'sid'},$error);
	    delete $heap->{'error_event'};
	}
	$kernel->yield('disconnect'); # handles all errors for now
}



sub disconnect() {
    my ($self, $kernel, $heap) = @_[SESSION, KERNEL, HEAP];	
        
    $kernel->yield('send_presence','unavailable','xa','Disconnected');
    
    $kernel->post('JABBER'.$heap->{'sid'}
		      , 'shutdown_socket', 1);
        
    $kernel->post('Manager'.$heap->{'sid'},'shutdown');
        
    $kernel->delay('shutdown',2);
    
    delete $heap->{readwrite};

    return;
    
}


# ---------------------------- #
# send_xml - 
# ---------------------------- #
sub send_xml()
{
	my ($sender, $kernel,$heap,$node,$event,$event_param) = 
	    @_[SENDER, KERNEL,HEAP, ARG0, ARG1, ARG2];
		
	$kernel->post('JABBER'.$heap->{'sid'},'output_handler', $node);
	
	if (defined($event)) {
	    # send event to the manager
	    $kernel->post('Manager'.$heap->{'sid'},'manage_events', $event, $event_param,$node,$heap->{'sid'});
	} else {
	    return;
	}
}

# ---------------------------- #
# send_presnce - 
# ---------------------------- #
sub send_presence()
{
    my ($self, $kernel, $heap, $type, $show, $status, $to) =
	@_[SESSION, KERNEL, HEAP, ARG0..ARG3];
    
    $heap->{'last_active'} = time();
    my $node = XNode->new('presence');
    $node->attr('to', $to) if defined($to);
    $node->attr('type', $type) if defined($type);
    $node->insert_tag('show')->data($show) if defined($show);
    $node->insert_tag('status')->data($status) if defined($status);
    $kernel->post('JABBER'.$heap->{'sid'}, 'output_handler', $node);
}

sub start_browse()
{
        my ($self, $sender,$kernel,$heap,$event,$event_param,$id,$jid,$auto,$items)
            = @_[SESSION,SENDER, KERNEL, HEAP, ARG0 .. ARG6];

	if (not defined $jid or $jid eq "") {
            $jid = $heap->{'hostname'};
        }
        my $node  = POE::Filter::XML::Node->new('iq');
        $node->attr('type','get');
        $node->attr('id',$id."1");
	$node->attr('to',$jid);	
        my $query = $node->insert_tag('query');
        #$query->attr('xmlns',+NS_JABBER_DISCOINFO);
        $query->attr('xmlns','http://jabber.org/protocol/disco#info');
        $kernel->yield('send_xml',$node);
                                                                                                                    
        $node  = POE::Filter::XML::Node->new('iq');
        $node->attr('type','get');
        $node->attr('id',$id."2");
	$node->attr('to',$jid);	
	$node->attr('from',$heap->{'jid'});	
        $query = $node->insert_tag('query');
        #$query->attr('xmlns',+NS_JABBER_DISCOITEMS);
        $query->attr('xmlns','http://jabber.org/protocol/disco#items');
        $kernel->yield('send_xml',$node);
                                                                                                                    
        $node  = POE::Filter::XML::Node->new('iq');
        $node->attr('type','get');
        $node->attr('to',$jid);	
	$node->attr('id',$id."3");	
	
        $query = $node->insert_tag('query');
        $query->attr('xmlns','jabber:iq:browse'); # old stuff
        $kernel->post($heap->{'sid'},'send_xml',$node);
	
	$kernel->post('Manager'.$heap->{'sid'},'start_browse', $event,
		      $event_param,$sender,$id,$heap->{'sid'},$jid,$auto,$items);

}

sub start_vcard()
{
        my ($self, $sender,$kernel,$heap,$event,$event_param,$jid,$id)
            = @_[SESSION,SENDER, KERNEL, HEAP, ARG0 .. ARG3];

        my $node  = POE::Filter::XML::Node->new('iq');
        $node->attr('type',+IQ_GET);
        $node->attr('id',$id);
	$node->attr('to',$jid);	
        my $vcard = $node->insert_tag('vCard');
        #$vcard->attr('xmlns',+NS_JABBER_DISCOINFO);
        $vcard->attr('xmlns','vcard-temp');
	$vcard->attr('prodid','-//HandGen//NONSGML vGen v1.0//EN');
	$vcard->attr('version','2.0');
        $kernel->yield('send_xml',$node);
	$kernel->post('Manager'.$heap->{'sid'},'start_vcard', $event,
		      $event_param,$sender,$jid,$id,$heap->{'sid'});

}

sub set_vcard()
{
    my ($self, $sender,$kernel,$heap,$event,$event_param,$node,$id)
	= @_[SESSION,SENDER, KERNEL, HEAP, ARG0 .. ARG3];
    my $iq = POE::Filter::XML::Node->new('iq');
    $iq->attr('type',+IQ_SET);
    $iq->attr('id',$id);
    $node->attr('xmlns','vcard-temp');
    $iq->insert_tag($node);
    $kernel->yield('send_xml',$iq);

    $kernel->post('Manager'.$heap->{'sid'},'start_vcard', $event,
		  $event_param,$sender,$heap->{'jid'},$id,$heap->{'sid'});

}

1;