Net-HTTPS-Any-0.10/0000755000175000017500000000000011367110760012263 5ustar ivanivanNet-HTTPS-Any-0.10/README0000644000175000017500000000203711025530725013143 0ustar ivanivanNet-HTTPS-Any This module will make an HTTPS connection using Net::SSLeay or ( Crypt::SSLeay and LWP), whatever is available on the current system. It is derived from Business::OnlinePayment::HTTPS. INSTALLATION To install this module, run the following commands: perl Makefile.PL make make test make install SUPPORT AND DOCUMENTATION After installing, you can find documentation for this module with the perldoc command. perldoc Net::HTTPS::Any You can also look for information at: RT, CPAN's request tracker http://rt.cpan.org/NoAuth/Bugs.html?Dist=Net-HTTPS-Any AnnoCPAN, Annotated CPAN documentation http://annocpan.org/dist/Net-HTTPS-Any CPAN Ratings http://cpanratings.perl.org/d/Net-HTTPS-Any Search CPAN http://search.cpan.org/dist/Net-HTTPS-Any COPYRIGHT AND LICENCE Copyright (C) 2008 Freeside Internet Services, Inc. (http://freeside.biz) All rights reserved. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. Net-HTTPS-Any-0.10/Changes0000644000175000017500000000144011367110625013555 0ustar ivanivanRevision history for Net-HTTPS-Any 0.10 Sat May 1 13:39:39 PDT 2010 - Pull in changes from Business::OnlinePayment::HTTPS 0.09 from Business::OnlinePayment 3.00 - Default Content-Type to application/x-www-form-urlencoded - Added WHY THIS MODULE section to POD - Updated tests for new world of not returning HTTP as part of the response code - Removed meaningless Content-Type handling from https_get - Added/documented debugging option - Updated servers used for testing in examples and tests - Supress uninitialized value warnings from Net::SSLeay 0.09 unrelesed - First version numbered 0.09 (based on Business::OnlinePayment::HTTPS 0.08 from Business::OnlinePayment 3.00_08) Net-HTTPS-Any-0.10/META.yml0000644000175000017500000000120611367110760013533 0ustar ivanivan--- #YAML:1.0 name: Net-HTTPS-Any version: 0.10 abstract: Simple HTTPS class using whichever underlying SSL module is available author: - Ivan Kohler license: unknown distribution_type: module configure_requires: ExtUtils::MakeMaker: 0 build_requires: ExtUtils::MakeMaker: 0 requires: Test::More: 0 Tie::IxHash: 0 URI::Escape: 0 no_index: directory: - t - inc generated_by: ExtUtils::MakeMaker version 6.55_02 meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.4.html version: 1.4 Net-HTTPS-Any-0.10/lib/0000755000175000017500000000000011367110760013031 5ustar ivanivanNet-HTTPS-Any-0.10/lib/Net/0000755000175000017500000000000011367110760013557 5ustar ivanivanNet-HTTPS-Any-0.10/lib/Net/HTTPS/0000755000175000017500000000000011367110760014461 5ustar ivanivanNet-HTTPS-Any-0.10/lib/Net/HTTPS/Any.pm0000644000175000017500000002440511367110356015554 0ustar ivanivanpackage Net::HTTPS::Any; use warnings; use strict; use base qw( Exporter ); use vars qw(@EXPORT_OK $ssl_module $skip_NetSSLeay); use URI::Escape; use Tie::IxHash; @EXPORT_OK = qw( https_get https_post ); BEGIN { $ssl_module = ''; eval { die if defined($skip_NetSSLeay) && $skip_NetSSLeay; require Net::SSLeay; Net::SSLeay->VERSION(1.30); #import Net::SSLeay # qw(get_https post_https make_form make_headers); $ssl_module = 'Net::SSLeay'; }; if ($@) { eval { require LWP::UserAgent; require HTTP::Request::Common; require Crypt::SSLeay; #import HTTP::Request::Common qw(GET POST); $ssl_module = 'Crypt::SSLeay'; }; } unless ($ssl_module) { die "One of Net::SSLeay (v1.30 or later)" . " or Crypt::SSLeay (+LWP) is required"; } } =head1 NAME Net::HTTPS::Any - Simple HTTPS class using whichever underlying SSL module is available =cut our $VERSION = '0.10'; =head1 SYNOPSIS use Net::HTTPS::Any qw(https_get https_post); ( $page, $response, %reply_headers ) = https_get( { 'host' => 'www.fortify.net', 'port' => 443, 'path' => '/sslcheck.html', }, ); ( $page, $response, %reply_headers ) = https_post( 'host' => 'www.google.com', 'port' => 443, 'path' => '/accounts/ServiceLoginAuth', 'args' => { 'field' => 'value' }, #'args' => [ 'field'=>'value' ], #order preserved ); #... =head1 DESCRIPTION This is a simple wrapper around either of the two available SSL modules. It offers a unified API for sending GET and POST requests over HTTPS and receiving responses. It depends on Net::SSLeay _or_ ( Crypt::SSLeay and LWP::UserAgent ). =head1 WHY THIS MODULE If you just want to write something that speaks HTTPS, you don't need this module. Just go ahead and use whichever of the two modules is good for you. Don't worry about it. On the other hand, if you are a CPAN author or distribute a Perl application, especially if you aim to support multiple OSes/disributions, using this module for speaking HTTPS may make things easier on your users. It allows your code to be used with either SSL implementation. =head1 FUNCTIONS =head2 https_get HASHREF | FIELD => VALUE, ... Accepts parameters as either a hashref or a list of fields and values. Parameters are: =over 4 =item host =item port =item path =item headers (hashref) For example: { 'X-Header1' => 'value', ... } =cut # =item Content-Type # # Defaults to "application/x-www-form-urlencoded" if not specified. =item args CGI arguments, eitehr as a hashref or a listref. In the latter case, ordering is preserved (see L to do so when passing a hashref). =item debug Set true to enable debugging. =back Returns a list consisting of the page content as a string, the HTTP response code and message (i.e. "200 OK" or "404 Not Found"), and a list of key/value pairs representing the HTTP response headers. =cut sub https_get { my $opts = ref($_[0]) ? shift : { @_ }; #hashref or list # accept a hashref or a list (keep it ordered) my $post_data = {}; # technically get_data, pedant if ( exists($opts->{'args'}) && ref($opts->{'args'}) eq 'HASH' ) { $post_data = $opts->{'args'}; } elsif ( exists($opts->{'args'}) && ref($opts->{'args'}) eq 'ARRAY' ) { tie my %hash, 'Tie::IxHash', @{ $opts->{'args'} }; $post_data = \%hash; } $opts->{'port'} ||= 443; #$opts->{"Content-Type"} ||= "application/x-www-form-urlencoded"; ### XXX referer!!! my %headers = (); if ( ref( $opts->{headers} ) eq "HASH" ) { %headers = %{ $opts->{headers} }; } $headers{'Host'} ||= $opts->{'host'}; my $path = $opts->{'path'}; if ( keys %$post_data ) { $path .= '?' . join( ';', map { uri_escape($_) . '=' . uri_escape( $post_data->{$_} ) } keys %$post_data ); } if ( $ssl_module eq 'Net::SSLeay' ) { no warnings 'uninitialized'; import Net::SSLeay qw(get_https make_headers); my $headers = make_headers(%headers); $Net::SSLeay::trace = $opts->{'debug'} if exists $opts->{'debug'} && $opts->{'debug'}; my( $res_page, $res_code, @res_headers ) = get_https( $opts->{'host'}, $opts->{'port'}, $path, $headers, #"", #$opts->{"Content-Type"}, ); $res_code =~ /^(HTTP\S+ )?(.*)/ and $res_code = $2; return ( $res_page, $res_code, @res_headers ); } elsif ( $ssl_module eq 'Crypt::SSLeay' ) { import HTTP::Request::Common qw(GET); my $url = 'https://' . $opts->{'host'}; $url .= ':' . $opts->{'port'} unless $opts->{'port'} == 443; $url .= "/$path"; my $ua = new LWP::UserAgent; foreach my $hdr ( keys %headers ) { $ua->default_header( $hdr => $headers{$hdr} ); } $ENV{HTTPS_DEBUG} = $opts->{'debug'} if exists $opts->{'debug'}; my $res = $ua->request( GET($url) ); my @res_headers = map { $_ => $res->header($_) } $res->header_field_names; return ( $res->content, $res->code. ' '. $res->message, @res_headers ); } else { die "unknown SSL module $ssl_module"; } } =head2 https_post HASHREF | FIELD => VALUE, ... Accepts parameters as either a hashref or a list of fields and values. Parameters are: =over 4 =item host =item port =item path =item headers (hashref) For example: { 'X-Header1' => 'value', ... } =item Content-Type Defaults to "application/x-www-form-urlencoded" if not specified. =item args CGI arguments, eitehr as a hashref or a listref. In the latter case, ordering is preserved (see L to do so when passing a hashref). =item content Raw content (overrides args). A simple scalar containing the raw content. =item debug Set true to enable debugging in the underlying SSL module. =back Returns a list consisting of the page content as a string, the HTTP response code and message (i.e. "200 OK" or "404 Not Found"), and a list of key/value pairs representing the HTTP response headers. =cut sub https_post { my $opts = ref($_[0]) ? shift : { @_ }; #hashref or list # accept a hashref or a list (keep it ordered). or a scalar of content. my $post_data = ''; if ( exists($opts->{'args'}) && ref($opts->{'args'}) eq 'HASH' ) { $post_data = $opts->{'args'}; } elsif ( exists($opts->{'args'}) && ref($opts->{'args'}) eq 'ARRAY' ) { tie my %hash, 'Tie::IxHash', @{ $opts->{'args'} }; $post_data = \%hash; } if ( exists $opts->{'content'} ) { $post_data = $opts->{'content'}; } $opts->{'port'} ||= 443; $opts->{"Content-Type"} ||= "application/x-www-form-urlencoded"; ### XXX referer!!! my %headers; if ( ref( $opts->{headers} ) eq "HASH" ) { %headers = %{ $opts->{headers} }; } $headers{'Host'} ||= $opts->{'host'}; if ( $ssl_module eq 'Net::SSLeay' ) { no warnings 'uninitialized'; import Net::SSLeay qw(post_https make_headers make_form); my $headers = make_headers(%headers); $Net::SSLeay::trace = $opts->{'debug'} if exists $opts->{'debug'} && $opts->{'debug'}; my $raw_data = ref($post_data) ? make_form(%$post_data) : $post_data; $Net::SSLeay::trace = $opts->{'debug'} if exists $opts->{'debug'} && $opts->{'debug'}; my( $res_page, $res_code, @res_headers ) = post_https( $opts->{'host'}, $opts->{'port'}, $opts->{'path'}, $headers, $raw_data, $opts->{"Content-Type"}, ); $res_code =~ /^(HTTP\S+ )?(.*)/ and $res_code = $2; return ( $res_page, $res_code, @res_headers ); } elsif ( $ssl_module eq 'Crypt::SSLeay' ) { import HTTP::Request::Common qw(POST); my $url = 'https://' . $opts->{'host'}; $url .= ':' . $opts->{'port'} unless $opts->{'port'} == 443; $url .= $opts->{'path'}; my $ua = new LWP::UserAgent; foreach my $hdr ( keys %headers ) { $ua->default_header( $hdr => $headers{$hdr} ); } $ENV{HTTPS_DEBUG} = $opts->{'debug'} if exists $opts->{'debug'}; my $res; if ( ref($post_data) ) { $res = $ua->request( POST( $url, [%$post_data] ) ); } else { my $req = new HTTP::Request( 'POST' => $url ); $req->content_type( $opts->{"Content-Type"} ); $req->content($post_data); $res = $ua->request($req); } my @res_headers = map { $_ => $res->header($_) } $res->header_field_names; return ( $res->content, $res->code. ' '. $res->message, @res_headers ); } else { die "unknown SSL module $ssl_module"; } } =head1 AUTHOR Ivan Kohler, C<< >> =head1 BUGS Please report any bugs or feature requests to C, or through the web interface at L. I will be notified, and then you'll automatically be notified of progress on your bug as I make changes. =head1 SUPPORT You can find documentation for this module with the perldoc command. perldoc Net::HTTPS::Any You can also look for information at: =over 4 =item * RT: CPAN's request tracker L =item * AnnoCPAN: Annotated CPAN documentation L =item * CPAN Ratings L =item * Search CPAN L =back =head1 COPYRIGHT & LICENSE Copyright 2008-2010 Freeside Internet Services, Inc. (http://freeside.biz/) All rights reserved. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut 1; Net-HTTPS-Any-0.10/t/0000755000175000017500000000000011367110760012526 5ustar ivanivanNet-HTTPS-Any-0.10/t/pod.t0000644000175000017500000000035011024642670013473 0ustar ivanivan#!perl -T use strict; use warnings; use Test::More; # Ensure a recent version of Test::Pod my $min_tp = 1.22; eval "use Test::Pod $min_tp"; plan skip_all => "Test::Pod $min_tp required for testing POD" if $@; all_pod_files_ok(); Net-HTTPS-Any-0.10/t/post-netssleay.t0000644000175000017500000000154211367110017015702 0ustar ivanivan#!/usr/bin/perl use strict; use warnings; use Test::More; BEGIN { plan( tests=>4 ); use_ok 'Net::HTTPS::Any', 'https_post'; }; #200 my($content, $response, %headers) = https_post( { 'host' => 'www.google.com', 'port' => 443, 'path' => '/accounts/ServiceLoginAuth', 'args' => { 'posted' => 'data' }, }, 'net_https_any_test' => 1, ); #like($response, qr/^HTTP\/[\d\.]+\s+200/i, 'Received 200 (OK) response'); like($response, qr/^200/i, 'Received 200 (OK) response'); ok( length($content), 'Received content' ); #404 my($content2, $response2, %headers2) = https_post( { 'host' => 'www.fortify.net', 'port' => 443, 'path' => '/notfound.html', }, 'net_https_any_test' => 1, ); #like($response2, qr/^HTTP\/[\d\.]+\s+404/i, 'Received 404 (Not Found) response'); like($response2, qr/^404/i, 'Received 404 (Not Found) response'); Net-HTTPS-Any-0.10/t/pod-coverage.t0000644000175000017500000000104711024642670015270 0ustar ivanivanuse strict; use warnings; use Test::More; # Ensure a recent version of Test::Pod::Coverage my $min_tpc = 1.08; eval "use Test::Pod::Coverage $min_tpc"; plan skip_all => "Test::Pod::Coverage $min_tpc required for testing POD coverage" if $@; # Test::Pod::Coverage doesn't require a minimum Pod::Coverage version, # but older versions don't recognize some common documentation styles my $min_pc = 0.18; eval "use Pod::Coverage $min_pc"; plan skip_all => "Pod::Coverage $min_pc required for testing POD coverage" if $@; all_pod_coverage_ok(); Net-HTTPS-Any-0.10/t/get-netssleay.t0000644000175000017500000000146311367110311015473 0ustar ivanivan#!/usr/bin/perl use strict; use warnings; use Test::More; BEGIN { plan( tests=>4 ); use_ok( 'Net::HTTPS::Any', qw( https_get ) ); } #200 my($content, $response, %headers) = https_get( { 'host' => 'www.fortify.net', 'port' => 443, 'path' => '/sslcheck.html', }, 'net_https_any_test' => 1, ); #like($response, qr/^HTTP\/[\d\.]+\s+200/i, 'Received 200 (OK) response'); like($response, qr/^200/i, 'Received 200 (OK) response'); ok( length($content), 'Received content' ); #404 my($content2, $response2, %headers2) = https_get( { 'host' => 'www.fortify.net', 'port' => 443, 'path' => '/notfound.html', }, 'net_https_any_test' => 1, ); #like($response2, qr/^HTTP\/[\d\.]+\s+404/i, 'Received 404 (Not Found) response'); like($response2, qr/^404/i, 'Received 404 (Not Found) response'); Net-HTTPS-Any-0.10/t/post-cryptssleay.t0000644000175000017500000000165711367110055016266 0ustar ivanivan#!/usr/bin/perl use strict; use warnings; use Test::More; BEGIN { plan( tests=>4 ); $Net::HTTPS::Any::skip_NetSSLeay=1; $Net::HTTPS::Any::skip_NetSSLeay=1; use_ok 'Net::HTTPS::Any', 'https_post'; }; #200 my($content, $response, %headers) = https_post( { 'host' => 'www.google.com', 'port' => 443, 'path' => '/accounts/ServiceLoginAuth', 'args' => { 'posted' => 'data' }, }, 'net_https_any_test' => 1, ); #like($response, qr/^HTTP\/[\d\.]+\s+200/i, 'Received 200 (OK) response'); like($response, qr/^200/i, 'Received 200 (OK) response'); ok( length($content), 'Received content' ); #404 my($content2, $response2, %headers2) = https_post( { 'host' => 'www.fortify.net', 'port' => 443, 'path' => '/notfound.html', }, 'net_https_any_test' => 1, ); #like($response2, qr/^HTTP\/[\d\.]+\s+404/i, 'Received 404 (Not FOund) response'); like($response2, qr/^404/i, 'Received 404 (Not Found) response'); Net-HTTPS-Any-0.10/t/get-cryptssleay.t0000644000175000017500000000157311367107102016054 0ustar ivanivan#!/usr/bin/perl use strict; use warnings; use Test::More; BEGIN { plan( tests=>4 ); $Net::HTTPS::Any::skip_NetSSLeay=1; $Net::HTTPS::Any::skip_NetSSLeay=1; use_ok 'Net::HTTPS::Any', 'https_get'; }; #200 my($content, $response, %headers) = https_get( { 'host' => 'www.fortify.net', 'port' => 443, 'path' => '/sslcheck.html', }, 'net_https_any_test' => 1, ); #like($response, qr/^HTTP\/[\d\.]+\s+200/i, 'Received 200 (OK) response'); like($response, qr/^200/i, 'Received 200 (OK) response'); ok( length($content), 'Received content' ); #404 my($content2, $response2, %headers2) = https_get( { 'host' => 'www.fortify.net', 'port' => 443, 'path' => '/notfound.html', }, 'net_https_any_test' => 1, ); #like($response2, qr/^HTTP\/[\d\.]+\s+404/i, 'Received 404 (Not found) response'); like($response2, qr/^404/i, 'Received 404 (Not found) response'); Net-HTTPS-Any-0.10/t/00-load.t0000644000175000017500000000023311024642670014045 0ustar ivanivan#!perl -T use Test::More tests => 1; BEGIN { use_ok( 'Net::HTTPS::Any' ); } diag( "Testing Net::HTTPS::Any $Net::HTTPS::Any::VERSION, Perl $], $^X" ); Net-HTTPS-Any-0.10/Makefile.PL0000644000175000017500000000145611366730177014254 0ustar ivanivanuse strict; use warnings; use ExtUtils::MakeMaker; WriteMakefile( NAME => 'Net::HTTPS::Any', AUTHOR => 'Ivan Kohler ', VERSION_FROM => 'lib/Net/HTTPS/Any.pm', ABSTRACT_FROM => 'lib/Net/HTTPS/Any.pm', PL_FILES => {}, PREREQ_PM => { 'Test::More' => 0, 'URI::Escape' => 0, 'Tie::IxHash' => 0, # If you are aware of a way to declare an OR relation in prerequisites, # please tell me, you would be my hero. it doesn't have to be EU:MM. # 'Net::SSLeay' => 0, # or 'Crypt::SSLeay' => 0, # 'LWP' => 0, }, dist => { COMPRESS => 'gzip -9f', SUFFIX => 'gz', }, clean => { FILES => 'Net-HTTPS-Any-*' }, ); Net-HTTPS-Any-0.10/MANIFEST0000644000175000017500000000037311367110760013417 0ustar ivanivanChanges MANIFEST Makefile.PL README lib/Net/HTTPS/Any.pm t/00-load.t t/get-cryptssleay.t t/get-netssleay.t t/pod-coverage.t t/pod.t t/post-cryptssleay.t t/post-netssleay.t META.yml Module meta-data (added by MakeMaker)