File Coverage

blib/lib/Lemonldap/NG/Manager/Sessions.pm

Criterion	Covered	Total	%
statement	4	6	66.6
branch			n/a
condition			n/a
subroutine	2	2	100.0
pod			n/a
total	6	8	75.0

## @file
# Session explorer

## @class
# Session explorer.
# Synopsis:
#  * build a new Lemonldap::NG::Manager::Sessions object
#  * insert tree() result in HTML
#
# tree() loads on of the tree methods.
# new() manage ajax requests (inserted in HTML tree)
package Lemonldap::NG::Manager::Sessions;

use strict;
use Lemonldap::NG::Handler::CGI qw(:tsv);
use Lemonldap::NG::Common::Session;
use Lemonldap::NG::Common::Apache::Session;   #inherits
use Lemonldap::NG::Common::Conf;              #link protected conf Configuration
use Lemonldap::NG::Common::Conf::Constants;   #inherits
require Lemonldap::NG::Manager::_i18n;        #inherits
use utf8;

#inherits Apache::Session

#our $whatToTrace;
#*whatToTrace = \$Lemonldap::NG::Handler::_CGI::whatToTrace;

our $VERSION = '1.4.1';

our @ISA = qw(
  Lemonldap::NG::Handler::CGI
  Lemonldap::NG::Manager::_i18n
);

## @cmethod Lemonldap::NG::Manager::Sessions new(hashRef args)
# Constructor.
# @param $args Arguments for Lemonldap::NG::Handler::CGI::new()
# @return New Lemonldap::NG::Manager::Sessions object
sub new {
    my ( $class, $args ) = @_;

    # Output UTF-8
    binmode( STDOUT, ':utf8' );

    # Try to get configuration values from global configuration
    my $conf = Lemonldap::NG::Common::Conf->new( $args->{configStorage} )
      or Lemonldap::NG::Handler::CGI->abort( 'Unable to get configuration',
        $Lemonldap::NG::Common::Conf::msg );

    if ( my $globalconf = $conf->getConf() ) {
        $args->{$_} ||= $globalconf->{$_}
          foreach (qw/portal hiddenAttributes /);
    }

    # Configuration from MANAGER section
    if ( my $localconf = $conf->getLocalConf(MANAGERSECTION) ) {
        $args->{$_} ||= $localconf->{$_} foreach ( keys %$localconf );
    }

    # Configuration from SESSIONSEXPLORER section
    if ( my $localconfse = $conf->getLocalConf(SESSIONSEXPLORERSECTION) ) {
        $args->{$_} ||= $localconfse->{$_} foreach ( keys %$localconfse );
    }

    my $self = $class->SUPER::new($args)
      or $class->abort( 'Unable to start ' . __PACKAGE__,
        'See Apache logs for more' );

    # Local args prepends global args
    $self->{$_} = $args->{$_} foreach ( keys %$args );

    # Load default skin if no other specified
    $self->{managerSkin} ||= 'default';

    # IP field
    $self->{ipField} = "ipAddr";

    # Multi values separator
    $self->{multiValuesSeparator} ||= '; ';

    # Attributes to hide
    $self->{hiddenAttributes} = "_password"
      unless defined $self->{hiddenAttributes};

    # Now we're ready to display sessions. Choose display type:
    # case AJAX request
    if ( my ($k) = grep /^(?:uid(?:ByIp)?|session|delete|letter|id|p)$/,
        $self->param() )
    {
        print $self->header( -type => 'text/html;charset=utf-8' );
        $self->lmLog( "Ajax request: $k", 'debug' );
        print $self->$k( $self->param($k) );
        $self->quit();
    }

    # case else : store tree type choosen to use it later in tree()
    ( $self->{_tree} ) = grep /^(?:full(?:uid|ip)|ipclasses|doubleIp)$/,
      $self->param();

    # default display : list by uid
    $self->{_tree} ||= 'list';
    $self->lmLog( "Session display type: $self->{_tree}", 'debug' );

    return $self;
}

## @method string tree()
# Launch required tree builder. It can be one of :
#  * doubleIp()
#  * fullip()
#  * fulluid()
#  * ipclasses()
#  * list() (default)
# @return string XML tree
sub tree {
    my $self = shift;

    my $sub = $self->{_tree};
    $self->lmLog( "Building chosen tree: $sub", 'debug' );
    my ( $r, $legend ) = $self->$sub( $self->param($sub) );
    return
qq{$legend$r};
}

################
# TREE METHODS #
################

## @method protected string list()
# Build default tree (by letter)
# @return string XML tree
sub list {
    my $self = shift;
    my ( $byUid, $count, $res );
    $count = 0;

    # Parse all sessions to store first letter
    my $moduleOptions = $tsv->{globalStorageOptions} || {};
    $moduleOptions->{backend} = $tsv->{globalStorage};
    my $module = "Lemonldap::NG::Common::Apache::Session";
    $res =
      $module->get_key_from_all_sessions( $moduleOptions,
        [ '_httpSessionType', $tsv->{whatToTrace} ] );
    while ( my ( $id, $entry ) = each %$res ) {
        next if ( $entry->{_httpSessionType} );
        next unless $entry->{ $tsv->{whatToTrace} } =~ /^(\w)/;
        $byUid->{$1}++;
        $count++;
    }
    $res = '';

    # Build tree sorted by first letter
    foreach my $letter ( sort keys %$byUid ) {
        $res .= $self->ajaxNode(

            # ID
            "li_$letter",

            # Legend
            "$letter ($byUid->{$letter} "
              . (
                  $byUid->{$letter} == 1
                ? $self->translate('session')
                : $self->translate('sessions')
              )
              . ")",

            # Next request
            "letter=$letter"
        );
    }
    return (
        $res,
        "$count "
          . (
              $count == 1
            ? $self->translate('session')
            : $self->translate('sessions')
          )
    );
}

## @method protected string doubleIp()
# Build tree with users connected from more than 1 IP
# @return string XML tree
sub doubleIp {
    my $self = shift;
    my ( $byUid, $byIp, $res, $count );

    # Parse all sessions
    my $moduleOptions = $tsv->{globalStorageOptions} || {};
    $moduleOptions->{backend} = $tsv->{globalStorage};
    my $module = "Lemonldap::NG::Common::Apache::Session";
    $res = $module->get_key_from_all_sessions(
        $moduleOptions,
        [
            '_httpSessionType', $tsv->{whatToTrace},
            $self->{ipField},   'startTime'
        ]
    );
    while ( my ( $id, $entry ) = each %$res ) {
        next if ( $entry->{_httpSessionType} );
        push @{ $byUid->{ $entry->{ $tsv->{whatToTrace} } }
              ->{ $entry->{ $self->{ipField} } } },
          { id => $id, startTime => $entry->{startTime} };
    }
    $res = '';

    # Build tree sorted by uid (or other field chosen in whatToTrace parameter)
    foreach my $uid (
        sort { ( keys %{ $byUid->{$b} } ) <=> ( keys %{ $byUid->{$a} } ) }
        keys %$byUid
      )
    {

        # Parse only uid that are connected from more than 1 IP
        last if ( ( keys %{ $byUid->{$uid} } ) == 1 );
        $count++;

        # Build UID node with IP as sub node
        $res .= "$uid";
        foreach my $ip ( sort keys %{ $byUid->{$uid} } ) {
            $res .= "$ip";

            # For each IP node, store sessions sorted by start time
            foreach my $session ( sort { $a->{startTime} <=> $b->{startTime} }
                @{ $byUid->{$uid}->{$ip} } )
            {
                $res .=
"{id}\">{id}');\">"
                  . $self->_stToStr( $session->{startTime} )
                  . "";
            }
            $res .= "";
        }
        $res .= "";
    }

    return (
        $res,
        "$count "
          . (
              $count == 1
            ? $self->translate('user')
            : $self->translate('users')
          )
    );
}

## @method protected string fullip(string req)
# Build single IP tree
# @param $req Optional IP request (127* for example)
# @return string XML tree
sub fullip {
    my ( $self, $req ) = splice @_;
    my ( $byUid, $res );

    # Parse sessions and store only if IP match regexp
    my $moduleOptions = $tsv->{globalStorageOptions} || {};
    $moduleOptions->{backend} = $tsv->{globalStorage};
    my $module = "Lemonldap::NG::Common::Apache::Session";
    $res =
      $module->searchOnExpr( $moduleOptions, $self->{ipField}, $req,
        $tsv->{whatToTrace}, 'startTime', $self->{ipField},
        '_httpSessionType' );
    while ( my ( $id, $entry ) = each %$res ) {
        next if ( $entry->{_httpSessionType} );
        push @{ $byUid->{ $entry->{ $self->{ipField} } }
              ->{ $entry->{ $tsv->{whatToTrace} } } },
          { id => $id, startTime => $entry->{startTime} };
    }
    $res = '';

    # Build tree sorted by IP
    foreach my $ip ( sort keys %$byUid ) {
        $res .= "$ip";
        foreach my $uid ( sort keys %{ $byUid->{$ip} } ) {
            $res .= $self->ajaxNode(
                $uid,
                $uid
                  . (
                    @{ $byUid->{$ip}->{$uid} } > 1
                    ? " ("
                      . @{ $byUid->{$ip}->{$uid} }
                      . " sessions)"
                    : ''
                  ),
                "uid=$uid"
            );
        }
        $res .= "";
    }
    return $res;
}

## @method protected string fulluid(string req)
# Build single uid tree
# @param $req request (examples: foo*, foo.bar)
# @return string XML tree
sub fulluid {
    my ( $self, $req ) = splice @_;
    my ( $byUid, $res );

    # Parse sessions to find user that match regexp
    my $moduleOptions = $tsv->{globalStorageOptions} || {};
    $moduleOptions->{backend} = $tsv->{globalStorage};
    my $module = "Lemonldap::NG::Common::Apache::Session";
    $res = $module->searchOnExpr(
        $moduleOptions, $tsv->{whatToTrace},
        $req,           $tsv->{whatToTrace},
        'startTime',    '_httpSessionType'
    );
    while ( my ( $id, $entry ) = each %$res ) {
        next if ( $entry->{_httpSessionType} );
        push @{ $byUid->{ $entry->{ $tsv->{whatToTrace} } } },
          { id => $id, startTime => $entry->{startTime} };
    }
    $res = '';

    # Build tree sorted by uid
    $res .= "$req";
    foreach my $uid ( sort keys %$byUid ) {
        $res .= $self->ajaxNode(
            $uid,
            $uid
              . (
                @{ $byUid->{$uid} } > 1
                ? " ("
                  . @{ $byUid->{$uid} }
                  . " sessions)"
                : ''
              ),
            "uid=$uid"
        );
    }
    $res .= "";
}

## @method protected string ipclasses()
# Build IP classes tree (call _ipclasses())
# @return string XML tree
sub ipclasses {
    my $self = shift;
    return $self->_ipclasses();
}

##################
# AJAX RESPONSES #
##################

## @method protected string delete(string id)
# Delete a session
# @param id Session identifier
# @return string XML tree
sub delete {
    my ( $self, $id ) = splice @_;
    my ( %h, $res );

    # Try to read session
    my $apacheSession = Lemonldap::NG::Common::Session->new(
        {
            storageModule        => $tsv->{globalStorage},
            storageModuleOptions => $tsv->{globalStorageOptions},
            cacheModule          => $tsv->{localSessionStorage},
            cacheModuleOptions   => $tsv->{localSessionStorageOptions},
            id                   => $id,
            kind                 => "SSO",
        }
    );

    if ( $apacheSession->error ) {
        $self->lmLog( "Unable to open session $id", 'error' );
        $self->lmLog( $apacheSession->error,        'error' );
        $res .= ''
          . $self->translate('error') . '';
        $res .= '';
        $res .= "Apache::Session error";
        $res .= '';
        return $res;
    }

    else {

        if ( my $id2 = $apacheSession->data->{_httpSession} ) {
            my $apacheSession2 = Lemonldap::NG::Common::Session->new(
                {
                    storageModule        => $tsv->{globalStorage},
                    storageModuleOptions => $tsv->{globalStorageOptions},
                    cacheModule          => $tsv->{localSessionStorage},
                    cacheModuleOptions   => $tsv->{localSessionStorageOptions},
                    id                   => $id2,
                    kind                 => "SSO",
                }
            );

            if ( $apacheSession2->data ) {
                unless ( $apacheSession2->remove ) {
                    $self->lmLog( "Unable to remove session $id2", 'error' );
                    $self->lmLog( $apacheSession2->error,          'error' );
                }
            }
            else {
                $self->lmLog( "Unable to open session $id2", 'error' );
                $self->lmLog( $apacheSession2->error,        'error' );
            }
        }

        if ( $apacheSession->remove ) {
            $self->lmLog( "Session $id deleted", 'info' );
            $res .= ''
              . $self->translate('sessionDeleted') . '';
        }
        else {
            $self->lmLog( "Unable to remove session $id", 'error' );
            $self->lmLog( $apacheSession->error,          'error' );
            $res .= ''
              . $self->translate('error') . '';
            $res .= '';
            $res .= "Apache::Session error";
            $res .= '';
        }
        return $res;
    }
}

## @method protected string session()
# Build session dump.
# @return string XML tree
sub session {
    my ( $self, $id ) = splice @_;
    my ( %h, $res );

    # Try to read session
    my $apacheSession = Lemonldap::NG::Common::Session->new(
        {
            storageModule        => $tsv->{globalStorage},
            storageModuleOptions => $tsv->{globalStorageOptions},
            cacheModule          => $tsv->{localSessionStorage},
            cacheModuleOptions   => $tsv->{localSessionStorageOptions},
            id                   => $id,
            kind                 => "SSO",
        }
    );

    if ( $apacheSession->error ) {
        $self->lmLog( "Unable to open session $id", 'error' );
        $self->lmLog( $apacheSession->error,        'error' );
        $res .= ''
          . $self->translate('error') . '';
        $res .= '';
        $res .= "Apache::Session error";
        $res .= '';
        return $res;
    }

    # Session is available, print content
    my %session = %{ $apacheSession->data };

    # General informations

    $res .= '';
    $res .= $self->translate('sessionTitle');
    $res .= '';

    $res .=
        ""
      . $self->translate('sessionStartedAt')
      . ": "
      . $self->_stToStr( $session{startTime} ) . "";

    # Transform values
    # -> split multiple values
    # -> decode UTF8
    # -> Manage dates
    # -> Hide password
    # -> quote HTML
    foreach ( keys %session ) {

        # Don't touch references
        next if ref $session{$_};

        # Remove empty value
        delete $session{$_} unless ( length $session{$_} );

        # Quote HTML
        my $value = htmlquote( $session{$_} );

        # Values in sessions are UTF8
        utf8::decode($value);

        # Multiple values
        if ( $value =~ m/$self->{multiValuesSeparator}/ ) {
            my $newvalue = '';
            $newvalue .= "$_"
              foreach ( split( $self->{multiValuesSeparator}, $value ) );
            $newvalue .= '';
            $value = $newvalue;
        }

        # Hide attributes
        $value = '****' if ( $self->{hiddenAttributes} =~ /\b$_\b/ );

        # Manage timestamp
        if ( $_ =~ /^(_utime|_lastAuthnUTime)$/ ) {
            $value = "$value (" . localtime($value) . ")";
        }

        # Manage dates
        if ( $_ =~ /^(startTime|updateTime)$/ ) {
            $value = "$value (" . $self->_stToStr($value) . ")";
        }

        # Register value
        $session{$_} = $value;
    }

    # Map attributes to categories
    my $categories = {
        'dateTitle'       => [qw(_utime startTime updateTime _lastAuthnUTime)],
        'connectionTitle' => [qw(ipAddr _timezone _url)],
        'authenticationTitle' =>
          [qw(_session_id _user _password authenticationLevel)],
        'modulesTitle' => [qw(_auth _userDB _passwordDB _issuerDB _authChoice)],
        'saml'         => [
            qw(_idp _idpConfKey _samlToken _lassoSessionDump _lassoIdentityDump)
        ],
        'groups'    => [qw(groups)],
        'ldap'      => [qw(dn)],
        'BrowserID' => [qw(_browserIdAnswer _browserIdAnswerRaw)],
    };

    # Display categories
    foreach my $category ( keys %$categories ) {

        # Test if category is not empty
        my $empty = 1;
        foreach ( @{ $categories->{$category} } ) {
            $empty = 0 if exists $session{$_};
        }
        next if ($empty);

        # Display category
        $res .= '';
        $res .= ''
          . $self->translate($category) . '';
        $res .= '';

        foreach my $attribute ( @{ $categories->{$category} } ) {

            # Hide empty attributes
            next unless exists $session{$attribute};

            # Display attribute
            $res .=
                ''
              . $self->translate($attribute)
              . ' ($'
              . $attribute
              . '): '
              . $session{$attribute} . '';

            # Delete attribute, to hide it
            delete $session{$attribute};
        }
        $res .= '';
        $res .= '';
    }

    # OpenID
    my $openidempty = 1;
    foreach ( keys %session ) {
        $openidempty = 0 if $_ =~ /^_openid/;
    }
    unless ($openidempty) {
        $res .= '';
        $res .=
          '' . 'OpenID' . '';
        $res .= '';

        foreach ( keys %session ) {
            next if $_ !~ /^_openid/;
            $res .=
              '' . $_ . ': ' . $session{$_} . '';

            # Delete attribute, to hide it
            delete $session{$_};
        }

        $res .= '';
        $res .= '';
    }

    # Notifications
    my $notifempty = 1;
    foreach ( keys %session ) {
        $notifempty = 0 if $_ =~ /^notification_/;
    }
    unless ($notifempty) {
        $res .= '';
        $res .= ''
          . ucfirst $self->translate('notificationsDone') . '';
        $res .= '';

        foreach ( keys %session ) {
            next if $_ !~ /^notification_(.+)/;
            $res .=
                ''
              . $1
              . ': '
              . $session{$_} . " ("
              . localtime( $session{$_} ) . ")";

            # Delete attribute, to hide it
            delete $session{$_};
        }

        $res .= '';
        $res .= '';
    }

    # Login history
    if ( defined $session{loginHistory} ) {
        $res .= '';
        $res .= ''
          . ucfirst $self->translate('loginHistory') . '';
        $res .= '';

        # Get all login records
        my $loginRecords = {};

        if ( defined $session{loginHistory}->{successLogin} ) {
            foreach ( @{ $session{loginHistory}->{successLogin} } ) {
                $loginRecords->{ $_->{_utime} } =
                  "Success (IP " . $_->{ipAddr} . ")";
            }
        }

        if ( defined $session{loginHistory}->{failedLogin} ) {
            foreach ( @{ $session{loginHistory}->{failedLogin} } ) {
                $loginRecords->{ $_->{_utime} } =
                  $_->{error} . " (IP " . $_->{ipAddr} . ")";
            }
        }

        # Display records sorted by date
        foreach my $utime ( sort keys %{$loginRecords} ) {

            $res .=
                ""
              . localtime($utime)
              . ": "
              . $loginRecords->{$utime} . "";
        }

        delete $session{loginHistory};
        $res .= '';
        $res .= '';
    }

    # Other attributes
    $res .= '';
    $res .= ''
      . $self->translate('attributesAndMacros') . '';
    $res .= '';

    foreach my $attribute (
        sort {
            return $a cmp $b
              if ( ( $a =~ /^_/ and $b =~ /^_/ )
                or ( $a !~ /^_/ and $b !~ /^_/ ) );
            return $b cmp $a
        } keys %session
      )
    {

        # Display attribute
        $res .=
            ''
          . $attribute
          . ': '
          . $session{$attribute} . '';
    }

    $res .= '';
    $res .= '';

    # Delete button
    $res .= '';
    $res .=
        "
      . ' class="ui-state-default ui-corner-all"'
      . " value=\""
      . $self->translate('deleteSession') . "\" />";
    $res .= '';

    return $res;
}

## @method protected string uidByIp()
# Build single IP tree
# @return string XML tree
sub uidByIp {
    my ( $self, $ip ) = splice @_;
    my ( $byUser, $res );

    my $moduleOptions = $tsv->{globalStorageOptions} || {};
    $moduleOptions->{backend} = $tsv->{globalStorage};
    my $module = "Lemonldap::NG::Common::Apache::Session";
    $res =
      $module->searchOn( $moduleOptions, $self->{ipField}, $ip,
        '_httpSessionType', $tsv->{whatToTrace}, $self->{ipField},
        'startTime' );
    while ( my ( $id, $entry ) = each(%$res) ) {
        next if ( $entry->{_httpSessionType} );
        if ( $entry->{ $self->{ipField} } eq $ip ) {
            push @{ $byUser->{ $entry->{ $tsv->{whatToTrace} } } },
              { id => $id, startTime => $entry->{startTime} };
        }
    }
    $res = '';
    foreach my $user ( sort keys %$byUser ) {
        $res .= "$user";
        foreach my $session ( sort { $a->{startTime} <=> $b->{startTime} }
            @{ $byUser->{$user} } )
        {
            $res .=
"{id}\">{id}');\">"
              . $self->_stToStr( $session->{startTime} )
              . "";
        }
        $res .= "";
    }
    return $res;
}

## @method protected string uid()
# Build single UID tree part
# @return string XML tree
sub uid {
    my ( $self, $uid ) = splice @_;
    my ( $byIp, $res );

    my $moduleOptions = $tsv->{globalStorageOptions} || {};
    $moduleOptions->{backend} = $tsv->{globalStorage};
    my $module = "Lemonldap::NG::Common::Apache::Session";
    $res =
      $module->searchOn( $moduleOptions, $tsv->{whatToTrace}, $uid,
        '_httpSessionType', $tsv->{whatToTrace}, $self->{ipField},
        'startTime' );
    while ( my ( $id, $entry ) = each(%$res) ) {
        next if ( $entry->{_httpSessionType} );
        if ( $entry->{ $tsv->{whatToTrace} } eq $uid ) {
            push @{ $byIp->{ $entry->{ $self->{ipField} } } },
              { id => $id, startTime => $entry->{startTime} };
        }
    }
    $res = '';
    foreach my $ip ( sort keys %$byIp ) {
        $res .= "$ip";
        foreach my $session ( sort { $a->{startTime} <=> $b->{startTime} }
            @{ $byIp->{$ip} } )
        {
            $res .=
"{id}\">{id}');\">"
              . $self->_stToStr( $session->{startTime} )
              . "";
        }
        $res .= "";
    }
    return $res;
}

# Ajax request to list users starting by a letter
## @method protected string letter()
# Build letter XML part
# @return string XML tree
sub letter {
    my $self   = shift;
    my $letter = $self->param('letter');
    my ( $byUid, $res );

    my $moduleOptions = $tsv->{globalStorageOptions} || {};
    $moduleOptions->{backend} = $tsv->{globalStorage};
    my $module = "Lemonldap::NG::Common::Apache::Session";
    $res = $module->searchOnExpr(
        $moduleOptions, $tsv->{whatToTrace},
        "${letter}*",   '_httpSessionType',
        $tsv->{whatToTrace}
    );
    while ( my ( $id, $entry ) = each %$res ) {
        next if ( $entry->{_httpSessionType} );
        $byUid->{ $entry->{ $tsv->{whatToTrace} } }++;
    }
    $res = '';
    foreach my $uid ( sort keys %$byUid ) {
        $res .= $self->ajaxNode(
            $uid,
            $uid
              . (
                $byUid->{$uid} > 1
                ? " ($byUid->{$uid} "
                  . (
                      $byUid->{$uid} == 1
                    ? $self->translate('session')
                    : $self->translate('sessions')
                  )
                  . ")"
                : ''
              ),
            "uid=$uid"
        );
    }
    return $res;
}

## @method protected string p()
# Build IP classes sub tree (call _ipclasses())
# @return string XML tree
sub p {
    my $self = shift;
    my @t    = $self->_ipclasses(@_);
    return $t[0];
}

## @method private string _ipclasses()
# Build IP classes (sub) tree
# @return string XML tree
sub _ipclasses {
    my ( $self, $p ) = splice @_;
    my $partial = $p ? "$p." : '';
    my $repartial = quotemeta($partial);
    my ( $byIp, $count, $res );

    my $moduleOptions = $tsv->{globalStorageOptions} || {};
    $moduleOptions->{backend} = $tsv->{globalStorage};
    my $module = "Lemonldap::NG::Common::Apache::Session";
    $res = $module->searchOnExpr(
        $moduleOptions, $self->{ipField},
        "${partial}*",  '_httpSessionType',
        $self->{ipField}
    );

    while ( my ( $id, $entry ) = each %$res ) {
        next if ( $entry->{_httpSessionType} );
        $entry->{ $self->{ipField} } =~ /^$repartial(\d+)/ or next;
        $byIp->{$1}++;
        $count++;
    }
    $res = '';
    foreach my $ip ( sort { $a <=> $b } keys %$byIp ) {
        $res .= $self->ajaxNode(
            "$partial$ip",
            "$partial$ip ($byIp->{$ip} "
              . (
                  $byIp->{$ip} == 1 ? $self->translate('session')
                : $self->translate('sessions')
              )
              . ")",
            (
                $partial !~ /^\d+\.\d+\.\d+/ ? "ipclasses=1&p=$partial$ip"
                : "uidByIp=$partial$ip"
            )
        );
    }
    return (
        $res,
        "$count "
          . (
              $count == 1
            ? $self->translate('session')
            : $self->translate('sessions')
          )
    );

    #return $res;
}

## @fn protected string htmlquote(string s)
# Change <, > and & to HTML encoded values in the string
# @param $s HTML string
# @return HTML string
sub htmlquote {
    my $s = shift;
    $s =~ s/&/&/g;
    $s =~ s/
    $s =~ s/>/>/g;
    return $s;
}

## @method private void ajaxnode(string id, string text, string param)
# Display tree node with Ajax functions inside for opening the node.
# @param $id HTML id of the element.
# @param $text text to display
# @param $param Parameters for the Ajax query
sub ajaxNode {
    my ( $self, $id, $text, $param ) = @_;
    return
"$text\n{url:$ENV{SCRIPT_NAME}?$param}\n";
}

## @method private string _stToStr(string)
# Transform a utime string into readeable string (ex: "2010-08-18 13:03:13")
# @return Formated string
sub _stToStr {
    shift;
    return
      sprintf( '%d-%02d-%02d %d:%02d:%02d', unpack( 'a4a2a2a2a2a2', shift ) );
}

1;
__END__