javonet-nodejs-sdk 2.1.1 → 2.1.2

package/Binaries/Perl/Linux/X64/deps/lib/perl5/LWP/Authen/Ntlm.pm

@@ -1,183 +0,0 @@
-package LWP::Authen::Ntlm;
-
-use strict;
-
-our $VERSION = '6.68';
-
-use Authen::NTLM "1.02";
-use MIME::Base64 "2.12";
-
-sub authenticate {
-    my($class, $ua, $proxy, $auth_param, $response,
-       $request, $arg, $size) = @_;
-
-    my($user, $pass) = $ua->get_basic_credentials($auth_param->{realm},
-                                                  $request->uri, $proxy);
-
-    unless(defined $user and defined $pass) {
-		return $response;
-	}
-
-	if (!$ua->conn_cache()) {
-		warn "The keep_alive option must be enabled for NTLM authentication to work.  NTLM authentication aborted.\n";
-		return $response;
-	}
-
-	my($domain, $username) = split(/\\/, $user);
-
-	ntlm_domain($domain);
-	ntlm_user($username);
-	ntlm_password($pass);
-
-    my $auth_header = $proxy ? "Proxy-Authorization" : "Authorization";
-
-	# my ($challenge) = $response->header('WWW-Authenticate');
-	my $challenge;
-	foreach ($response->header('WWW-Authenticate')) {
-		last if /^NTLM/ && ($challenge=$_);
-	}
-
-	if ($challenge eq 'NTLM') {
-		# First phase, send handshake
-	    my $auth_value = "NTLM " . ntlm();
-		ntlm_reset();
-
-	    # Need to check this isn't a repeated fail!
-	    my $r = $response;
-		my $retry_count = 0;
-	    while ($r) {
-			my $auth = $r->request->header($auth_header);
-			++$retry_count if ($auth && $auth eq $auth_value);
-			if ($retry_count > 2) {
-				    # here we know this failed before
-				    $response->header("Client-Warning" =>
-						      "Credentials for '$user' failed before");
-				    return $response;
-			}
-			$r = $r->previous;
-	    }
-
-	    my $referral = $request->clone;
-	    $referral->header($auth_header => $auth_value);
-	    return $ua->request($referral, $arg, $size, $response);
-	}
-
-	else {
-		# Second phase, use the response challenge (unless non-401 code
-		#  was returned, in which case, we just send back the response
-		#  object, as is
-		my $auth_value;
-		if ($response->code ne '401') {
-			return $response;
-		}
-		else {
-			my $challenge;
-			foreach ($response->header('WWW-Authenticate')) {
-				last if /^NTLM/ && ($challenge=$_);
-			}
-			$challenge =~ s/^NTLM //;
-			ntlm();
-			$auth_value = "NTLM " . ntlm($challenge);
-			ntlm_reset();
-		}
-
-	    my $referral = $request->clone;
-	    $referral->header($auth_header => $auth_value);
-	    my $response2 = $ua->request($referral, $arg, $size, $response);
-		return $response2;
-	}
-}
-
-1;
-__END__
-
-=pod
-
-=head1 NAME
-
-LWP::Authen::Ntlm - Library for enabling NTLM authentication (Microsoft) in LWP
-
-=head1 SYNOPSIS
-
- use LWP::UserAgent;
- use HTTP::Request::Common;
- my $url = 'http://www.company.com/protected_page.html';
-
- # Set up the ntlm client and then the base64 encoded ntlm handshake message
- my $ua = LWP::UserAgent->new(keep_alive=>1);
- $ua->credentials('www.company.com:80', '', "MyDomain\\MyUserCode", 'MyPassword');
-
- $request = GET $url;
- print "--Performing request now...-----------\n";
- $response = $ua->request($request);
- print "--Done with request-------------------\n";
-
- if ($response->is_success) {print "It worked!->" . $response->code . "\n"}
- else {print "It didn't work!->" . $response->code . "\n"}
-
-=head1 DESCRIPTION
-
-L<LWP::Authen::Ntlm> allows LWP to authenticate against servers that are using the
-NTLM authentication scheme popularized by Microsoft.  This type of authentication is
-common on intranets of Microsoft-centric organizations.
-
-The module takes advantage of the Authen::NTLM module by Mark Bush.  Since there
-is also another Authen::NTLM module available from CPAN by Yee Man Chan with an
-entirely different interface, it is necessary to ensure that you have the correct
-NTLM module.
-
-In addition, there have been problems with incompatibilities between different
-versions of L<Mime::Base64>, which Bush's L<Authen::NTLM> makes use of.  Therefore, it is
-necessary to ensure that your Mime::Base64 module supports exporting of the
-C<encode_base64> and C<decode_base64> functions.
-
-=head1 USAGE
-
-The module is used indirectly through LWP, rather than including it directly in your
-code.  The LWP system will invoke the NTLM authentication when it encounters the
-authentication scheme while attempting to retrieve a URL from a server.  In order
-for the NTLM authentication to work, you must have a few things set up in your
-code prior to attempting to retrieve the URL:
-
-=over 4
-
-=item *
-
-Enable persistent HTTP connections
-
-To do this, pass the C<< "keep_alive=>1" >> option to the L<LWP::UserAgent> when creating it, like this:
-
-    my $ua = LWP::UserAgent->new(keep_alive=>1);
-
-=item *
-
-Set the credentials on the UserAgent object
-
-The credentials must be set like this:
-
-   $ua->credentials('www.company.com:80', '', "MyDomain\\MyUserCode", 'MyPassword');
-
-Note that you cannot use the L<HTTP::Request> object's C<authorization_basic()> method to set
-the credentials.  Note, too, that the C<'www.company.com:80'> portion only sets credentials
-on the specified port AND it is case-sensitive (this is due to the way LWP is coded, and
-has nothing to do with LWP::Authen::Ntlm)
-
-=back
-
-=head1 AVAILABILITY
-
-General queries regarding LWP should be made to the LWP Mailing List.
-
-Questions specific to LWP::Authen::Ntlm can be forwarded to jtillman@bigfoot.com
-
-=head1 COPYRIGHT
-
-Copyright (c) 2002 James Tillman. All rights reserved. This
-program is free software; you can redistribute it and/or modify it
-under the same terms as Perl itself.
-
-=head1 SEE ALSO
-
-L<LWP>, L<LWP::UserAgent>, L<lwpcook>.
-
-=cut

package/Binaries/Perl/Linux/X64/deps/lib/perl5/LWP/ConnCache.pm

@@ -1,350 +0,0 @@
-package LWP::ConnCache;
-
-use strict;
-
-our $VERSION = '6.68';
-our $DEBUG;
-
-sub new {
-    my($class, %cnf) = @_;
-
-    my $total_capacity = 1;
-    if (exists $cnf{total_capacity}) {
-        $total_capacity = delete $cnf{total_capacity};
-    }
-    if (%cnf && $^W) {
-	require Carp;
-	Carp::carp("Unrecognised options: @{[sort keys %cnf]}")
-    }
-    my $self = bless { cc_conns => [] }, $class;
-    $self->total_capacity($total_capacity);
-    $self;
-}
-
-
-sub deposit {
-    my($self, $type, $key, $conn) = @_;
-    push(@{$self->{cc_conns}}, [$conn, $type, $key, time]);
-    $self->enforce_limits($type);
-    return;
-}
-
-
-sub withdraw {
-    my($self, $type, $key) = @_;
-    my $conns = $self->{cc_conns};
-    for my $i (0 .. @$conns - 1) {
-	my $c = $conns->[$i];
-	next unless $c->[1] eq $type && $c->[2] eq $key;
-	splice(@$conns, $i, 1);  # remove it
-	return $c->[0];
-    }
-    return undef;
-}
-
-
-sub total_capacity {
-    my $self = shift;
-    my $old = $self->{cc_limit_total};
-    if (@_) {
-	$self->{cc_limit_total} = shift;
-	$self->enforce_limits;
-    }
-    $old;
-}
-
-
-sub capacity {
-    my $self = shift;
-    my $type = shift;
-    my $old = $self->{cc_limit}{$type};
-    if (@_) {
-	$self->{cc_limit}{$type} = shift;
-	$self->enforce_limits($type);
-    }
-    $old;
-}
-
-
-sub enforce_limits {
-    my($self, $type) = @_;
-    my $conns = $self->{cc_conns};
-
-    my @types = $type ? ($type) : ($self->get_types);
-    for $type (@types) {
-	next unless $self->{cc_limit};
-	my $limit = $self->{cc_limit}{$type};
-	next unless defined $limit;
-	for my $i (reverse 0 .. @$conns - 1) {
-	    next unless $conns->[$i][1] eq $type;
-	    if (--$limit < 0) {
-		$self->dropping(splice(@$conns, $i, 1), "$type capacity exceeded");
-	    }
-	}
-    }
-
-    if (defined(my $total = $self->{cc_limit_total})) {
-	while (@$conns > $total) {
-	    $self->dropping(shift(@$conns), "Total capacity exceeded");
-	}
-    }
-}
-
-
-sub dropping {
-    my($self, $c, $reason) = @_;
-    print "DROPPING @$c [$reason]\n" if $DEBUG;
-}
-
-
-sub drop {
-    my($self, $checker, $reason) = @_;
-    if (ref($checker) ne "CODE") {
-	# make it so
-	if (!defined $checker) {
-	    $checker = sub { 1 };  # drop all of them
-	}
-	elsif (_looks_like_number($checker)) {
-	    my $age_limit = $checker;
-	    my $time_limit = time - $age_limit;
-	    $reason ||= "older than $age_limit";
-	    $checker = sub { $_[3] < $time_limit };
-	}
-	else {
-	    my $type = $checker;
-	    $reason ||= "drop $type";
-	    $checker = sub { $_[1] eq $type };  # match on type
-	}
-    }
-    $reason ||= "drop";
-
-    local $SIG{__DIE__};  # don't interfere with eval below
-    local $@;
-    my @c;
-    for (@{$self->{cc_conns}}) {
-	my $drop;
-	eval {
-	    if (&$checker(@$_)) {
-		$self->dropping($_, $reason);
-		$drop++;
-	    }
-	};
-	push(@c, $_) unless $drop;
-    }
-    @{$self->{cc_conns}} = @c;
-}
-
-
-sub prune {
-    my $self = shift;
-    $self->drop(sub { !shift->ping }, "ping");
-}
-
-
-sub get_types {
-    my $self = shift;
-    my %t;
-    $t{$_->[1]}++ for @{$self->{cc_conns}};
-    return keys %t;
-}
-
-
-sub get_connections {
-    my($self, $type) = @_;
-    my @c;
-    for (@{$self->{cc_conns}}) {
-	push(@c, $_->[0]) if !$type || ($type && $type eq $_->[1]);
-    }
-    @c;
-}
-
-
-sub _looks_like_number {
-    $_[0] =~ /^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/;
-}
-
-1;
-
-
-__END__
-
-=pod
-
-=head1 NAME
-
-LWP::ConnCache - Connection cache manager
-
-=head1 NOTE
-
-This module is experimental.  Details of its interface is likely to
-change in the future.
-
-=head1 SYNOPSIS
-
- use LWP::ConnCache;
- my $cache = LWP::ConnCache->new;
- $cache->deposit($type, $key, $sock);
- $sock = $cache->withdraw($type, $key);
-
-=head1 DESCRIPTION
-
-The C<LWP::ConnCache> class is the standard connection cache manager
-for L<LWP::UserAgent>.
-
-=head1 METHODS
-
-The following basic methods are provided:
-
-=head2 new
-
-    my $cache = LWP::ConnCache->new( %options )
-
-This method constructs a new L<LWP::ConnCache> object.  The only
-option currently accepted is C<total_capacity>.  If specified it
-initializes the L<LWP::ConnCache/total_capacity> option. It defaults to C<1>.
-
-=head2 total_capacity
-
-    my $cap = $cache->total_capacity;
-    $cache->total_capacity(0); # drop all immediately
-    $cache->total_capacity(undef); # no limit
-    $cache->total_capacity($number);
-
-Get/sets the number of connection that will be cached.  Connections
-will start to be dropped when this limit is reached.  If set to C<0>,
-then all connections are immediately dropped.  If set to C<undef>,
-then there is no limit.
-
-=head2 capacity
-
-    my $http_capacity = $cache->capacity('http');
-    $cache->capacity('http', 2 );
-
-Get/set a limit for the number of connections of the specified type
-that can be cached.  The first parameter is a short string like
-C<"http"> or C<"ftp">.
-
-=head2 drop
-
-    $cache->drop(); # Drop ALL connections
-    # which is just a synonym for:
-    $cache->drop(sub{1}); # Drop ALL connections
-    # drop all connections older than 22 seconds and add a reason for it!
-    $cache->drop(22, "Older than 22 secs dropped");
-    # which is just a synonym for:
-    $cache->drop(sub {
-        my ($conn, $type, $key, $deposit_time) = @_;
-        if ($deposit_time < 22) {
-            # true values drop the connection
-            return 1;
-        }
-        # false values don't drop the connection
-        return 0;
-    }, "Older than 22 secs dropped" );
-
-Drop connections by some criteria.  The $checker argument is a
-subroutine that is called for each connection.  If the routine returns
-a TRUE value then the connection is dropped.  The routine is called
-with C<($conn, $type, $key, $deposit_time)> as arguments.
-
-Shortcuts: If the C<$checker> argument is absent (or C<undef>) all cached
-connections are dropped.  If the $checker is a number then all
-connections untouched that the given number of seconds or more are
-dropped.  If $checker is a string then all connections of the given
-type are dropped.
-
-The C<reason> is passed on to the L<LWP::ConnCache/dropped> method.
-
-=head2 prune
-
-    $cache->prune();
-
-Calling this method will drop all connections that are dead.  This is
-tested by calling the L<LWP::ConnCache/ping> method on the connections. If
-the L<LWP::ConnCache/ping> method exists and returns a false value, then the
-connection is dropped.
-
-=head2 get_types
-
-    my @types = $cache->get_types();
-
-This returns all the C<type> fields used for the currently cached
-connections.
-
-=head2 get_connections
-
-    my @conns = $cache->get_connections(); # all connections
-    my @conns = $cache->get_connections('http'); # connections for http
-
-This returns all connection objects of the specified type.  If no type
-is specified then all connections are returned.  In scalar context the
-number of cached connections of the specified type is returned.
-
-=head1 PROTOCOL METHODS
-
-The following methods are called by low-level protocol modules to
-try to save away connections and to get them back.
-
-=head2 deposit
-
-    $cache->deposit($type, $key, $conn);
-
-This method adds a new connection to the cache.  As a result, other
-already cached connections might be dropped.  Multiple connections with
-the same type/key might be added.
-
-=head2 withdraw
-
-    my $conn = $cache->withdraw($type, $key);
-
-This method tries to fetch back a connection that was previously
-deposited.  If no cached connection with the specified $type/$key is
-found, then C<undef> is returned.  There is not guarantee that a
-deposited connection can be withdrawn, as the cache manger is free to
-drop connections at any time.
-
-=head1 INTERNAL METHODS
-
-The following methods are called internally.  Subclasses might want to
-override them.
-
-=head2 enforce_limits
-
-    $conn->enforce_limits([$type])
-
-This method is called with after a new connection is added (deposited)
-in the cache or capacity limits are adjusted.  The default
-implementation drops connections until the specified capacity limits
-are not exceeded.
-
-=head2 dropping
-
-    $conn->dropping($conn_record, $reason)
-
-This method is called when a connection is dropped.  The record
-belonging to the dropped connection is passed as the first argument
-and a string describing the reason for the drop is passed as the
-second argument.  The default implementation makes some noise if the
-C<$LWP::ConnCache::DEBUG> variable is set and nothing more.
-
-=head1 SUBCLASSING
-
-For specialized cache policy it makes sense to subclass
-C<LWP::ConnCache> and perhaps override the L<LWP::ConnCache/deposit>,
-L<LWP::ConnCache/enforce_limits>, and L<LWP::ConnCache/dropping> methods.
-
-The object itself is a hash.  Keys prefixed with C<cc_> are reserved
-for the base class.
-
-=head1 SEE ALSO
-
-L<LWP::UserAgent>
-
-=head1 COPYRIGHT
-
-Copyright 2001 Gisle Aas.
-
-This library is free software; you can redistribute it and/or
-modify it under the same terms as Perl itself.
-
-=cut

package/Binaries/Perl/Linux/X64/deps/lib/perl5/LWP/Debug/TraceHTTP.pm

@@ -1,29 +0,0 @@
-package LWP::Debug::TraceHTTP;
-
-# Just call:
-#
-#   require LWP::Debug::TraceHTTP;
-#   LWP::Protocol::implementor('http', 'LWP::Debug::TraceHTTP');
-#
-# to use this module to trace all calls to the HTTP socket object in
-# programs that use LWP.
-
-use strict;
-use parent 'LWP::Protocol::http';
-
-our $VERSION = '6.68';
-
-package # hide from PAUSE
-    LWP::Debug::TraceHTTP::Socket;
-
-use Data::Dump 1.13;
-use Data::Dump::Trace qw(autowrap mcall);
-
-autowrap("LWP::Protocol::http::Socket" => "sock");
-
-sub new {
-    my $class = shift;
-    return mcall("LWP::Protocol::http::Socket" => "new", undef, @_);
-}
-
-1;

package/Binaries/Perl/Linux/X64/deps/lib/perl5/LWP/Debug.pm

@@ -1,112 +0,0 @@
-package LWP::Debug;    # legacy
-
-our $VERSION = '6.68';
-
-require Exporter;
-our @ISA       = qw(Exporter);
-our @EXPORT_OK = qw(level trace debug conns);
-
-use Carp ();
-
-my @levels = qw(trace debug conns);
-our %current_level = ();
-
-sub import {
-    my $pack    = shift;
-    my $callpkg = caller(0);
-    my @symbols = ();
-    my @levels  = ();
-    for (@_) {
-        if (/^[-+]/) {
-            push(@levels, $_);
-        }
-        else {
-            push(@symbols, $_);
-        }
-    }
-    Exporter::export($pack, $callpkg, @symbols);
-    level(@levels);
-}
-
-sub level {
-    for (@_) {
-        if ($_ eq '+') {    # all on
-                            # switch on all levels
-            %current_level = map { $_ => 1 } @levels;
-        }
-        elsif ($_ eq '-') {    # all off
-            %current_level = ();
-        }
-        elsif (/^([-+])(\w+)$/) {
-            $current_level{$2} = $1 eq '+';
-        }
-        else {
-            Carp::croak("Illegal level format $_");
-        }
-    }
-}
-
-sub trace { _log(@_) if $current_level{'trace'}; }
-sub debug { _log(@_) if $current_level{'debug'}; }
-sub conns { _log(@_) if $current_level{'conns'}; }
-
-sub _log {
-    my $msg = shift;
-    $msg .= "\n" unless $msg =~ /\n$/;    # ensure trailing "\n"
-
-    my ($package, $filename, $line, $sub) = caller(2);
-    print STDERR "$sub: $msg";
-}
-
-1;
-
-__END__
-
-=pod
-
-=head1 NAME
-
-LWP::Debug - deprecated
-
-=head1 DESCRIPTION
-
-This module has been deprecated.  Please see L<LWP::ConsoleLogger> for your
-debugging needs.
-
-LWP::Debug is used to provide tracing facilities, but these are not used
-by LWP any more.  The code in this module is kept around
-(undocumented) so that 3rd party code that happens to use the old
-interfaces continue to run.
-
-One useful feature that LWP::Debug provided (in an imprecise and
-troublesome way) was network traffic monitoring.  The following
-section provides some hints about recommended replacements.
-
-=head2 Network traffic monitoring
-
-The best way to monitor the network traffic that LWP generates is to
-use an external TCP monitoring program.  The
-L<WireShark|http://www.wireshark.org/> program is highly recommended for this.
-
-Another approach it to use a debugging HTTP proxy server and make
-LWP direct all its traffic via this one.  Call C<< $ua->proxy >> to
-set it up and then just use LWP as before.
-
-For less precise monitoring needs just setting up a few simple
-handlers might do.  The following example sets up handlers to dump the
-request and response objects that pass through LWP:
-
-  use LWP::UserAgent;
-  $ua = LWP::UserAgent->new;
-  $ua->default_header('Accept-Encoding' => scalar HTTP::Message::decodable());
-
-  $ua->add_handler("request_send",  sub { shift->dump; return });
-  $ua->add_handler("response_done", sub { shift->dump; return });
-
-  $ua->get("http://www.example.com");
-
-=head1 SEE ALSO
-
-L<LWP::ConsoleLogger>, L<LWP::ConsoleLogger::Everywhere>, L<LWP::UserAgent>
-
-=cut

package/Binaries/Perl/Linux/X64/deps/lib/perl5/LWP/DebugFile.pm

@@ -1,7 +0,0 @@
-package LWP::DebugFile;
-
-our $VERSION = '6.68';
-
-# legacy stub
-
-1;