PaxHeader/Catalyst-Authentication-Credential-HTTP-1.016000755 777777 777777 00000000214 12175027621 025263 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221706 19 SCHILY.nlink=12 Catalyst-Authentication-Credential-HTTP-1.016/000755 €;Ðâp€tzÕß00000000000 12175027621 025042 5ustar00tdoranAD\Domain Users000000 000000 Catalyst-Authentication-Credential-HTTP-1.016/PaxHeader/.gitignore000644 777777 777777 00000000213 12175022324 027317 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374954783 23 SCHILY.dev=16777218 22 SCHILY.ino=4217180 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/.gitignore000644 €;Ðâp€tzÕß00000000177 12175022324 027032 0ustar00tdoranAD\Domain Users000000 000000 Catalyst-Authentication-Credential-HTTP-* MANIFEST MANIFEST.bak META.yml MYMETA.json MYMETA.yml Makefile inc/ blib/ pm_to_blib Catalyst-Authentication-Credential-HTTP-1.016/PaxHeader/Changes000644 777777 777777 00000000213 12175022461 026624 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374954855 23 SCHILY.dev=16777218 22 SCHILY.ino=4217270 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/Changes000644 €;Ðâp€tzÕß00000011426 12175022461 026336 0ustar00tdoranAD\Domain Users000000 000000 1.016 2013-07-27 - Fix repository metadata. RT#87114 1.015 2012-06-27 - Add broken_dotnet_digest_without_query_string option Allows digest authentication from .NET, which does not include the query string in the uri in the digest Authorization header. - Fix broken synopsis. RT#75254 1.014 2012-02-05 - Add require_ssl configuration setting. - Add no_unprompted_authorization_required configuration setting. 1.013 2010-12-14 - Call store_digest_authorization_nonce() instead of $c->cache->set() in authenticate_digest() (RT#63669) (rjk) - Make Test::Exception and Test::MockObject be listed as test_requires rather than requires (RT#54029) - Skip WWW::Mech tests unless WWW::Mech is a new enough version (RT#55303). - Improve documentation for authenticate_digest() (rjk) - depends on Catalyst::Plugin::Cache, not Catalyst::Plugin::Session - reorganize and clarify 1.012 2010-03-07 - Move actions out of the test applications to stop warnings. - Make Pod tests author only. 1.011 2009-06-26 - Added true/false check to _debug option 1.010 2009-05-14 - Moved tests out to t/lib/ (dhoss) - Add debug when a user is found, but passwords don't match (abraxxa) 1.009 2009-01-04 - Remove use of _config accessor, which I'd stupidly cargo-culted. As we don't ever run in auth back-compat mode, we can store everything in instance data without worrying about conflicts. Note however - have to keep the accessor itself so that our parent class (which is still stupid and uses it) continues to work. 1.008 2008-12-10 - Fix issue with the user not being authenticated into the correct realm, by not calling $c->set_authenticated ourselves, but instead just returning the user object. Fix suggested by Bernhard Graf. (t0m) - Add test for this (t0m) - Change $user to $user_obj in authenticate_digest for consistency (t0m) 1.007 2008-11-19 - Add test for query strings in digest auth as digest header is built using the full URI (t0m) - Fix for this (Peter Corlett) - Fix warning when used with self_check => 1 (t0m) - Added respository info to META.yml (t0m) 1.006 2008-10-06 - Added username_field configuration option. I need this to play nice with Catalyst::Authentication::Store::Tangram. - Doc cleanups / clarifications related to RT#39838 1.005 2008-09-25 - Added better description of the use of the domains and use_uri_for options (info culled from RFC2617). - Split init method out to make this module easier to sub-class (used by Catalyst::Authentication::HTTP::Proxy). 1.004 2008-09-12 - Add tests for use_uri_for configuration options. - Add tests and documentation for storing an MD5 of "$user:$relam:$password" instead of cleartext password when doing digest auth. 1.003 2008-09-11 - Add ability to override the realm name presented for authentication when calling $c->authenticate. Documentation and tests for this. - Clean up documentation of options inherited from Catalyst::Authentication::Credential::Password. - Added an example of calling methods in the credential module from a controller to the POD. - Tests for the authorization_required_message configuration parameter. - Document use_uri_for configuration option - Document domain option (passed through from $c->authenticate) and add tests for this option. 1.002 2008-09-03 - Fix the assumptions that the password field is named password when doing digest auth. 1.001 2008-09-02 - Fix some of the assumptions about the user class by inheriting from the Catalyst::Authentication::Credential::Password module. This should make using DBIC as a store work correctly for basic auth. - Updated synopsis and todo list, this module still needs some work before it's ready for prime time again.. 1.000 2008-09-01 - Rename to remove Plugin from namespace. This is a pretty breaking change, as lots of things work differently with the new auth refactor. - Pull out some functionality which I think is better in other modules (realms/stores). With the auth refactor, this module didn't need to do so much. If anyone misses any of the functionality, please yell at me and I'll put it back. 0.11 2008-07-12 - Changed cache modules used in the tests to not be deprecated. - Fix RT#31036, and comply with RFC2617 Section 1.2. 0.10 2007-04-26 - switch to Module::Install 0.09 2006-12-31 - clean up tests - clean up docs - add body to 401 status 0.08 2006-10-12 - Fix basic test when using Test::MockObject 1.07 (die if using undefined interfaces) 0.07 2006-09-12 - Applied Ton Voon's patch that fixed option propagation for basic auth. 0.06 2006-09-07 - Refactored internals into smaller methods Catalyst-Authentication-Credential-HTTP-1.016/PaxHeader/inc000755 777777 777777 00000000213 12175027621 026033 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221714 18 SCHILY.nlink=3 Catalyst-Authentication-Credential-HTTP-1.016/inc/000755 €;Ðâp€tzÕß00000000000 12175027621 025613 5ustar00tdoranAD\Domain Users000000 000000 Catalyst-Authentication-Credential-HTTP-1.016/PaxHeader/lib000755 777777 777777 00000000213 12175027621 026030 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221744 18 SCHILY.nlink=3 Catalyst-Authentication-Credential-HTTP-1.016/lib/000755 €;Ðâp€tzÕß00000000000 12175027621 025610 5ustar00tdoranAD\Domain Users000000 000000 Catalyst-Authentication-Credential-HTTP-1.016/PaxHeader/Makefile.PL000644 777777 777777 00000000213 12175022376 027310 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957452 23 SCHILY.dev=16777218 22 SCHILY.ino=4217221 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/Makefile.PL000644 €;Ðâp€tzÕß00000001561 12175022376 027021 0ustar00tdoranAD\Domain Users000000 000000 use inc::Module::Install 0.87; use Module::Install::AuthorRequires; use Module::Install::AuthorTests; name 'Catalyst-Authentication-Credential-HTTP'; all_from 'lib/Catalyst/Authentication/Credential/HTTP.pm'; requires 'Catalyst::Runtime'; requires 'Catalyst::Plugin::Authentication' => '0.10005'; requires 'Data::UUID' => '0.11'; requires 'String::Escape'; requires 'URI::Escape'; requires 'Class::Accessor::Fast'; test_requires 'Test::Exception'; test_requires 'Test::MockObject'; test_requires 'Test::More' => '0.88'; author_requires 'Test::WWW::Mechanize::Catalyst' => '0.51'; author_requires 'Test::Pod' => '1.14'; author_requires 'Test::Spelling' => '0.11'; author_requires 'Test::Pod::Coverage' => '1.04'; resources repository => 'git://git.shadowcat.co.uk/catagits/Catalyst/Catalyst-Authentication-Credential-HTTP'; author_tests 't/author'; auto_install; WriteAll; Catalyst-Authentication-Credential-HTTP-1.016/PaxHeader/MANIFEST000644 777777 777777 00000000213 12175027606 026470 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221743 18 SCHILY.nlink=1 Catalyst-Authentication-Credential-HTTP-1.016/MANIFEST000644 €;Ðâp€tzÕß00000001542 12175027606 026200 0ustar00tdoranAD\Domain Users000000 000000 .gitignore Changes inc/Module/AutoInstall.pm inc/Module/Install.pm inc/Module/Install/AuthorRequires.pm inc/Module/Install/AuthorTests.pm inc/Module/Install/AutoInstall.pm inc/Module/Install/Base.pm inc/Module/Install/Can.pm inc/Module/Install/Fetch.pm inc/Module/Install/Include.pm inc/Module/Install/Makefile.pm inc/Module/Install/Metadata.pm inc/Module/Install/Win32.pm inc/Module/Install/WriteAll.pm lib/Catalyst/Authentication/Credential/HTTP.pm Makefile.PL MANIFEST This list of files META.yml README t/00use.t t/author/pod.t t/author/pod_spelling.t t/author/podcoverage.t t/basic.t t/lib/AuthDigestDotnetTestApp.pm t/lib/AuthDigestDotnetTestApp/Controller/Root.pm t/lib/AuthDigestTestApp.pm t/lib/AuthDigestTestApp/Controller/Root.pm t/lib/AuthTestApp.pm t/lib/AuthTestApp/Controller/Root.pm t/live_app.t t/live_app_digest.t t/live_app_digest_dotnet.t Todo Catalyst-Authentication-Credential-HTTP-1.016/PaxHeader/META.yml000644 777777 777777 00000000213 12175027561 026610 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957452 23 SCHILY.dev=16777218 22 SCHILY.ino=4221711 18 SCHILY.nlink=1 Catalyst-Authentication-Credential-HTTP-1.016/META.yml000644 €;Ðâp€tzÕß00000001560 12175027561 026320 0ustar00tdoranAD\Domain Users000000 000000 --- abstract: 'HTTP Basic and Digest authentication' author: - 'Updated to current name space and currently maintained' build_requires: ExtUtils::MakeMaker: 6.36 Test::Exception: 0 Test::MockObject: 0 Test::More: 0.88 configure_requires: ExtUtils::MakeMaker: 6.36 distribution_type: module dynamic_config: 1 generated_by: 'Module::Install version 1.06' license: perl meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.4.html version: 1.4 name: Catalyst-Authentication-Credential-HTTP no_index: directory: - inc - t requires: Catalyst::Plugin::Authentication: 0.10005 Catalyst::Runtime: 0 Class::Accessor::Fast: 0 Data::UUID: 0.11 String::Escape: 0 URI::Escape: 0 resources: license: http://dev.perl.org/licenses/ repository: git://git.shadowcat.co.uk/catagits/Catalyst/Catalyst-Authentication-Credential-HTTP version: 1.016 Catalyst-Authentication-Credential-HTTP-1.016/PaxHeader/README000644 777777 777777 00000000213 12175022324 026207 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374954843 23 SCHILY.dev=16777218 22 SCHILY.ino=4217185 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/README000644 €;Ðâp€tzÕß00000011541 12175022324 025717 0ustar00tdoranAD\Domain Users000000 000000 NAME Catalyst::Plugin::Authentication::Credential::HTTP - HTTP Basic and Digest authentication for Catalyst. SYNOPSIS use Catalyst qw/ Authentication Authentication::Store::Minimal Authentication::Credential::HTTP /; __PACKAGE__->config->{authentication}{http}{type} = 'any'; # or 'digest' or 'basic' __PACKAGE__->config->{authentication}{users} = { Mufasa => { password => "Circle Of Life", }, }; sub foo : Local { my ( $self, $c ) = @_; $c->authorization_required( realm => "foo" ); # named after the status code ;-) # either user gets authenticated or 401 is sent do_stuff(); } # with ACL plugin __PACKAGE__->deny_access_unless("/path", sub { $_[0]->authenticate_http }); sub end : Private { my ( $self, $c ) = @_; $c->authorization_required_response( realm => "foo" ); $c->error(0); } DESCRIPTION This moduule lets you use HTTP authentication with Catalyst::Plugin::Authentication. Both basic and digest authentication are currently supported. When authentication is required, this module sets a status of 401, and the body of the response to 'Authorization required.'. To override this and set your own content, check for the "$c->res->status == 401" in your "end" action, and change the body accordingly. TERMS Nonce A nonce is a one-time value sent with each digest authentication request header. The value must always be unique, so per default the last value of the nonce is kept using Catalyst::Plugin::Cache. To change this behaviour, override the "store_digest_authorization_nonce" and "get_digest_authorization_nonce" methods as shown below. METHODS authorization_required %opts Tries to "authenticate_http", and if that fails calls "authorization_required_response" and detaches the current action call stack. This method just passes the options through untouched. authenticate_http %opts Looks inside "$c->request->headers" and processes the digest and basic (badly named) authorization header. This will only try the methods set in the configuration. First digest, then basic. See the next two methods for what %opts can contain. authenticate_basic %opts authenticate_digest %opts Try to authenticate one of the methods without checking if the method is allowed in the configuration. %opts can contain "store" (either an object or a name), "user" (to disregard %the username from the header altogether, overriding it with a username or user %object). authorization_required_response %opts Sets "$c->response" to the correct status code, and adds the correct header to demand authentication data from the user agent. Typically used by "authorization_required", but may be invoked manually. %opts can contain "realm", "domain" and "algorithm", which are used to build %the digest header. store_digest_authorization_nonce $key, $nonce get_digest_authorization_nonce $key Set or get the $nonce object used by the digest auth mode. You may override these methods. By default they will call "get" and "set" on "$c->cache". CONFIGURATION All configuration is stored in "YourApp->config->{authentication}{http}". This should be a hash, and it can contain the following entries: store Either a name or an object -- the default store to use for HTTP authentication. type Can be either "any" (the default), "basic" or "digest". This controls "authorization_required_response" and "authenticate_http", but not the "manual" methods. authorization_required_message Set this to a string to override the default body content "Authorization required." RESTRICTIONS When using digest authentication, this module will only work together with authentication stores whose User objects have a "password" method that returns the plain-text password. It will not work together with Catalyst::Authentication::Store::Htpasswd, or Catalyst::Plugin::Authentication::Store::DBIC stores whose "password" methods return a hashed or salted version of the password. AUTHORS Yuval Kogman, "nothingmuch@woobling.org" Jess Robinson Sascha Kiefer "esskar@cpan.org" SEE ALSO RFC 2617 (or its successors), Catalyst::Plugin::Cache, Catalyst::Plugin::Authentication COPYRIGHT & LICENSE Copyright (c) 2005-2006 the aforementioned authors. All rights reserved. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. Catalyst-Authentication-Credential-HTTP-1.016/PaxHeader/t000755 777777 777777 00000000213 12175027621 025525 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221708 18 SCHILY.nlink=9 Catalyst-Authentication-Credential-HTTP-1.016/t/000755 €;Ðâp€tzÕß00000000000 12175027621 025305 5ustar00tdoranAD\Domain Users000000 000000 Catalyst-Authentication-Credential-HTTP-1.016/PaxHeader/Todo000644 777777 777777 00000000213 12175022324 026157 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4217186 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/Todo000644 €;Ðâp€tzÕß00000000601 12175022324 025662 0ustar00tdoranAD\Domain Users000000 000000 . Split auth headers / do auth methods again, and make authenticate call each in turn. . Test 'algorithm' config / MD5-sess properly. . Full implementation of MD5-sess with remote authentication service. . Domain option should be able to be passed as config. . Support for NTLM auth? . Config verification / validation on construction. . Test all config parameters (esp username_field)Catalyst-Authentication-Credential-HTTP-1.016/t/PaxHeader/00use.t000644 777777 777777 00000000213 12175022324 026713 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957453 23 SCHILY.dev=16777218 22 SCHILY.ino=4217193 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/t/00use.t000644 €;Ðâp€tzÕß00000000627 12175022324 026426 0ustar00tdoranAD\Domain Users000000 000000 use strict; use warnings; use Test::More; use_ok 'Catalyst'; diag 'Catalyst ' . $Catalyst::VERSION; use_ok 'Catalyst::Plugin::Authentication'; diag 'Catalyst::Plugin::Authentication ' . $Catalyst::Plugin::Authentication::VERSION; use_ok 'Catalyst::Authentication::Credential::HTTP'; diag 'Catalyst::Authentication::Credential::HTTP ' . $Catalyst::Authentication::Credential::HTTP::VERSION; done_testing; Catalyst-Authentication-Credential-HTTP-1.016/t/PaxHeader/author000755 777777 777777 00000000213 12175027621 027027 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221733 18 SCHILY.nlink=5 Catalyst-Authentication-Credential-HTTP-1.016/t/author/000755 €;Ðâp€tzÕß00000000000 12175027621 026607 5ustar00tdoranAD\Domain Users000000 000000 Catalyst-Authentication-Credential-HTTP-1.016/t/PaxHeader/basic.t000644 777777 777777 00000000213 12175022324 027040 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957455 23 SCHILY.dev=16777218 22 SCHILY.ino=4217198 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/t/basic.t000644 €;Ðâp€tzÕß00000015367 12175022324 026562 0ustar00tdoranAD\Domain Users000000 000000 #!/usr/bin/perl use strict; use warnings; use Test::More tests => 35; use Test::MockObject::Extends; use Test::MockObject; use Test::Exception; use HTTP::Headers; my $m; BEGIN { use_ok($m = "Catalyst::Authentication::Credential::HTTP") } can_ok( $m, "authenticate" ); can_ok( $m, "authorization_required_response" ); my $req = Test::MockObject->new; my $req_headers = HTTP::Headers->new; $req->set_always( headers => $req_headers ); my $res = Test::MockObject->new; my $status; $res->mock(status => sub { $status = $_[1] }); my $content_type; $res->mock(content_type => sub { $content_type = $_[1] }); my $body; my $headers; $res->mock(body => sub { $body = $_[1] }); my $res_headers = HTTP::Headers->new; $res->set_always( headers => $res_headers ); my $user = Test::MockObject->new; $user->set_isa('Catalyst::Authentication::User'); $user->mock(get => sub { return shift->{$_[0]} }); my $find_user_opts; my $realm = Test::MockObject->new; $realm->mock( find_user => sub { $find_user_opts = $_[1]; return $user; }); $realm->mock( name => sub { 'foo' } ); my $c = Test::MockObject->new; my $cache = Test::MockObject->new; $cache->mock(set => sub { shift->{$_[0]} = $_[1] }); $cache->mock(get => sub { return shift->{$_[0]} }); my $uri_for_called = 0; $c->mock(uri_for => sub { my ($c, $uri) = @_; $uri_for_called++; return 'uri_for:' . $uri} ); $c->mock(cache => sub { $cache }); $c->mock(debug => sub { 0 }); my @login_info; $c->mock( login => sub { shift; @login_info = @_; 1 } ); my $authenticated = 0; $c->mock( set_authenticated => sub { $authenticated++; } ); $c->set_always( config => {} ); $c->set_always( req => $req ); $c->set_always( res => $res ); $c->set_always( request => $req ); $c->set_always( response => $res ); sub new_self { my $config = { @_ }; my $raw_self = $m->new($config, $c, $realm); return Test::MockObject::Extends->new( $raw_self ); } # Normal auth, simple as possible. # No credentials my $self = new_self( type => 'any', password_type => 'clear', password_field => 'password' ); throws_ok { $self->authenticate( $c, $realm ); } qr/^ $Catalyst::DETACH $/x, 'Calling authenticate for http auth without header detaches'; $user->{password} = 'bar'; # Wrong credentials $req_headers->authorization_basic( qw/foo quux/ ); throws_ok { $self->authenticate( $c, $realm ); } qr/^ $Catalyst::DETACH $/x, 'Calling authenticate for http auth without header detaches'; # Correct credentials $req_headers->authorization_basic( qw/foo bar/ ); { my $user = $self->authenticate($c, $realm); ok($user, "auth successful with header"); isa_ok $user, 'Catalyst::Authentication::User'; } is($authenticated, 0, 'Not called set_authenticated'); is_deeply( $find_user_opts, { username => 'foo'}, "login delegated"); # Test all the headers look good. $req_headers->clear; $res_headers->clear; $c->clear; throws_ok { $self->authenticate( $c, $realm ); } qr/^ $Catalyst::DETACH $/x, "detached on no authorization required with bad auth"; is( $status, 401, "401 status code" ); is( $content_type, 'text/plain' ); is( $body, 'Authorization required.' ); like( ($res_headers->header('WWW-Authenticate'))[0], qr/^Digest/, "WWW-Authenticate header set: digest"); like( ($res_headers->header('WWW-Authenticate'))[0], qr/realm="foo"/, "WWW-Authenticate header set: digest realm"); like( ($res_headers->header('WWW-Authenticate'))[1], qr/^Basic/, "WWW-Authenticate header set: basic"); like( ($res_headers->header('WWW-Authenticate'))[1], qr/realm="foo"/, "WWW-Authenticate header set: basic realm"); $res_headers->clear; # Check password_field works { my $self = new_self( type => 'any', password_type => 'clear', password_field => 'the_other_password' ); local $user->{password} = 'bar'; local $user->{the_other_password} = 'the_other_password'; $req_headers->authorization_basic( qw/foo the_other_password/ ); ok($self->authenticate($c, $realm), "auth successful with header and alternate password field"); $c->clear; $req_headers->authorization_basic( qw/foo bar/ ); throws_ok { $self->authenticate( $c, $realm ); } qr/^ $Catalyst::DETACH $/x, "detached on bad password (different password field)"; } $req_headers->clear; $res_headers->clear; throws_ok { $self->authenticate( $c, $realm, { realm => 'myrealm' }); # Override realm object's name method by doing this. } qr/^ $Catalyst::DETACH $/x, "detached on no authorization supplied, overridden realm value"; is( $status, 401, "401 status code" ); is( $content_type, 'text/plain' ); is( $body, 'Authorization required.' ); like( ($res_headers->header('WWW-Authenticate'))[0], qr/realm="myrealm"/, "WWW-Authenticate header set: digest realm overridden"); like( ($res_headers->header('WWW-Authenticate'))[1], qr/realm="myrealm"/, "WWW-Authenticate header set: basic realm overridden"); # Check authorization_required_message works $req_headers->clear; $res_headers->clear; $c->clear; { my $self = new_self( type => 'any', password_type => 'clear', authorization_required_message => 'foobar' ); throws_ok { $self->authenticate( $c, $realm ); } qr/^ $Catalyst::DETACH $/x, "detached"; is( $body, 'foobar', 'Body is supplied auth message'); } # Check undef authorization_required_message suppresses crapping in # the body. $req_headers->clear; $res_headers->clear; $c->clear; $body = 'quuux'; { my $self = new_self( type => 'any', password_type => 'clear', authorization_required_message => undef ); throws_ok { $self->authenticate( $c, $realm ); } qr/^ $Catalyst::DETACH $/x, "detached"; is( $body, 'quuux', 'Body is not set - user overrode auth message'); } # Check domain config works $req_headers->clear; $res_headers->clear; $c->clear; { my $self = new_self( type => 'any', password_type => 'clear'); throws_ok { $self->authenticate( $c, $realm, {domain => [qw/dom1 dom2/]} ); } qr/^ $Catalyst::DETACH $/x, "detached"; like( ($res_headers->header('WWW-Authenticate'))[0], qr/domain="dom1 dom2"/, "WWW-Authenticate header set: digest domains set"); like( ($res_headers->header('WWW-Authenticate'))[1], qr/domain="dom1 dom2"/, "WWW-Authenticate header set: basic domains set"); } # Check domain config works with use_uri_for option $req_headers->clear; $res_headers->clear; $c->clear; { my $self = new_self( type => 'any', password_type => 'clear', use_uri_for => 1); throws_ok { $self->authenticate( $c, $realm, {domain => [qw/dom1 dom2/]} ); } qr/^ $Catalyst::DETACH $/x, "detached"; like( ($res_headers->header('WWW-Authenticate'))[0], qr/domain="uri_for:dom1 uri_for:dom2"/, "WWW-Authenticate header set: digest domains set with use_uri_for"); like( ($res_headers->header('WWW-Authenticate'))[1], qr/domain="uri_for:dom1 uri_for:dom2"/, "WWW-Authenticate header set: basic domains set with use_uri_for"); }Catalyst-Authentication-Credential-HTTP-1.016/t/PaxHeader/lib000755 777777 777777 00000000213 12175027621 026273 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221718 18 SCHILY.nlink=8 Catalyst-Authentication-Credential-HTTP-1.016/t/lib/000755 €;Ðâp€tzÕß00000000000 12175027621 026053 5ustar00tdoranAD\Domain Users000000 000000 Catalyst-Authentication-Credential-HTTP-1.016/t/PaxHeader/live_app.t000644 777777 777777 00000000213 12175022324 027556 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957456 23 SCHILY.dev=16777218 22 SCHILY.ino=4217212 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/t/live_app.t000644 €;Ðâp€tzÕß00000003004 12175022324 027261 0ustar00tdoranAD\Domain Users000000 000000 #!/usr/bin/perl use strict; use warnings; use FindBin qw/$Bin/; use lib "$Bin/lib"; use Test::More; BEGIN { do { eval { require Test::WWW::Mechanize::Catalyst } and Test::WWW::Mechanize::Catalyst->VERSION('0.51') } or plan skip_all => "Test::WWW::Mechanize::Catalyst is needed for this test"; } use HTTP::Request; use Test::More; use Test::WWW::Mechanize::Catalyst; my $mech = Test::WWW::Mechanize::Catalyst->new(catalyst_app => 'AuthTestApp'); $mech->get("http://localhost/moose"); is( $mech->status, 401, "status is 401" ) or die $mech->content; $mech->content_lacks( "foo", "no output" ); my $r = HTTP::Request->new( GET => "http://localhost/moose" ); $r->authorization_basic(qw/foo s3cr3t/); $mech->request($r); is( $mech->status, 200, "status is 200" ); $mech->content_contains( "foo", "foo output" ); AuthTestApp->get_auth_realm('test')->credential->no_unprompted_authorization_required(1); $mech = Test::WWW::Mechanize::Catalyst->new(catalyst_app => 'AuthTestApp'); $mech->get("http://localhost/moose"); isnt( $mech->status, 401, "status isnt 401" ) or die $mech->content; AuthTestApp->get_auth_realm('test')->credential->no_unprompted_authorization_required(0); AuthTestApp->get_auth_realm('test')->credential->require_ssl(1); $mech = Test::WWW::Mechanize::Catalyst->new(catalyst_app => 'AuthTestApp'); $r = HTTP::Request->new( GET => "http://localhost/moose" ); $r->authorization_basic(qw/foo s3cr3t/); $mech->request($r); is( $mech->status, 401, "status is 401" ); done_testing; Catalyst-Authentication-Credential-HTTP-1.016/t/PaxHeader/live_app_digest.t000644 777777 777777 00000000213 12175022324 031115 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957456 23 SCHILY.dev=16777218 22 SCHILY.ino=4217213 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/t/live_app_digest.t000644 €;Ðâp€tzÕß00000005220 12175022324 030622 0ustar00tdoranAD\Domain Users000000 000000 #!/usr/bin/perl use strict; use warnings; use FindBin qw/$Bin/; use lib "$Bin/lib"; use Test::More; BEGIN { do { eval { require Test::WWW::Mechanize::Catalyst } and Test::WWW::Mechanize::Catalyst->VERSION('0.51') } or plan skip_all => "Test::WWW::Mechanize::Catalyst is needed for this test"; eval { require Catalyst::Plugin::Cache } or plan skip_all => "Catalyst::Plugin::Cache is needed for this test"; eval { require Cache::FileCache } or plan skip_all => "Cache::FileCache is needed for this test"; plan tests => 12; } use Digest::MD5; use HTTP::Request; use Test::More; use Test::WWW::Mechanize::Catalyst qw/AuthDigestTestApp/; sub do_test { my $username = shift; my $uri = shift; my $mech = Test::WWW::Mechanize::Catalyst->new; $mech->get("http://localhost/moose"); is( $mech->status, 401, "status is 401" ); my $www_auth = $mech->res->headers->header('WWW-Authenticate'); my %www_auth_params = map { my @key_val = split /=/, $_, 2; $key_val[0] = lc $key_val[0]; $key_val[1] =~ s{"}{}g; # remove the quotes @key_val; } split /, /, substr( $www_auth, 7 ); #7 == length "Digest " $mech->content_lacks( "foo", "no output" ); my $response = ''; { my $password = 'Circle Of Life'; my $realm = $www_auth_params{realm}; my $nonce = $www_auth_params{nonce}; my $cnonce = '0a4f113b'; my $opaque = $www_auth_params{opaque}; my $nc = '00000001'; my $method = 'GET'; my $qop = 'auth'; $uri ||= '/moose'; my $ctx = Digest::MD5->new; $ctx->add( join( ':', $username, $realm, $password ) ); my $A1_digest = $ctx->hexdigest; $ctx = Digest::MD5->new; $ctx->add( join( ':', $method, $uri ) ); my $A2_digest = $ctx->hexdigest; my $digest = Digest::MD5::md5_hex( join( ':', $A1_digest, $nonce, $qop ? ( $nc, $cnonce, $qop ) : (), $A2_digest ) ); $response = qq{Digest username="$username", realm="$realm", nonce="$nonce", uri="$uri", qop=$qop, nc=$nc, cnonce="$cnonce", response="$digest", opaque="$opaque"}; } my $r = HTTP::Request->new( GET => "http://localhost" . $uri ); $mech->request($r); $r->headers->push_header( Authorization => $response ); $mech->request($r); is( $mech->status, 200, "status is 200" ); $mech->content_contains( $username, "Mufasa output" ); } do_test('Mufasa'); do_test('Mufasa2'); do_test('Mufasa', '/moose?moose_id=1'); # Digest auth includes the full URL path, so need to test query strings Catalyst-Authentication-Credential-HTTP-1.016/t/PaxHeader/live_app_digest_dotnet.t000644 777777 777777 00000000213 12175022324 032472 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957456 23 SCHILY.dev=16777218 22 SCHILY.ino=4217214 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/t/live_app_digest_dotnet.t000644 €;Ðâp€tzÕß00000006246 12175022324 032210 0ustar00tdoranAD\Domain Users000000 000000 #!/usr/bin/perl use strict; use warnings; use FindBin qw/$Bin/; use lib "$Bin/lib"; use Test::More; BEGIN { do { eval { require Test::WWW::Mechanize::Catalyst } and Test::WWW::Mechanize::Catalyst->VERSION('0.51') } or plan skip_all => "Test::WWW::Mechanize::Catalyst is needed for this test"; eval { require Catalyst::Plugin::Cache } or plan skip_all => "Catalyst::Plugin::Cache is needed for this test"; eval { require Cache::FileCache } or plan skip_all => "Cache::FileCache is needed for this test"; plan tests => 19; } use Digest::MD5; use HTTP::Request; use Test::More; use Test::WWW::Mechanize::Catalyst; sub do_test { my ($username, $uri, $emulate_dotnet, $fail) = @_; my $app = $fail ? 'AuthDigestTestApp' : 'AuthDigestDotnetTestApp'; my $mech = Test::WWW::Mechanize::Catalyst->new(catalyst_app => $app); $mech->get("http://localhost/moose"); is( $mech->status, 401, "status is 401" ); my $www_auth = $mech->res->headers->header('WWW-Authenticate'); my %www_auth_params = map { my @key_val = split /=/, $_, 2; $key_val[0] = lc $key_val[0]; $key_val[1] =~ s{"}{}g; # remove the quotes @key_val; } split /, /, substr( $www_auth, 7 ); #7 == length "Digest " $mech->content_lacks( "foo", "no output" ); my $response = ''; { my $password = 'Circle Of Life'; my $realm = $www_auth_params{realm}; my $nonce = $www_auth_params{nonce}; my $cnonce = '0a4f113b'; my $opaque = $www_auth_params{opaque}; my $nc = '00000001'; my $method = 'GET'; my $qop = 'auth'; $uri ||= '/moose'; my $auth_uri = $uri; if ($emulate_dotnet) { $auth_uri =~ s/\?.*//; } my $ctx = Digest::MD5->new; $ctx->add( join( ':', $username, $realm, $password ) ); my $A1_digest = $ctx->hexdigest; $ctx = Digest::MD5->new; $ctx->add( join( ':', $method, $auth_uri ) ); my $A2_digest = $ctx->hexdigest; my $digest = Digest::MD5::md5_hex( join( ':', $A1_digest, $nonce, $qop ? ( $nc, $cnonce, $qop ) : (), $A2_digest ) ); $response = qq{Digest username="$username", realm="$realm", nonce="$nonce", uri="$auth_uri", qop=$qop, nc=$nc, cnonce="$cnonce", response="$digest", opaque="$opaque"}; } my $r = HTTP::Request->new( GET => "http://localhost" . $uri ); $mech->request($r); $r->headers->push_header( Authorization => $response ); $mech->request($r); if ($fail) { is( $mech->status, 400, "status is 400" ); } else { is( $mech->status, 200, "status is 200" ); $mech->content_contains( $username, "Mufasa output" ); } } do_test('Mufasa'); do_test('Mufasa2'); # Test with query string do_test('Mufasa2', '/moose?moose_id=1'); # Test with query string, emulating .NET, which omits the query string # from the Authorization header do_test('Mufasa2', '/moose?moose_id=1', 1); # Test with query string, emulating .NET, against app without .NET setting; # authorization should fail do_test('Mufasa2', '/moose?moose_id=1', 1, 1); Catalyst-Authentication-Credential-HTTP-1.016/t/lib/PaxHeader/AuthDigestDotnetTestApp000755 777777 777777 00000000213 12175027621 033013 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221750 18 SCHILY.nlink=3 Catalyst-Authentication-Credential-HTTP-1.016/t/lib/AuthDigestDotnetTestApp/000755 €;Ðâp€tzÕß00000000000 12175027621 032573 5ustar00tdoranAD\Domain Users000000 000000 Catalyst-Authentication-Credential-HTTP-1.016/t/lib/PaxHeader/AuthDigestDotnetTestApp.pm000644 777777 777777 00000000213 12175022324 033416 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374954783 23 SCHILY.dev=16777218 22 SCHILY.ino=4217200 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/t/lib/AuthDigestDotnetTestApp.pm000644 €;Ðâp€tzÕß00000002042 12175022324 033122 0ustar00tdoranAD\Domain Users000000 000000 package AuthDigestDotnetTestApp; use Catalyst qw/ Authentication Cache /; our %users; my $digest_pass = Digest::MD5->new; $digest_pass->add('Mufasa2:testrealm@host.com:Circle Of Life'); %users = ( Mufasa => { pass => "Circle Of Life", }, Mufasa2 => { pass => $digest_pass->hexdigest, }, ); __PACKAGE__->config( cache => { backend => { class => 'Cache::FileCache', }, }, authentication => { default_realm => 'testrealm@host.com', realms => { 'testrealm@host.com' => { store => { class => 'Minimal', users => \%users, }, credential => { class => 'HTTP', type => 'digest', password_type => 'clear', password_field => 'pass', broken_dotnet_digest_without_query_string => 1, }, }, }, }, ); __PACKAGE__->setup; 1; Catalyst-Authentication-Credential-HTTP-1.016/t/lib/PaxHeader/AuthDigestTestApp000755 777777 777777 00000000213 12175027621 031635 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221722 18 SCHILY.nlink=3 Catalyst-Authentication-Credential-HTTP-1.016/t/lib/AuthDigestTestApp/000755 €;Ðâp€tzÕß00000000000 12175027621 031415 5ustar00tdoranAD\Domain Users000000 000000 Catalyst-Authentication-Credential-HTTP-1.016/t/lib/PaxHeader/AuthDigestTestApp.pm000644 777777 777777 00000000213 12175022324 032240 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374954783 23 SCHILY.dev=16777218 22 SCHILY.ino=4217204 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/t/lib/AuthDigestTestApp.pm000644 €;Ðâp€tzÕß00000001727 12175022324 031755 0ustar00tdoranAD\Domain Users000000 000000 package AuthDigestTestApp; use Catalyst qw/ Authentication Cache /; our %users; my $digest_pass = Digest::MD5->new; $digest_pass->add('Mufasa2:testrealm@host.com:Circle Of Life'); %users = ( Mufasa => { pass => "Circle Of Life", }, Mufasa2 => { pass => $digest_pass->hexdigest, }, ); __PACKAGE__->config( cache => { backend => { class => 'Cache::FileCache', }, }, authentication => { default_realm => 'testrealm@host.com', realms => { 'testrealm@host.com' => { store => { class => 'Minimal', users => \%users, }, credential => { class => 'HTTP', type => 'digest', password_type => 'clear', password_field => 'pass' }, }, }, }, ); __PACKAGE__->setup; 1; Catalyst-Authentication-Credential-HTTP-1.016/t/lib/PaxHeader/AuthTestApp000755 777777 777777 00000000213 12175027621 030475 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221738 18 SCHILY.nlink=3 Catalyst-Authentication-Credential-HTTP-1.016/t/lib/AuthTestApp/000755 €;Ðâp€tzÕß00000000000 12175027621 030255 5ustar00tdoranAD\Domain Users000000 000000 Catalyst-Authentication-Credential-HTTP-1.016/t/lib/PaxHeader/AuthTestApp.pm000644 777777 777777 00000000213 12175022324 031100 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957456 23 SCHILY.dev=16777218 22 SCHILY.ino=4217208 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/t/lib/AuthTestApp.pm000644 €;Ðâp€tzÕß00000001115 12175022324 030604 0ustar00tdoranAD\Domain Users000000 000000 package AuthTestApp; use Catalyst qw/ Authentication /; our %users; __PACKAGE__->config( 'Plugin::Authentication' => { default_realm => 'test', test => { store => { class => 'Minimal', users => \%users, }, credential => { class => 'HTTP', type => 'basic', password_type => 'clear', password_field => 'password' }, }, }, ); %users = ( foo => { password => "s3cr3t", }, ); __PACKAGE__->setup; 1; Catalyst-Authentication-Credential-HTTP-1.016/t/lib/AuthTestApp/PaxHeader/Controller000755 777777 777777 00000000213 12175027621 032620 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221739 18 SCHILY.nlink=3 Catalyst-Authentication-Credential-HTTP-1.016/t/lib/AuthTestApp/Controller/000755 €;Ðâp€tzÕß00000000000 12175027621 032400 5ustar00tdoranAD\Domain Users000000 000000 Catalyst-Authentication-Credential-HTTP-1.016/t/lib/AuthTestApp/Controller/PaxHeader/Root.pm000644 777777 777777 00000000213 12175022324 034146 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957456 23 SCHILY.dev=16777218 22 SCHILY.ino=4217211 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/t/lib/AuthTestApp/Controller/Root.pm000644 €;Ðâp€tzÕß00000000462 12175022324 033656 0ustar00tdoranAD\Domain Users000000 000000 package AuthTestApp::Controller::Root; use strict; use warnings; use base qw/ Catalyst::Controller /; __PACKAGE__->config( namespace => '' ); sub auto : Private { my ($self, $c) = @_; $c->authenticate(); } sub moose : Local { my ( $self, $c ) = @_; $c->res->body( $c->user->id ); } 1; Catalyst-Authentication-Credential-HTTP-1.016/t/lib/AuthDigestTestApp/PaxHeader/Controller000755 777777 777777 00000000213 12175027621 033760 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221723 18 SCHILY.nlink=3 Catalyst-Authentication-Credential-HTTP-1.016/t/lib/AuthDigestTestApp/Controller/000755 €;Ðâp€tzÕß00000000000 12175027621 033540 5ustar00tdoranAD\Domain Users000000 000000 Catalyst-Authentication-Credential-HTTP-1.016/t/lib/AuthDigestTestApp/Controller/PaxHeader/Root.pm000644 777777 777777 00000000213 12175022324 035306 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374954783 23 SCHILY.dev=16777218 22 SCHILY.ino=4217207 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/t/lib/AuthDigestTestApp/Controller/Root.pm000644 €;Ðâp€tzÕß00000000502 12175022324 035011 0ustar00tdoranAD\Domain Users000000 000000 package AuthDigestTestApp::Controller::Root; use strict; use warnings; use base qw/ Catalyst::Controller /; __PACKAGE__->config(namespace => ''); sub moose : Local { my ( $self, $c ) = @_; #$c->authenticate( { realm => 'testrealm@host.com' } ); $c->authenticate(); $c->res->body( $c->user->id ); } 1; Catalyst-Authentication-Credential-HTTP-1.016/t/lib/AuthDigestDotnetTestApp/PaxHeader/Controller000755 777777 777777 00000000213 12175027621 035136 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221751 18 SCHILY.nlink=3 Catalyst-Authentication-Credential-HTTP-1.016/t/lib/AuthDigestDotnetTestApp/Controller/000755 €;Ðâp€tzÕß00000000000 12175027621 034716 5ustar00tdoranAD\Domain Users000000 000000 t/lib/AuthDigestDotnetTestApp/Controller/PaxHeader/Root.pm000644 777777 777777 00000000213 12175022324 036405 xustar00tdoranAD\Domain Users000000 000000 Catalyst-Authentication-Credential-HTTP-1.01618 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374954783 23 SCHILY.dev=16777218 22 SCHILY.ino=4217203 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/t/lib/AuthDigestDotnetTestApp/Controller/Root.pm000644 €;Ðâp€tzÕß00000000510 12175022324 036166 0ustar00tdoranAD\Domain Users000000 000000 package AuthDigestDotnetTestApp::Controller::Root; use strict; use warnings; use base qw/ Catalyst::Controller /; __PACKAGE__->config(namespace => ''); sub moose : Local { my ( $self, $c ) = @_; #$c->authenticate( { realm => 'testrealm@host.com' } ); $c->authenticate(); $c->res->body( $c->user->id ); } 1; Catalyst-Authentication-Credential-HTTP-1.016/t/author/PaxHeader/pod.t000644 777777 777777 00000000213 12175022324 030043 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957429 23 SCHILY.dev=16777218 22 SCHILY.ino=4217195 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/t/author/pod.t000644 €;Ðâp€tzÕß00000000072 12175022324 027550 0ustar00tdoranAD\Domain Users000000 000000 use Test::More; use Test::Pod 1.14; all_pod_files_ok(); Catalyst-Authentication-Credential-HTTP-1.016/t/author/PaxHeader/pod_spelling.t000644 777777 777777 00000000213 12175022324 031740 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957430 23 SCHILY.dev=16777218 22 SCHILY.ino=4217196 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/t/author/pod_spelling.t000644 €;Ðâp€tzÕß00000000536 12175022324 031452 0ustar00tdoranAD\Domain Users000000 000000 #!perl -w use strict; use warnings; use Test::More; use Test::Spelling 0.11; set_spell_cmd('aspell list'); add_stopwords( grep { defined $_ && length $_ } ); all_pod_files_spelling_ok(); __DATA__ Kimball rfc uri APIs Sascha URI https dhoss behaviour Doran Kiefer Kogman Yuval auth username Authorization authorization sess init ok Corlett Catalyst-Authentication-Credential-HTTP-1.016/t/author/PaxHeader/podcoverage.t000644 777777 777777 00000000213 12175022324 031557 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957430 23 SCHILY.dev=16777218 22 SCHILY.ino=4217197 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/t/author/podcoverage.t000644 €;Ðâp€tzÕß00000000107 12175022324 031263 0ustar00tdoranAD\Domain Users000000 000000 use Test::More; use Test::Pod::Coverage 1.04; all_pod_coverage_ok(); Catalyst-Authentication-Credential-HTTP-1.016/lib/PaxHeader/Catalyst000755 777777 777777 00000000213 12175027621 027614 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221745 18 SCHILY.nlink=3 Catalyst-Authentication-Credential-HTTP-1.016/lib/Catalyst/000755 €;Ðâp€tzÕß00000000000 12175027621 027374 5ustar00tdoranAD\Domain Users000000 000000 Catalyst-Authentication-Credential-HTTP-1.016/lib/Catalyst/PaxHeader/Authentication000755 777777 777777 00000000213 12175027621 032573 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221746 18 SCHILY.nlink=3 Catalyst-Authentication-Credential-HTTP-1.016/lib/Catalyst/Authentication/000755 €;Ðâp€tzÕß00000000000 12175027621 032353 5ustar00tdoranAD\Domain Users000000 000000 Catalyst-Authentication-Credential-HTTP-1.016/lib/Catalyst/Authentication/PaxHeader/Credential000755 777777 777777 00000000213 12175027621 034645 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221747 18 SCHILY.nlink=3 Catalyst-Authentication-Credential-HTTP-1.016/lib/Catalyst/Authentication/Credential/000755 €;Ðâp€tzÕß00000000000 12175027621 034425 5ustar00tdoranAD\Domain Users000000 000000 lib/Catalyst/Authentication/Credential/PaxHeader/HTTP.pm000644 777777 777777 00000000213 12175022533 035752 xustar00tdoranAD\Domain Users000000 000000 Catalyst-Authentication-Credential-HTTP-1.01618 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957453 23 SCHILY.dev=16777218 22 SCHILY.ino=4217275 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/lib/Catalyst/Authentication/Credential/HTTP.pm000644 €;Ðâp€tzÕß00000051146 12175022533 035546 0ustar00tdoranAD\Domain Users000000 000000 package Catalyst::Authentication::Credential::HTTP; use base qw/Catalyst::Authentication::Credential::Password/; use strict; use warnings; use String::Escape (); use URI::Escape (); use Catalyst (); use Digest::MD5 (); __PACKAGE__->mk_accessors(qw/ _config authorization_required_message password_field username_field type realm algorithm use_uri_for no_unprompted_authorization_required require_ssl broken_dotnet_digest_without_query_string /); our $VERSION = '1.016'; sub new { my ($class, $config, $app, $realm) = @_; $config->{username_field} ||= 'username'; # _config is shity back-compat with our base class. my $self = { %$config, _config => $config, _debug => $app->debug ? 1 : 0 }; bless $self, $class; $self->realm($realm); $self->init; return $self; } sub init { my ($self) = @_; my $type = $self->type || 'any'; if (!grep /$type/, ('basic', 'digest', 'any')) { Catalyst::Exception->throw(__PACKAGE__ . " used with unsupported authentication type: " . $type); } $self->type($type); } sub authenticate { my ( $self, $c, $realm, $auth_info ) = @_; my $auth; $self->authentication_failed( $c, $realm, $auth_info ) if $self->require_ssl ? $c->req->base->scheme ne 'https' : 0; $auth = $self->authenticate_digest($c, $realm, $auth_info) if $self->_is_http_auth_type('digest'); return $auth if $auth; $auth = $self->authenticate_basic($c, $realm, $auth_info) if $self->_is_http_auth_type('basic'); return $auth if $auth; $self->authentication_failed( $c, $realm, $auth_info ); } sub authentication_failed { my ( $self, $c, $realm, $auth_info ) = @_; unless ($self->no_unprompted_authorization_required) { $self->authorization_required_response($c, $realm, $auth_info); die $Catalyst::DETACH; } } sub authenticate_basic { my ( $self, $c, $realm, $auth_info ) = @_; $c->log->debug('Checking http basic authentication.') if $c->debug; my $headers = $c->req->headers; if ( my ( $username, $password ) = $headers->authorization_basic ) { my $user_obj = $realm->find_user( { $self->username_field => $username }, $c); if (ref($user_obj)) { my $opts = {}; $opts->{$self->password_field} = $password if $self->password_field; if ($self->check_password($user_obj, $opts)) { return $user_obj; } else { $c->log->debug("Password mismatch!") if $c->debug; return; } } else { $c->log->debug("Unable to locate user matching user info provided") if $c->debug; return; } } return; } sub authenticate_digest { my ( $self, $c, $realm, $auth_info ) = @_; $c->log->debug('Checking http digest authentication.') if $c->debug; my $headers = $c->req->headers; my @authorization = $headers->header('Authorization'); foreach my $authorization (@authorization) { next unless $authorization =~ m{^Digest}; my %res = map { my @key_val = split /=/, $_, 2; $key_val[0] = lc $key_val[0]; $key_val[1] =~ s{"}{}g; # remove the quotes @key_val; } split /,\s?/, substr( $authorization, 7 ); #7 == length "Digest " my $opaque = $res{opaque}; my $nonce = $self->get_digest_authorization_nonce( $c, __PACKAGE__ . '::opaque:' . $opaque ); next unless $nonce; $c->log->debug('Checking authentication parameters.') if $c->debug; my $uri = $c->request->uri->path_query; my $algorithm = $res{algorithm} || 'MD5'; my $nonce_count = '0x' . $res{nc}; my $check = ($uri eq $res{uri} || ($self->broken_dotnet_digest_without_query_string && $c->request->uri->path eq $res{uri})) && ( exists $res{username} ) && ( exists $res{qop} ) && ( exists $res{cnonce} ) && ( exists $res{nc} ) && $algorithm eq $nonce->algorithm && hex($nonce_count) > hex( $nonce->nonce_count ) && $res{nonce} eq $nonce->nonce; # TODO: set Stale instead unless ($check) { $c->log->debug('Digest authentication failed. Bad request.') if $c->debug; $c->res->status(400); # bad request Carp::confess $Catalyst::DETACH; } $c->log->debug('Checking authentication response.') if $c->debug; my $username = $res{username}; my $user_obj; unless ( $user_obj = $auth_info->{user} ) { $user_obj = $realm->find_user( { $self->username_field => $username }, $c); } unless ($user_obj) { # no user, no authentication $c->log->debug("Unable to locate user matching user info provided") if $c->debug; return; } # everything looks good, let's check the response # calculate H(A2) as per spec my $ctx = Digest::MD5->new; $ctx->add( join( ':', $c->request->method, $res{uri} ) ); if ( $res{qop} eq 'auth-int' ) { my $digest = Digest::MD5::md5_hex( $c->request->body ); # not sure here $ctx->add( ':', $digest ); } my $A2_digest = $ctx->hexdigest; # the idea of the for loop: # if we do not want to store the plain password in our user store, # we can store md5_hex("$username:$realm:$password") instead my $password_field = $self->password_field; for my $r ( 0 .. 1 ) { # calculate H(A1) as per spec my $A1_digest = $r ? $user_obj->$password_field() : do { $ctx = Digest::MD5->new; $ctx->add( join( ':', $username, $realm->name, $user_obj->$password_field() ) ); $ctx->hexdigest; }; if ( $nonce->algorithm eq 'MD5-sess' ) { $ctx = Digest::MD5->new; $ctx->add( join( ':', $A1_digest, $res{nonce}, $res{cnonce} ) ); $A1_digest = $ctx->hexdigest; } my $digest_in = join( ':', $A1_digest, $res{nonce}, $res{qop} ? ( $res{nc}, $res{cnonce}, $res{qop} ) : (), $A2_digest ); my $rq_digest = Digest::MD5::md5_hex($digest_in); $nonce->nonce_count($nonce_count); my $key = __PACKAGE__ . '::opaque:' . $nonce->opaque; $self->store_digest_authorization_nonce( $c, $key, $nonce ); if ($rq_digest eq $res{response}) { return $user_obj; } } } return; } sub _check_cache { my $c = shift; die "A cache is needed for http digest authentication." unless $c->can('cache'); return; } sub _is_http_auth_type { my ( $self, $type ) = @_; my $cfgtype = lc( $self->type ); return 1 if $cfgtype eq 'any' || $cfgtype eq lc $type; return 0; } sub authorization_required_response { my ( $self, $c, $realm, $auth_info ) = @_; $c->res->status(401); $c->res->content_type('text/plain'); if (exists $self->{authorization_required_message}) { # If you set the key to undef, don't stamp on the body. $c->res->body($self->authorization_required_message) if defined $self->authorization_required_message; } else { $c->res->body('Authorization required.'); } # *DONT* short circuit my $ok; $ok++ if $self->_create_digest_auth_response($c, $auth_info); $ok++ if $self->_create_basic_auth_response($c, $auth_info); unless ( $ok ) { die 'Could not build authorization required response. ' . 'Did you configure a valid authentication http type: ' . 'basic, digest, any'; } return; } sub _add_authentication_header { my ( $c, $header ) = @_; $c->response->headers->push_header( 'WWW-Authenticate' => $header ); return; } sub _create_digest_auth_response { my ( $self, $c, $opts ) = @_; return unless $self->_is_http_auth_type('digest'); if ( my $digest = $self->_build_digest_auth_header( $c, $opts ) ) { _add_authentication_header( $c, $digest ); return 1; } return; } sub _create_basic_auth_response { my ( $self, $c, $opts ) = @_; return unless $self->_is_http_auth_type('basic'); if ( my $basic = $self->_build_basic_auth_header( $c, $opts ) ) { _add_authentication_header( $c, $basic ); return 1; } return; } sub _build_auth_header_realm { my ( $self, $c, $opts ) = @_; if ( my $realm_name = String::Escape::qprintable($opts->{realm} ? $opts->{realm} : $self->realm->name) ) { $realm_name = qq{"$realm_name"} unless $realm_name =~ /^"/; return 'realm=' . $realm_name; } return; } sub _build_auth_header_domain { my ( $self, $c, $opts ) = @_; if ( my $domain = $opts->{domain} ) { Catalyst::Exception->throw("domain must be an array reference") unless ref($domain) && ref($domain) eq "ARRAY"; my @uris = $self->use_uri_for ? ( map { $c->uri_for($_) } @$domain ) : ( map { URI::Escape::uri_escape($_) } @$domain ); return qq{domain="@uris"}; } return; } sub _build_auth_header_common { my ( $self, $c, $opts ) = @_; return ( $self->_build_auth_header_realm($c, $opts), $self->_build_auth_header_domain($c, $opts), ); } sub _build_basic_auth_header { my ( $self, $c, $opts ) = @_; return _join_auth_header_parts( Basic => $self->_build_auth_header_common( $c, $opts ) ); } sub _build_digest_auth_header { my ( $self, $c, $opts ) = @_; my $nonce = $self->_digest_auth_nonce($c, $opts); my $key = __PACKAGE__ . '::opaque:' . $nonce->opaque; $self->store_digest_authorization_nonce( $c, $key, $nonce ); return _join_auth_header_parts( Digest => $self->_build_auth_header_common($c, $opts), map { sprintf '%s="%s"', $_, $nonce->$_ } qw( qop nonce opaque algorithm ), ); } sub _digest_auth_nonce { my ( $self, $c, $opts ) = @_; my $package = __PACKAGE__ . '::Nonce'; my $nonce = $package->new; if ( my $algorithm = $opts->{algorithm} || $self->algorithm) { $nonce->algorithm( $algorithm ); } return $nonce; } sub _join_auth_header_parts { my ( $type, @parts ) = @_; return "$type " . join(", ", @parts ); } sub get_digest_authorization_nonce { my ( $self, $c, $key ) = @_; _check_cache($c); return $c->cache->get( $key ); } sub store_digest_authorization_nonce { my ( $self, $c, $key, $nonce ) = @_; _check_cache($c); return $c->cache->set( $key, $nonce ); } package Catalyst::Authentication::Credential::HTTP::Nonce; use strict; use base qw[ Class::Accessor::Fast ]; use Data::UUID (); our $VERSION = '0.02'; __PACKAGE__->mk_accessors(qw[ nonce nonce_count qop opaque algorithm ]); sub new { my $class = shift; my $self = $class->SUPER::new(@_); $self->nonce( Data::UUID->new->create_b64 ); $self->opaque( Data::UUID->new->create_b64 ); $self->qop('auth,auth-int'); $self->nonce_count('0x0'); $self->algorithm('MD5'); return $self; } 1; __END__ =pod =head1 NAME Catalyst::Authentication::Credential::HTTP - HTTP Basic and Digest authentication for Catalyst. =head1 SYNOPSIS use Catalyst qw/ Authentication /; __PACKAGE__->config( authentication => { default_realm => 'example', realms => { example => { credential => { class => 'HTTP', type => 'any', # or 'digest' or 'basic' password_type => 'clear', password_field => 'password' }, store => { class => 'Minimal', users => { Mufasa => { password => "Circle Of Life", }, }, }, }, } }); sub foo : Local { my ( $self, $c ) = @_; $c->authenticate({}, "example"); # either user gets authenticated or 401 is sent # Note that the authentication realm sent to the client (in the # RFC 2617 sense) is overridden here, but this *does not* # effect the Catalyst::Authentication::Realm used for # authentication - to do that, you need # $c->authenticate({}, 'otherrealm') do_stuff(); } sub always_auth : Local { my ( $self, $c ) = @_; # Force authorization headers onto the response so that the user # is asked again for authentication, even if they successfully # authenticated. my $realm = $c->get_auth_realm('example'); $realm->credential->authorization_required_response($c, $realm); } # with ACL plugin __PACKAGE__->deny_access_unless("/path", sub { $_[0]->authenticate }); =head1 DESCRIPTION This module lets you use HTTP authentication with L. Both basic and digest authentication are currently supported. When authentication is required, this module sets a status of 401, and the body of the response to 'Authorization required.'. To override this and set your own content, check for the C<< $c->res->status == 401 >> in your C action, and change the body accordingly. =head2 TERMS =over 4 =item Nonce A nonce is a one-time value sent with each digest authentication request header. The value must always be unique, so per default the last value of the nonce is kept using L. To change this behaviour, override the C and C methods as shown below. =back =head1 METHODS =over 4 =item new $config, $c, $realm Simple constructor. =item init Validates that $config is ok. =item authenticate $c, $realm, \%auth_info Tries to authenticate the user, and if that fails calls C and detaches the current action call stack. Looks inside C<< $c->request->headers >> and processes the digest and basic (badly named) authorization header. This will only try the methods set in the configuration. First digest, then basic. The %auth_info hash can contain a number of keys which control the authentication behaviour: =over =item realm Sets the HTTP authentication realm presented to the client. Note this does not alter the Catalyst::Authentication::Realm object used for the authentication. =item domain Array reference to domains used to build the authorization headers. This list of domains defines the protection space. If a domain URI is an absolute path (starts with /), it is relative to the root URL of the server being accessed. An absolute URI in this list may refer to a different server than the one being accessed. The client will use this list to determine the set of URIs for which the same authentication information may be sent. If this is omitted or its value is empty, the client will assume that the protection space consists of all URIs on the responding server. Therefore, if your application is not hosted at the root of this domain, and you want to prevent the authentication credentials for this application being sent to any other applications. then you should use the I configuration option, and pass a domain of I. =back =item authenticate_basic $c, $realm, \%auth_info Performs HTTP basic authentication. =item authenticate_digest $c, $realm, \%auth_info Performs HTTP digest authentication. The password_type B be I for digest authentication to succeed. If you do not want to store your user passwords as clear text, you may instead store the MD5 digest in hex of the string '$username:$realm:$password'. L is used for persistent storage of the nonce values (see L). It must be loaded in your application, unless you override the C and C methods as shown below. Takes an additional parameter of I, the possible values of which are 'MD5' (the default) and 'MD5-sess'. For more information about 'MD5-sess', see section 3.2.2.2 in RFC 2617. =item authorization_required_response $c, $realm, \%auth_info Sets C<< $c->response >> to the correct status code, and adds the correct header to demand authentication data from the user agent. Typically used by C, but may be invoked manually. %opts can contain C and C, which are used to build %the digest header. =item store_digest_authorization_nonce $c, $key, $nonce =item get_digest_authorization_nonce $c, $key Set or get the C<$nonce> object used by the digest auth mode. You may override these methods. By default they will call C and C on C<< $c->cache >>. =item authentication_failed Sets the 401 response and calls C<< $ctx->detach >>. =back =head1 CONFIGURATION All configuration is stored in C<< YourApp->config('Plugin::Authentication' => { yourrealm => { credential => { class => 'HTTP', %config } } } >>. This should be a hash, and it can contain the following entries: =over =item type Can be either C (the default), C or C. This controls C and C, but not the "manual" methods. =item authorization_required_message Set this to a string to override the default body content "Authorization required.", or set to undef to suppress body content being generated. =item password_type The type of password returned by the user object. Same usage as in L =item password_field The name of accessor used to retrieve the value of the password field from the user object. Same usage as in L =item username_field The field name that the user's username is mapped into when finding the user from the realm. Defaults to 'username'. =item use_uri_for If this configuration key has a true value, then the domain(s) for the authorization header will be run through $c->uri_for(). Use this configuration option if your application is not running at the root of your domain, and you want to ensure that authentication credentials from your application are not shared with other applications on the same server. =item require_ssl If this configuration key has a true value then authentication will be denied (and a 401 issued in normal circumstances) unless the request is via https. =item no_unprompted_authorization_required Causes authentication to fail as normal modules do, without calling C<< $c->detach >>. This means that the basic auth credential can be used as part of the progressive realm. However use like this is probably not optimum it also means that users in browsers ill never get a HTTP authenticate dialogue box (unless you manually return a 401 response in your application), and even some automated user agents (for APIs) will not send the Authorization header without specific manipulation of the request headers. =item broken_dotnet_digest_without_query_string Enables support for .NET (or other similarly broken clients), which fails to include the query string in the uri in the digest Authorization header, contrary to rfc2617. This option has no effect on clients that include the query string; they will continue to work as normal. =back =head1 RESTRICTIONS When using digest authentication, this module will only work together with authentication stores whose User objects have a C method that returns the plain-text password. It will not work together with L, or L stores whose C methods return a hashed or salted version of the password. =head1 AUTHORS Updated to current name space and currently maintained by: Tomas Doran C. Original module by: =over =item Yuval Kogman, C =item Jess Robinson =item Sascha Kiefer C =back =head1 CONTRIBUTORS Patches contributed by: =over =item Peter Corlett =item Devin Austin (dhoss) C =item Ronald J Kimball =back =head1 SEE ALSO RFC 2617 (or its successors), L, L =head1 COPYRIGHT & LICENSE Copyright (c) 2005-2008 the aforementioned authors. All rights reserved. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut Catalyst-Authentication-Credential-HTTP-1.016/inc/PaxHeader/Module000755 777777 777777 00000000213 12175027621 027260 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221715 18 SCHILY.nlink=5 Catalyst-Authentication-Credential-HTTP-1.016/inc/Module/000755 €;Ðâp€tzÕß00000000000 12175027621 027040 5ustar00tdoranAD\Domain Users000000 000000 Catalyst-Authentication-Credential-HTTP-1.016/inc/Module/PaxHeader/AutoInstall.pm000644 777777 777777 00000000213 12175027561 032132 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957453 23 SCHILY.dev=16777218 22 SCHILY.ino=4221578 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/inc/Module/AutoInstall.pm000644 €;Ðâp€tzÕß00000062162 12175027561 031647 0ustar00tdoranAD\Domain Users000000 000000 #line 1 package Module::AutoInstall; use strict; use Cwd (); use File::Spec (); use ExtUtils::MakeMaker (); use vars qw{$VERSION}; BEGIN { $VERSION = '1.06'; } # special map on pre-defined feature sets my %FeatureMap = ( '' => 'Core Features', # XXX: deprecated '-core' => 'Core Features', ); # various lexical flags my ( @Missing, @Existing, %DisabledTests, $UnderCPAN, $InstallDepsTarget, $HasCPANPLUS ); my ( $Config, $CheckOnly, $SkipInstall, $AcceptDefault, $TestOnly, $AllDeps, $UpgradeDeps ); my ( $PostambleActions, $PostambleActionsNoTest, $PostambleActionsUpgradeDeps, $PostambleActionsUpgradeDepsNoTest, $PostambleActionsListDeps, $PostambleActionsListAllDeps, $PostambleUsed, $NoTest); # See if it's a testing or non-interactive session _accept_default( $ENV{AUTOMATED_TESTING} or ! -t STDIN ); _init(); sub _accept_default { $AcceptDefault = shift; } sub _installdeps_target { $InstallDepsTarget = shift; } sub missing_modules { return @Missing; } sub do_install { __PACKAGE__->install( [ $Config ? ( UNIVERSAL::isa( $Config, 'HASH' ) ? %{$Config} : @{$Config} ) : () ], @Missing, ); } # initialize various flags, and/or perform install sub _init { foreach my $arg ( @ARGV, split( /[\s\t]+/, $ENV{PERL_AUTOINSTALL} || $ENV{PERL_EXTUTILS_AUTOINSTALL} || '' ) ) { if ( $arg =~ /^--config=(.*)$/ ) { $Config = [ split( ',', $1 ) ]; } elsif ( $arg =~ /^--installdeps=(.*)$/ ) { __PACKAGE__->install( $Config, @Missing = split( /,/, $1 ) ); exit 0; } elsif ( $arg =~ /^--upgradedeps=(.*)$/ ) { $UpgradeDeps = 1; __PACKAGE__->install( $Config, @Missing = split( /,/, $1 ) ); exit 0; } elsif ( $arg =~ /^--default(?:deps)?$/ ) { $AcceptDefault = 1; } elsif ( $arg =~ /^--check(?:deps)?$/ ) { $CheckOnly = 1; } elsif ( $arg =~ /^--skip(?:deps)?$/ ) { $SkipInstall = 1; } elsif ( $arg =~ /^--test(?:only)?$/ ) { $TestOnly = 1; } elsif ( $arg =~ /^--all(?:deps)?$/ ) { $AllDeps = 1; } } } # overrides MakeMaker's prompt() to automatically accept the default choice sub _prompt { goto &ExtUtils::MakeMaker::prompt unless $AcceptDefault; my ( $prompt, $default ) = @_; my $y = ( $default =~ /^[Yy]/ ); print $prompt, ' [', ( $y ? 'Y' : 'y' ), '/', ( $y ? 'n' : 'N' ), '] '; print "$default\n"; return $default; } # the workhorse sub import { my $class = shift; my @args = @_ or return; my $core_all; print "*** $class version " . $class->VERSION . "\n"; print "*** Checking for Perl dependencies...\n"; my $cwd = Cwd::cwd(); $Config = []; my $maxlen = length( ( sort { length($b) <=> length($a) } grep { /^[^\-]/ } map { ref($_) ? ( ( ref($_) eq 'HASH' ) ? keys(%$_) : @{$_} ) : '' } map { +{@args}->{$_} } grep { /^[^\-]/ or /^-core$/i } keys %{ +{@args} } )[0] ); # We want to know if we're under CPAN early to avoid prompting, but # if we aren't going to try and install anything anyway then skip the # check entirely since we don't want to have to load (and configure) # an old CPAN just for a cosmetic message $UnderCPAN = _check_lock(1) unless $SkipInstall || $InstallDepsTarget; while ( my ( $feature, $modules ) = splice( @args, 0, 2 ) ) { my ( @required, @tests, @skiptests ); my $default = 1; my $conflict = 0; if ( $feature =~ m/^-(\w+)$/ ) { my $option = lc($1); # check for a newer version of myself _update_to( $modules, @_ ) and return if $option eq 'version'; # sets CPAN configuration options $Config = $modules if $option eq 'config'; # promote every features to core status $core_all = ( $modules =~ /^all$/i ) and next if $option eq 'core'; next unless $option eq 'core'; } print "[" . ( $FeatureMap{ lc($feature) } || $feature ) . "]\n"; $modules = [ %{$modules} ] if UNIVERSAL::isa( $modules, 'HASH' ); unshift @$modules, -default => &{ shift(@$modules) } if ( ref( $modules->[0] ) eq 'CODE' ); # XXX: bugward combatability while ( my ( $mod, $arg ) = splice( @$modules, 0, 2 ) ) { if ( $mod =~ m/^-(\w+)$/ ) { my $option = lc($1); $default = $arg if ( $option eq 'default' ); $conflict = $arg if ( $option eq 'conflict' ); @tests = @{$arg} if ( $option eq 'tests' ); @skiptests = @{$arg} if ( $option eq 'skiptests' ); next; } printf( "- %-${maxlen}s ...", $mod ); if ( $arg and $arg =~ /^\D/ ) { unshift @$modules, $arg; $arg = 0; } # XXX: check for conflicts and uninstalls(!) them. my $cur = _version_of($mod); if (_version_cmp ($cur, $arg) >= 0) { print "loaded. ($cur" . ( $arg ? " >= $arg" : '' ) . ")\n"; push @Existing, $mod => $arg; $DisabledTests{$_} = 1 for map { glob($_) } @skiptests; } else { if (not defined $cur) # indeed missing { print "missing." . ( $arg ? " (would need $arg)" : '' ) . "\n"; } else { # no need to check $arg as _version_cmp ($cur, undef) would satisfy >= above print "too old. ($cur < $arg)\n"; } push @required, $mod => $arg; } } next unless @required; my $mandatory = ( $feature eq '-core' or $core_all ); if ( !$SkipInstall and ( $CheckOnly or ($mandatory and $UnderCPAN) or $AllDeps or $InstallDepsTarget or _prompt( qq{==> Auto-install the } . ( @required / 2 ) . ( $mandatory ? ' mandatory' : ' optional' ) . qq{ module(s) from CPAN?}, $default ? 'y' : 'n', ) =~ /^[Yy]/ ) ) { push( @Missing, @required ); $DisabledTests{$_} = 1 for map { glob($_) } @skiptests; } elsif ( !$SkipInstall and $default and $mandatory and _prompt( qq{==> The module(s) are mandatory! Really skip?}, 'n', ) =~ /^[Nn]/ ) { push( @Missing, @required ); $DisabledTests{$_} = 1 for map { glob($_) } @skiptests; } else { $DisabledTests{$_} = 1 for map { glob($_) } @tests; } } if ( @Missing and not( $CheckOnly or $UnderCPAN) ) { require Config; my $make = $Config::Config{make}; if ($InstallDepsTarget) { print "*** To install dependencies type '$make installdeps' or '$make installdeps_notest'.\n"; } else { print "*** Dependencies will be installed the next time you type '$make'.\n"; } # make an educated guess of whether we'll need root permission. print " (You may need to do that as the 'root' user.)\n" if eval '$>'; } print "*** $class configuration finished.\n"; chdir $cwd; # import to main:: no strict 'refs'; *{'main::WriteMakefile'} = \&Write if caller(0) eq 'main'; return (@Existing, @Missing); } sub _running_under { my $thing = shift; print <<"END_MESSAGE"; *** Since we're running under ${thing}, I'll just let it take care of the dependency's installation later. END_MESSAGE return 1; } # Check to see if we are currently running under CPAN.pm and/or CPANPLUS; # if we are, then we simply let it taking care of our dependencies sub _check_lock { return unless @Missing or @_; if ($ENV{PERL5_CPANM_IS_RUNNING}) { return _running_under('cpanminus'); } my $cpan_env = $ENV{PERL5_CPAN_IS_RUNNING}; if ($ENV{PERL5_CPANPLUS_IS_RUNNING}) { return _running_under($cpan_env ? 'CPAN' : 'CPANPLUS'); } require CPAN; if ($CPAN::VERSION > '1.89') { if ($cpan_env) { return _running_under('CPAN'); } return; # CPAN.pm new enough, don't need to check further } # last ditch attempt, this -will- configure CPAN, very sorry _load_cpan(1); # force initialize even though it's already loaded # Find the CPAN lock-file my $lock = MM->catfile( $CPAN::Config->{cpan_home}, ".lock" ); return unless -f $lock; # Check the lock local *LOCK; return unless open(LOCK, $lock); if ( ( $^O eq 'MSWin32' ? _under_cpan() : == getppid() ) and ( $CPAN::Config->{prerequisites_policy} || '' ) ne 'ignore' ) { print <<'END_MESSAGE'; *** Since we're running under CPAN, I'll just let it take care of the dependency's installation later. END_MESSAGE return 1; } close LOCK; return; } sub install { my $class = shift; my $i; # used below to strip leading '-' from config keys my @config = ( map { s/^-// if ++$i; $_ } @{ +shift } ); my ( @modules, @installed ); while ( my ( $pkg, $ver ) = splice( @_, 0, 2 ) ) { # grep out those already installed if ( _version_cmp( _version_of($pkg), $ver ) >= 0 ) { push @installed, $pkg; } else { push @modules, $pkg, $ver; } } if ($UpgradeDeps) { push @modules, @installed; @installed = (); } return @installed unless @modules; # nothing to do return @installed if _check_lock(); # defer to the CPAN shell print "*** Installing dependencies...\n"; return unless _connected_to('cpan.org'); my %args = @config; my %failed; local *FAILED; if ( $args{do_once} and open( FAILED, '.#autoinstall.failed' ) ) { while () { chomp; $failed{$_}++ } close FAILED; my @newmod; while ( my ( $k, $v ) = splice( @modules, 0, 2 ) ) { push @newmod, ( $k => $v ) unless $failed{$k}; } @modules = @newmod; } if ( _has_cpanplus() and not $ENV{PERL_AUTOINSTALL_PREFER_CPAN} ) { _install_cpanplus( \@modules, \@config ); } else { _install_cpan( \@modules, \@config ); } print "*** $class installation finished.\n"; # see if we have successfully installed them while ( my ( $pkg, $ver ) = splice( @modules, 0, 2 ) ) { if ( _version_cmp( _version_of($pkg), $ver ) >= 0 ) { push @installed, $pkg; } elsif ( $args{do_once} and open( FAILED, '>> .#autoinstall.failed' ) ) { print FAILED "$pkg\n"; } } close FAILED if $args{do_once}; return @installed; } sub _install_cpanplus { my @modules = @{ +shift }; my @config = _cpanplus_config( @{ +shift } ); my $installed = 0; require CPANPLUS::Backend; my $cp = CPANPLUS::Backend->new; my $conf = $cp->configure_object; return unless $conf->can('conf') # 0.05x+ with "sudo" support or _can_write($conf->_get_build('base')); # 0.04x # if we're root, set UNINST=1 to avoid trouble unless user asked for it. my $makeflags = $conf->get_conf('makeflags') || ''; if ( UNIVERSAL::isa( $makeflags, 'HASH' ) ) { # 0.03+ uses a hashref here $makeflags->{UNINST} = 1 unless exists $makeflags->{UNINST}; } else { # 0.02 and below uses a scalar $makeflags = join( ' ', split( ' ', $makeflags ), 'UNINST=1' ) if ( $makeflags !~ /\bUNINST\b/ and eval qq{ $> eq '0' } ); } $conf->set_conf( makeflags => $makeflags ); $conf->set_conf( prereqs => 1 ); while ( my ( $key, $val ) = splice( @config, 0, 2 ) ) { $conf->set_conf( $key, $val ); } my $modtree = $cp->module_tree; while ( my ( $pkg, $ver ) = splice( @modules, 0, 2 ) ) { print "*** Installing $pkg...\n"; MY::preinstall( $pkg, $ver ) or next if defined &MY::preinstall; my $success; my $obj = $modtree->{$pkg}; if ( $obj and _version_cmp( $obj->{version}, $ver ) >= 0 ) { my $pathname = $pkg; $pathname =~ s/::/\\W/; foreach my $inc ( grep { m/$pathname.pm/i } keys(%INC) ) { delete $INC{$inc}; } my $rv = $cp->install( modules => [ $obj->{module} ] ); if ( $rv and ( $rv->{ $obj->{module} } or $rv->{ok} ) ) { print "*** $pkg successfully installed.\n"; $success = 1; } else { print "*** $pkg installation cancelled.\n"; $success = 0; } $installed += $success; } else { print << "."; *** Could not find a version $ver or above for $pkg; skipping. . } MY::postinstall( $pkg, $ver, $success ) if defined &MY::postinstall; } return $installed; } sub _cpanplus_config { my @config = (); while ( @_ ) { my ($key, $value) = (shift(), shift()); if ( $key eq 'prerequisites_policy' ) { if ( $value eq 'follow' ) { $value = CPANPLUS::Internals::Constants::PREREQ_INSTALL(); } elsif ( $value eq 'ask' ) { $value = CPANPLUS::Internals::Constants::PREREQ_ASK(); } elsif ( $value eq 'ignore' ) { $value = CPANPLUS::Internals::Constants::PREREQ_IGNORE(); } else { die "*** Cannot convert option $key = '$value' to CPANPLUS version.\n"; } push @config, 'prereqs', $value; } elsif ( $key eq 'force' ) { push @config, $key, $value; } elsif ( $key eq 'notest' ) { push @config, 'skiptest', $value; } else { die "*** Cannot convert option $key to CPANPLUS version.\n"; } } return @config; } sub _install_cpan { my @modules = @{ +shift }; my @config = @{ +shift }; my $installed = 0; my %args; _load_cpan(); require Config; if (CPAN->VERSION < 1.80) { # no "sudo" support, probe for writableness return unless _can_write( MM->catfile( $CPAN::Config->{cpan_home}, 'sources' ) ) and _can_write( $Config::Config{sitelib} ); } # if we're root, set UNINST=1 to avoid trouble unless user asked for it. my $makeflags = $CPAN::Config->{make_install_arg} || ''; $CPAN::Config->{make_install_arg} = join( ' ', split( ' ', $makeflags ), 'UNINST=1' ) if ( $makeflags !~ /\bUNINST\b/ and eval qq{ $> eq '0' } ); # don't show start-up info $CPAN::Config->{inhibit_startup_message} = 1; # set additional options while ( my ( $opt, $arg ) = splice( @config, 0, 2 ) ) { ( $args{$opt} = $arg, next ) if $opt =~ /^(?:force|notest)$/; # pseudo-option $CPAN::Config->{$opt} = $arg; } if ($args{notest} && (not CPAN::Shell->can('notest'))) { die "Your version of CPAN is too old to support the 'notest' pragma"; } local $CPAN::Config->{prerequisites_policy} = 'follow'; while ( my ( $pkg, $ver ) = splice( @modules, 0, 2 ) ) { MY::preinstall( $pkg, $ver ) or next if defined &MY::preinstall; print "*** Installing $pkg...\n"; my $obj = CPAN::Shell->expand( Module => $pkg ); my $success = 0; if ( $obj and _version_cmp( $obj->cpan_version, $ver ) >= 0 ) { my $pathname = $pkg; $pathname =~ s/::/\\W/; foreach my $inc ( grep { m/$pathname.pm/i } keys(%INC) ) { delete $INC{$inc}; } my $rv = do { if ($args{force}) { CPAN::Shell->force( install => $pkg ) } elsif ($args{notest}) { CPAN::Shell->notest( install => $pkg ) } else { CPAN::Shell->install($pkg) } }; $rv ||= eval { $CPAN::META->instance( 'CPAN::Distribution', $obj->cpan_file, ) ->{install} if $CPAN::META; }; if ( $rv eq 'YES' ) { print "*** $pkg successfully installed.\n"; $success = 1; } else { print "*** $pkg installation failed.\n"; $success = 0; } $installed += $success; } else { print << "."; *** Could not find a version $ver or above for $pkg; skipping. . } MY::postinstall( $pkg, $ver, $success ) if defined &MY::postinstall; } return $installed; } sub _has_cpanplus { return ( $HasCPANPLUS = ( $INC{'CPANPLUS/Config.pm'} or _load('CPANPLUS::Shell::Default') ) ); } # make guesses on whether we're under the CPAN installation directory sub _under_cpan { require Cwd; require File::Spec; my $cwd = File::Spec->canonpath( Cwd::cwd() ); my $cpan = File::Spec->canonpath( $CPAN::Config->{cpan_home} ); return ( index( $cwd, $cpan ) > -1 ); } sub _update_to { my $class = __PACKAGE__; my $ver = shift; return if _version_cmp( _version_of($class), $ver ) >= 0; # no need to upgrade if ( _prompt( "==> A newer version of $class ($ver) is required. Install?", 'y' ) =~ /^[Nn]/ ) { die "*** Please install $class $ver manually.\n"; } print << "."; *** Trying to fetch it from CPAN... . # install ourselves _load($class) and return $class->import(@_) if $class->install( [], $class, $ver ); print << '.'; exit 1; *** Cannot bootstrap myself. :-( Installation terminated. . } # check if we're connected to some host, using inet_aton sub _connected_to { my $site = shift; return ( ( _load('Socket') and Socket::inet_aton($site) ) or _prompt( qq( *** Your host cannot resolve the domain name '$site', which probably means the Internet connections are unavailable. ==> Should we try to install the required module(s) anyway?), 'n' ) =~ /^[Yy]/ ); } # check if a directory is writable; may create it on demand sub _can_write { my $path = shift; mkdir( $path, 0755 ) unless -e $path; return 1 if -w $path; print << "."; *** You are not allowed to write to the directory '$path'; the installation may fail due to insufficient permissions. . if ( eval '$>' and lc(`sudo -V`) =~ /version/ and _prompt( qq( ==> Should we try to re-execute the autoinstall process with 'sudo'?), ((-t STDIN) ? 'y' : 'n') ) =~ /^[Yy]/ ) { # try to bootstrap ourselves from sudo print << "."; *** Trying to re-execute the autoinstall process with 'sudo'... . my $missing = join( ',', @Missing ); my $config = join( ',', UNIVERSAL::isa( $Config, 'HASH' ) ? %{$Config} : @{$Config} ) if $Config; return unless system( 'sudo', $^X, $0, "--config=$config", "--installdeps=$missing" ); print << "."; *** The 'sudo' command exited with error! Resuming... . } return _prompt( qq( ==> Should we try to install the required module(s) anyway?), 'n' ) =~ /^[Yy]/; } # load a module and return the version it reports sub _load { my $mod = pop; # method/function doesn't matter my $file = $mod; $file =~ s|::|/|g; $file .= '.pm'; local $@; return eval { require $file; $mod->VERSION } || ( $@ ? undef: 0 ); } # report version without loading a module sub _version_of { my $mod = pop; # method/function doesn't matter my $file = $mod; $file =~ s|::|/|g; $file .= '.pm'; foreach my $dir ( @INC ) { next if ref $dir; my $path = File::Spec->catfile($dir, $file); next unless -e $path; require ExtUtils::MM_Unix; return ExtUtils::MM_Unix->parse_version($path); } return undef; } # Load CPAN.pm and it's configuration sub _load_cpan { return if $CPAN::VERSION and $CPAN::Config and not @_; require CPAN; # CPAN-1.82+ adds CPAN::Config::AUTOLOAD to redirect to # CPAN::HandleConfig->load. CPAN reports that the redirection # is deprecated in a warning printed at the user. # CPAN-1.81 expects CPAN::HandleConfig->load, does not have # $CPAN::HandleConfig::VERSION but cannot handle # CPAN::Config->load # Which "versions expect CPAN::Config->load? if ( $CPAN::HandleConfig::VERSION || CPAN::HandleConfig->can('load') ) { # Newer versions of CPAN have a HandleConfig module CPAN::HandleConfig->load; } else { # Older versions had the load method in Config directly CPAN::Config->load; } } # compare two versions, either use Sort::Versions or plain comparison # return values same as <=> sub _version_cmp { my ( $cur, $min ) = @_; return -1 unless defined $cur; # if 0 keep comparing return 1 unless $min; $cur =~ s/\s+$//; # check for version numbers that are not in decimal format if ( ref($cur) or ref($min) or $cur =~ /v|\..*\./ or $min =~ /v|\..*\./ ) { if ( ( $version::VERSION or defined( _load('version') )) and version->can('new') ) { # use version.pm if it is installed. return version->new($cur) <=> version->new($min); } elsif ( $Sort::Versions::VERSION or defined( _load('Sort::Versions') ) ) { # use Sort::Versions as the sorting algorithm for a.b.c versions return Sort::Versions::versioncmp( $cur, $min ); } warn "Cannot reliably compare non-decimal formatted versions.\n" . "Please install version.pm or Sort::Versions.\n"; } # plain comparison local $^W = 0; # shuts off 'not numeric' bugs return $cur <=> $min; } # nothing; this usage is deprecated. sub main::PREREQ_PM { return {}; } sub _make_args { my %args = @_; $args{PREREQ_PM} = { %{ $args{PREREQ_PM} || {} }, @Existing, @Missing } if $UnderCPAN or $TestOnly; if ( $args{EXE_FILES} and -e 'MANIFEST' ) { require ExtUtils::Manifest; my $manifest = ExtUtils::Manifest::maniread('MANIFEST'); $args{EXE_FILES} = [ grep { exists $manifest->{$_} } @{ $args{EXE_FILES} } ]; } $args{test}{TESTS} ||= 't/*.t'; $args{test}{TESTS} = join( ' ', grep { !exists( $DisabledTests{$_} ) } map { glob($_) } split( /\s+/, $args{test}{TESTS} ) ); my $missing = join( ',', @Missing ); my $config = join( ',', UNIVERSAL::isa( $Config, 'HASH' ) ? %{$Config} : @{$Config} ) if $Config; $PostambleActions = ( ($missing and not $UnderCPAN) ? "\$(PERL) $0 --config=$config --installdeps=$missing" : "\$(NOECHO) \$(NOOP)" ); my $deps_list = join( ',', @Missing, @Existing ); $PostambleActionsUpgradeDeps = "\$(PERL) $0 --config=$config --upgradedeps=$deps_list"; my $config_notest = join( ',', (UNIVERSAL::isa( $Config, 'HASH' ) ? %{$Config} : @{$Config}), 'notest', 1 ) if $Config; $PostambleActionsNoTest = ( ($missing and not $UnderCPAN) ? "\$(PERL) $0 --config=$config_notest --installdeps=$missing" : "\$(NOECHO) \$(NOOP)" ); $PostambleActionsUpgradeDepsNoTest = "\$(PERL) $0 --config=$config_notest --upgradedeps=$deps_list"; $PostambleActionsListDeps = '@$(PERL) -le "print for @ARGV" ' . join(' ', map $Missing[$_], grep $_ % 2 == 0, 0..$#Missing); my @all = (@Missing, @Existing); $PostambleActionsListAllDeps = '@$(PERL) -le "print for @ARGV" ' . join(' ', map $all[$_], grep $_ % 2 == 0, 0..$#all); return %args; } # a wrapper to ExtUtils::MakeMaker::WriteMakefile sub Write { require Carp; Carp::croak "WriteMakefile: Need even number of args" if @_ % 2; if ($CheckOnly) { print << "."; *** Makefile not written in check-only mode. . return; } my %args = _make_args(@_); no strict 'refs'; $PostambleUsed = 0; local *MY::postamble = \&postamble unless defined &MY::postamble; ExtUtils::MakeMaker::WriteMakefile(%args); print << "." unless $PostambleUsed; *** WARNING: Makefile written with customized MY::postamble() without including contents from Module::AutoInstall::postamble() -- auto installation features disabled. Please contact the author. . return 1; } sub postamble { $PostambleUsed = 1; my $fragment; $fragment .= <<"AUTO_INSTALL" if !$InstallDepsTarget; config :: installdeps \t\$(NOECHO) \$(NOOP) AUTO_INSTALL $fragment .= <<"END_MAKE"; checkdeps :: \t\$(PERL) $0 --checkdeps installdeps :: \t$PostambleActions installdeps_notest :: \t$PostambleActionsNoTest upgradedeps :: \t$PostambleActionsUpgradeDeps upgradedeps_notest :: \t$PostambleActionsUpgradeDepsNoTest listdeps :: \t$PostambleActionsListDeps listalldeps :: \t$PostambleActionsListAllDeps END_MAKE return $fragment; } 1; __END__ #line 1193 Catalyst-Authentication-Credential-HTTP-1.016/inc/Module/PaxHeader/Install000755 777777 777777 00000000214 12175027621 030667 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221716 19 SCHILY.nlink=13 Catalyst-Authentication-Credential-HTTP-1.016/inc/Module/Install/000755 €;Ðâp€tzÕß00000000000 12175027621 030446 5ustar00tdoranAD\Domain Users000000 000000 Catalyst-Authentication-Credential-HTTP-1.016/inc/Module/PaxHeader/Install.pm000644 777777 777777 00000000213 12175027560 031300 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221568 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/inc/Module/Install.pm000644 €;Ðâp€tzÕß00000030135 12175027560 031010 0ustar00tdoranAD\Domain Users000000 000000 #line 1 package Module::Install; # For any maintainers: # The load order for Module::Install is a bit magic. # It goes something like this... # # IF ( host has Module::Install installed, creating author mode ) { # 1. Makefile.PL calls "use inc::Module::Install" # 2. $INC{inc/Module/Install.pm} set to installed version of inc::Module::Install # 3. The installed version of inc::Module::Install loads # 4. inc::Module::Install calls "require Module::Install" # 5. The ./inc/ version of Module::Install loads # } ELSE { # 1. Makefile.PL calls "use inc::Module::Install" # 2. $INC{inc/Module/Install.pm} set to ./inc/ version of Module::Install # 3. The ./inc/ version of Module::Install loads # } use 5.005; use strict 'vars'; use Cwd (); use File::Find (); use File::Path (); use vars qw{$VERSION $MAIN}; BEGIN { # All Module::Install core packages now require synchronised versions. # This will be used to ensure we don't accidentally load old or # different versions of modules. # This is not enforced yet, but will be some time in the next few # releases once we can make sure it won't clash with custom # Module::Install extensions. $VERSION = '1.06'; # Storage for the pseudo-singleton $MAIN = undef; *inc::Module::Install::VERSION = *VERSION; @inc::Module::Install::ISA = __PACKAGE__; } sub import { my $class = shift; my $self = $class->new(@_); my $who = $self->_caller; #------------------------------------------------------------- # all of the following checks should be included in import(), # to allow "eval 'require Module::Install; 1' to test # installation of Module::Install. (RT #51267) #------------------------------------------------------------- # Whether or not inc::Module::Install is actually loaded, the # $INC{inc/Module/Install.pm} is what will still get set as long as # the caller loaded module this in the documented manner. # If not set, the caller may NOT have loaded the bundled version, and thus # they may not have a MI version that works with the Makefile.PL. This would # result in false errors or unexpected behaviour. And we don't want that. my $file = join( '/', 'inc', split /::/, __PACKAGE__ ) . '.pm'; unless ( $INC{$file} ) { die <<"END_DIE" } Please invoke ${\__PACKAGE__} with: use inc::${\__PACKAGE__}; not: use ${\__PACKAGE__}; END_DIE # This reportedly fixes a rare Win32 UTC file time issue, but # as this is a non-cross-platform XS module not in the core, # we shouldn't really depend on it. See RT #24194 for detail. # (Also, this module only supports Perl 5.6 and above). eval "use Win32::UTCFileTime" if $^O eq 'MSWin32' && $] >= 5.006; # If the script that is loading Module::Install is from the future, # then make will detect this and cause it to re-run over and over # again. This is bad. Rather than taking action to touch it (which # is unreliable on some platforms and requires write permissions) # for now we should catch this and refuse to run. if ( -f $0 ) { my $s = (stat($0))[9]; # If the modification time is only slightly in the future, # sleep briefly to remove the problem. my $a = $s - time; if ( $a > 0 and $a < 5 ) { sleep 5 } # Too far in the future, throw an error. my $t = time; if ( $s > $t ) { die <<"END_DIE" } Your installer $0 has a modification time in the future ($s > $t). This is known to create infinite loops in make. Please correct this, then run $0 again. END_DIE } # Build.PL was formerly supported, but no longer is due to excessive # difficulty in implementing every single feature twice. if ( $0 =~ /Build.PL$/i ) { die <<"END_DIE" } Module::Install no longer supports Build.PL. It was impossible to maintain duel backends, and has been deprecated. Please remove all Build.PL files and only use the Makefile.PL installer. END_DIE #------------------------------------------------------------- # To save some more typing in Module::Install installers, every... # use inc::Module::Install # ...also acts as an implicit use strict. $^H |= strict::bits(qw(refs subs vars)); #------------------------------------------------------------- unless ( -f $self->{file} ) { foreach my $key (keys %INC) { delete $INC{$key} if $key =~ /Module\/Install/; } local $^W; require "$self->{path}/$self->{dispatch}.pm"; File::Path::mkpath("$self->{prefix}/$self->{author}"); $self->{admin} = "$self->{name}::$self->{dispatch}"->new( _top => $self ); $self->{admin}->init; @_ = ($class, _self => $self); goto &{"$self->{name}::import"}; } local $^W; *{"${who}::AUTOLOAD"} = $self->autoload; $self->preload; # Unregister loader and worker packages so subdirs can use them again delete $INC{'inc/Module/Install.pm'}; delete $INC{'Module/Install.pm'}; # Save to the singleton $MAIN = $self; return 1; } sub autoload { my $self = shift; my $who = $self->_caller; my $cwd = Cwd::cwd(); my $sym = "${who}::AUTOLOAD"; $sym->{$cwd} = sub { my $pwd = Cwd::cwd(); if ( my $code = $sym->{$pwd} ) { # Delegate back to parent dirs goto &$code unless $cwd eq $pwd; } unless ($$sym =~ s/([^:]+)$//) { # XXX: it looks like we can't retrieve the missing function # via $$sym (usually $main::AUTOLOAD) in this case. # I'm still wondering if we should slurp Makefile.PL to # get some context or not ... my ($package, $file, $line) = caller; die <<"EOT"; Unknown function is found at $file line $line. Execution of $file aborted due to runtime errors. If you're a contributor to a project, you may need to install some Module::Install extensions from CPAN (or other repository). If you're a user of a module, please contact the author. EOT } my $method = $1; if ( uc($method) eq $method ) { # Do nothing return; } elsif ( $method =~ /^_/ and $self->can($method) ) { # Dispatch to the root M:I class return $self->$method(@_); } # Dispatch to the appropriate plugin unshift @_, ( $self, $1 ); goto &{$self->can('call')}; }; } sub preload { my $self = shift; unless ( $self->{extensions} ) { $self->load_extensions( "$self->{prefix}/$self->{path}", $self ); } my @exts = @{$self->{extensions}}; unless ( @exts ) { @exts = $self->{admin}->load_all_extensions; } my %seen; foreach my $obj ( @exts ) { while (my ($method, $glob) = each %{ref($obj) . '::'}) { next unless $obj->can($method); next if $method =~ /^_/; next if $method eq uc($method); $seen{$method}++; } } my $who = $self->_caller; foreach my $name ( sort keys %seen ) { local $^W; *{"${who}::$name"} = sub { ${"${who}::AUTOLOAD"} = "${who}::$name"; goto &{"${who}::AUTOLOAD"}; }; } } sub new { my ($class, %args) = @_; delete $INC{'FindBin.pm'}; { # to suppress the redefine warning local $SIG{__WARN__} = sub {}; require FindBin; } # ignore the prefix on extension modules built from top level. my $base_path = Cwd::abs_path($FindBin::Bin); unless ( Cwd::abs_path(Cwd::cwd()) eq $base_path ) { delete $args{prefix}; } return $args{_self} if $args{_self}; $args{dispatch} ||= 'Admin'; $args{prefix} ||= 'inc'; $args{author} ||= ($^O eq 'VMS' ? '_author' : '.author'); $args{bundle} ||= 'inc/BUNDLES'; $args{base} ||= $base_path; $class =~ s/^\Q$args{prefix}\E:://; $args{name} ||= $class; $args{version} ||= $class->VERSION; unless ( $args{path} ) { $args{path} = $args{name}; $args{path} =~ s!::!/!g; } $args{file} ||= "$args{base}/$args{prefix}/$args{path}.pm"; $args{wrote} = 0; bless( \%args, $class ); } sub call { my ($self, $method) = @_; my $obj = $self->load($method) or return; splice(@_, 0, 2, $obj); goto &{$obj->can($method)}; } sub load { my ($self, $method) = @_; $self->load_extensions( "$self->{prefix}/$self->{path}", $self ) unless $self->{extensions}; foreach my $obj (@{$self->{extensions}}) { return $obj if $obj->can($method); } my $admin = $self->{admin} or die <<"END_DIE"; The '$method' method does not exist in the '$self->{prefix}' path! Please remove the '$self->{prefix}' directory and run $0 again to load it. END_DIE my $obj = $admin->load($method, 1); push @{$self->{extensions}}, $obj; $obj; } sub load_extensions { my ($self, $path, $top) = @_; my $should_reload = 0; unless ( grep { ! ref $_ and lc $_ eq lc $self->{prefix} } @INC ) { unshift @INC, $self->{prefix}; $should_reload = 1; } foreach my $rv ( $self->find_extensions($path) ) { my ($file, $pkg) = @{$rv}; next if $self->{pathnames}{$pkg}; local $@; my $new = eval { local $^W; require $file; $pkg->can('new') }; unless ( $new ) { warn $@ if $@; next; } $self->{pathnames}{$pkg} = $should_reload ? delete $INC{$file} : $INC{$file}; push @{$self->{extensions}}, &{$new}($pkg, _top => $top ); } $self->{extensions} ||= []; } sub find_extensions { my ($self, $path) = @_; my @found; File::Find::find( sub { my $file = $File::Find::name; return unless $file =~ m!^\Q$path\E/(.+)\.pm\Z!is; my $subpath = $1; return if lc($subpath) eq lc($self->{dispatch}); $file = "$self->{path}/$subpath.pm"; my $pkg = "$self->{name}::$subpath"; $pkg =~ s!/!::!g; # If we have a mixed-case package name, assume case has been preserved # correctly. Otherwise, root through the file to locate the case-preserved # version of the package name. if ( $subpath eq lc($subpath) || $subpath eq uc($subpath) ) { my $content = Module::Install::_read($subpath . '.pm'); my $in_pod = 0; foreach ( split //, $content ) { $in_pod = 1 if /^=\w/; $in_pod = 0 if /^=cut/; next if ($in_pod || /^=cut/); # skip pod text next if /^\s*#/; # and comments if ( m/^\s*package\s+($pkg)\s*;/i ) { $pkg = $1; last; } } } push @found, [ $file, $pkg ]; }, $path ) if -d $path; @found; } ##################################################################### # Common Utility Functions sub _caller { my $depth = 0; my $call = caller($depth); while ( $call eq __PACKAGE__ ) { $depth++; $call = caller($depth); } return $call; } # Done in evals to avoid confusing Perl::MinimumVersion eval( $] >= 5.006 ? <<'END_NEW' : <<'END_OLD' ); die $@ if $@; sub _read { local *FH; open( FH, '<', $_[0] ) or die "open($_[0]): $!"; my $string = do { local $/; }; close FH or die "close($_[0]): $!"; return $string; } END_NEW sub _read { local *FH; open( FH, "< $_[0]" ) or die "open($_[0]): $!"; my $string = do { local $/; }; close FH or die "close($_[0]): $!"; return $string; } END_OLD sub _readperl { my $string = Module::Install::_read($_[0]); $string =~ s/(?:\015{1,2}\012|\015|\012)/\n/sg; $string =~ s/(\n)\n*__(?:DATA|END)__\b.*\z/$1/s; $string =~ s/\n\n=\w+.+?\n\n=cut\b.+?\n+/\n\n/sg; return $string; } sub _readpod { my $string = Module::Install::_read($_[0]); $string =~ s/(?:\015{1,2}\012|\015|\012)/\n/sg; return $string if $_[0] =~ /\.pod\z/; $string =~ s/(^|\n=cut\b.+?\n+)[^=\s].+?\n(\n=\w+|\z)/$1$2/sg; $string =~ s/\n*=pod\b[^\n]*\n+/\n\n/sg; $string =~ s/\n*=cut\b[^\n]*\n+/\n\n/sg; $string =~ s/^\n+//s; return $string; } # Done in evals to avoid confusing Perl::MinimumVersion eval( $] >= 5.006 ? <<'END_NEW' : <<'END_OLD' ); die $@ if $@; sub _write { local *FH; open( FH, '>', $_[0] ) or die "open($_[0]): $!"; foreach ( 1 .. $#_ ) { print FH $_[$_] or die "print($_[0]): $!"; } close FH or die "close($_[0]): $!"; } END_NEW sub _write { local *FH; open( FH, "> $_[0]" ) or die "open($_[0]): $!"; foreach ( 1 .. $#_ ) { print FH $_[$_] or die "print($_[0]): $!"; } close FH or die "close($_[0]): $!"; } END_OLD # _version is for processing module versions (eg, 1.03_05) not # Perl versions (eg, 5.8.1). sub _version ($) { my $s = shift || 0; my $d =()= $s =~ /(\.)/g; if ( $d >= 2 ) { # Normalise multipart versions $s =~ s/(\.)(\d{1,3})/sprintf("$1%03d",$2)/eg; } $s =~ s/^(\d+)\.?//; my $l = $1 || 0; my @v = map { $_ . '0' x (3 - length $_) } $s =~ /(\d{1,3})\D?/g; $l = $l . '.' . join '', @v if @v; return $l + 0; } sub _cmp ($$) { _version($_[1]) <=> _version($_[2]); } # Cloned from Params::Util::_CLASS sub _CLASS ($) { ( defined $_[0] and ! ref $_[0] and $_[0] =~ m/^[^\W\d]\w*(?:::\w+)*\z/s ) ? $_[0] : undef; } 1; # Copyright 2008 - 2012 Adam Kennedy. Catalyst-Authentication-Credential-HTTP-1.016/inc/Module/Install/PaxHeader/AuthorRequires.pm000644 777777 777777 00000000213 12175027560 034262 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221573 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/inc/Module/Install/AuthorRequires.pm000644 €;Ðâp€tzÕß00000001131 12175027560 033764 0ustar00tdoranAD\Domain Users000000 000000 #line 1 use strict; use warnings; package Module::Install::AuthorRequires; use base 'Module::Install::Base'; # cargo cult BEGIN { our $VERSION = '0.02'; our $ISCORE = 1; } sub author_requires { my $self = shift; return $self->{values}->{author_requires} unless @_; my @added; while (@_) { my $mod = shift or last; my $version = shift || 0; push @added, [$mod => $version]; } push @{ $self->{values}->{author_requires} }, @added; $self->admin->author_requires(@added); return map { @$_ } @added; } 1; __END__ #line 92 Catalyst-Authentication-Credential-HTTP-1.016/inc/Module/Install/PaxHeader/AuthorTests.pm000644 777777 777777 00000000213 12175027560 033565 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221575 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/inc/Module/Install/AuthorTests.pm000644 €;Ðâp€tzÕß00000002215 12175027560 033273 0ustar00tdoranAD\Domain Users000000 000000 #line 1 package Module::Install::AuthorTests; use 5.005; use strict; use Module::Install::Base; use Carp (); #line 16 use vars qw{$VERSION $ISCORE @ISA}; BEGIN { $VERSION = '0.002'; $ISCORE = 1; @ISA = qw{Module::Install::Base}; } #line 42 sub author_tests { my ($self, @dirs) = @_; _add_author_tests($self, \@dirs, 0); } #line 56 sub recursive_author_tests { my ($self, @dirs) = @_; _add_author_tests($self, \@dirs, 1); } sub _wanted { my $href = shift; sub { /\.t$/ and -f $_ and $href->{$File::Find::dir} = 1 } } sub _add_author_tests { my ($self, $dirs, $recurse) = @_; return unless $Module::Install::AUTHOR; my @tests = $self->tests ? (split / /, $self->tests) : 't/*.t'; # XXX: pick a default, later -- rjbs, 2008-02-24 my @dirs = @$dirs ? @$dirs : Carp::confess "no dirs given to author_tests"; @dirs = grep { -d } @dirs; if ($recurse) { require File::Find; my %test_dir; File::Find::find(_wanted(\%test_dir), @dirs); $self->tests( join ' ', @tests, map { "$_/*.t" } sort keys %test_dir ); } else { $self->tests( join ' ', @tests, map { "$_/*.t" } sort @dirs ); } } #line 107 1; Catalyst-Authentication-Credential-HTTP-1.016/inc/Module/Install/PaxHeader/AutoInstall.pm000644 777777 777777 00000000213 12175027561 033540 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221576 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/inc/Module/Install/AutoInstall.pm000644 €;Ðâp€tzÕß00000004162 12175027561 033251 0ustar00tdoranAD\Domain Users000000 000000 #line 1 package Module::Install::AutoInstall; use strict; use Module::Install::Base (); use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '1.06'; @ISA = 'Module::Install::Base'; $ISCORE = 1; } sub AutoInstall { $_[0] } sub run { my $self = shift; $self->auto_install_now(@_); } sub write { my $self = shift; $self->auto_install(@_); } sub auto_install { my $self = shift; return if $self->{done}++; # Flatten array of arrays into a single array my @core = map @$_, map @$_, grep ref, $self->build_requires, $self->requires; my @config = @_; # We'll need Module::AutoInstall $self->include('Module::AutoInstall'); require Module::AutoInstall; my @features_require = Module::AutoInstall->import( (@config ? (-config => \@config) : ()), (@core ? (-core => \@core) : ()), $self->features, ); my %seen; my @requires = map @$_, map @$_, grep ref, $self->requires; while (my ($mod, $ver) = splice(@requires, 0, 2)) { $seen{$mod}{$ver}++; } my @build_requires = map @$_, map @$_, grep ref, $self->build_requires; while (my ($mod, $ver) = splice(@build_requires, 0, 2)) { $seen{$mod}{$ver}++; } my @configure_requires = map @$_, map @$_, grep ref, $self->configure_requires; while (my ($mod, $ver) = splice(@configure_requires, 0, 2)) { $seen{$mod}{$ver}++; } my @deduped; while (my ($mod, $ver) = splice(@features_require, 0, 2)) { push @deduped, $mod => $ver unless $seen{$mod}{$ver}++; } $self->requires(@deduped); $self->makemaker_args( Module::AutoInstall::_make_args() ); my $class = ref($self); $self->postamble( "# --- $class section:\n" . Module::AutoInstall::postamble() ); } sub installdeps_target { my ($self, @args) = @_; $self->include('Module::AutoInstall'); require Module::AutoInstall; Module::AutoInstall::_installdeps_target(1); $self->auto_install(@args); } sub auto_install_now { my $self = shift; $self->auto_install(@_); Module::AutoInstall::do_install(); } 1; Catalyst-Authentication-Credential-HTTP-1.016/inc/Module/Install/PaxHeader/Base.pm000644 777777 777777 00000000213 12175027560 032152 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221571 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/inc/Module/Install/Base.pm000644 €;Ðâp€tzÕß00000002147 12175027560 031664 0ustar00tdoranAD\Domain Users000000 000000 #line 1 package Module::Install::Base; use strict 'vars'; use vars qw{$VERSION}; BEGIN { $VERSION = '1.06'; } # Suspend handler for "redefined" warnings BEGIN { my $w = $SIG{__WARN__}; $SIG{__WARN__} = sub { $w }; } #line 42 sub new { my $class = shift; unless ( defined &{"${class}::call"} ) { *{"${class}::call"} = sub { shift->_top->call(@_) }; } unless ( defined &{"${class}::load"} ) { *{"${class}::load"} = sub { shift->_top->load(@_) }; } bless { @_ }, $class; } #line 61 sub AUTOLOAD { local $@; my $func = eval { shift->_top->autoload } or return; goto &$func; } #line 75 sub _top { $_[0]->{_top}; } #line 90 sub admin { $_[0]->_top->{admin} or Module::Install::Base::FakeAdmin->new; } #line 106 sub is_admin { ! $_[0]->admin->isa('Module::Install::Base::FakeAdmin'); } sub DESTROY {} package Module::Install::Base::FakeAdmin; use vars qw{$VERSION}; BEGIN { $VERSION = $Module::Install::Base::VERSION; } my $fake; sub new { $fake ||= bless(\@_, $_[0]); } sub AUTOLOAD {} sub DESTROY {} # Restore warning handler BEGIN { $SIG{__WARN__} = $SIG{__WARN__}->(); } 1; #line 159 Catalyst-Authentication-Credential-HTTP-1.016/inc/Module/Install/PaxHeader/Can.pm000644 777777 777777 00000000213 12175027560 032001 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221574 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/inc/Module/Install/Can.pm000644 €;Ðâp€tzÕß00000006157 12175027560 031520 0ustar00tdoranAD\Domain Users000000 000000 #line 1 package Module::Install::Can; use strict; use Config (); use ExtUtils::MakeMaker (); use Module::Install::Base (); use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '1.06'; @ISA = 'Module::Install::Base'; $ISCORE = 1; } # check if we can load some module ### Upgrade this to not have to load the module if possible sub can_use { my ($self, $mod, $ver) = @_; $mod =~ s{::|\\}{/}g; $mod .= '.pm' unless $mod =~ /\.pm$/i; my $pkg = $mod; $pkg =~ s{/}{::}g; $pkg =~ s{\.pm$}{}i; local $@; eval { require $mod; $pkg->VERSION($ver || 0); 1 }; } # Check if we can run some command sub can_run { my ($self, $cmd) = @_; my $_cmd = $cmd; return $_cmd if (-x $_cmd or $_cmd = MM->maybe_command($_cmd)); for my $dir ((split /$Config::Config{path_sep}/, $ENV{PATH}), '.') { next if $dir eq ''; require File::Spec; my $abs = File::Spec->catfile($dir, $cmd); return $abs if (-x $abs or $abs = MM->maybe_command($abs)); } return; } # Can our C compiler environment build XS files sub can_xs { my $self = shift; # Ensure we have the CBuilder module $self->configure_requires( 'ExtUtils::CBuilder' => 0.27 ); # Do we have the configure_requires checker? local $@; eval "require ExtUtils::CBuilder;"; if ( $@ ) { # They don't obey configure_requires, so it is # someone old and delicate. Try to avoid hurting # them by falling back to an older simpler test. return $self->can_cc(); } # Do we have a working C compiler my $builder = ExtUtils::CBuilder->new( quiet => 1, ); unless ( $builder->have_compiler ) { # No working C compiler return 0; } # Write a C file representative of what XS becomes require File::Temp; my ( $FH, $tmpfile ) = File::Temp::tempfile( "compilexs-XXXXX", SUFFIX => '.c', ); binmode $FH; print $FH <<'END_C'; #include "EXTERN.h" #include "perl.h" #include "XSUB.h" int main(int argc, char **argv) { return 0; } int boot_sanexs() { return 1; } END_C close $FH; # Can the C compiler access the same headers XS does my @libs = (); my $object = undef; eval { local $^W = 0; $object = $builder->compile( source => $tmpfile, ); @libs = $builder->link( objects => $object, module_name => 'sanexs', ); }; my $result = $@ ? 0 : 1; # Clean up all the build files foreach ( $tmpfile, $object, @libs ) { next unless defined $_; 1 while unlink; } return $result; } # Can we locate a (the) C compiler sub can_cc { my $self = shift; my @chunks = split(/ /, $Config::Config{cc}) or return; # $Config{cc} may contain args; try to find out the program part while (@chunks) { return $self->can_run("@chunks") || (pop(@chunks), next); } return; } # Fix Cygwin bug on maybe_command(); if ( $^O eq 'cygwin' ) { require ExtUtils::MM_Cygwin; require ExtUtils::MM_Win32; if ( ! defined(&ExtUtils::MM_Cygwin::maybe_command) ) { *ExtUtils::MM_Cygwin::maybe_command = sub { my ($self, $file) = @_; if ($file =~ m{^/cygdrive/}i and ExtUtils::MM_Win32->can('maybe_command')) { ExtUtils::MM_Win32->maybe_command($file); } else { ExtUtils::MM_Unix->maybe_command($file); } } } } 1; __END__ #line 236 Catalyst-Authentication-Credential-HTTP-1.016/inc/Module/Install/PaxHeader/Fetch.pm000644 777777 777777 00000000213 12175027561 032332 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221581 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/inc/Module/Install/Fetch.pm000644 €;Ðâp€tzÕß00000004627 12175027561 032051 0ustar00tdoranAD\Domain Users000000 000000 #line 1 package Module::Install::Fetch; use strict; use Module::Install::Base (); use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '1.06'; @ISA = 'Module::Install::Base'; $ISCORE = 1; } sub get_file { my ($self, %args) = @_; my ($scheme, $host, $path, $file) = $args{url} =~ m|^(\w+)://([^/]+)(.+)/(.+)| or return; if ( $scheme eq 'http' and ! eval { require LWP::Simple; 1 } ) { $args{url} = $args{ftp_url} or (warn("LWP support unavailable!\n"), return); ($scheme, $host, $path, $file) = $args{url} =~ m|^(\w+)://([^/]+)(.+)/(.+)| or return; } $|++; print "Fetching '$file' from $host... "; unless (eval { require Socket; Socket::inet_aton($host) }) { warn "'$host' resolve failed!\n"; return; } return unless $scheme eq 'ftp' or $scheme eq 'http'; require Cwd; my $dir = Cwd::getcwd(); chdir $args{local_dir} or return if exists $args{local_dir}; if (eval { require LWP::Simple; 1 }) { LWP::Simple::mirror($args{url}, $file); } elsif (eval { require Net::FTP; 1 }) { eval { # use Net::FTP to get past firewall my $ftp = Net::FTP->new($host, Passive => 1, Timeout => 600); $ftp->login("anonymous", 'anonymous@example.com'); $ftp->cwd($path); $ftp->binary; $ftp->get($file) or (warn("$!\n"), return); $ftp->quit; } } elsif (my $ftp = $self->can_run('ftp')) { eval { # no Net::FTP, fallback to ftp.exe require FileHandle; my $fh = FileHandle->new; local $SIG{CHLD} = 'IGNORE'; unless ($fh->open("|$ftp -n")) { warn "Couldn't open ftp: $!\n"; chdir $dir; return; } my @dialog = split(/\n/, <<"END_FTP"); open $host user anonymous anonymous\@example.com cd $path binary get $file $file quit END_FTP foreach (@dialog) { $fh->print("$_\n") } $fh->close; } } else { warn "No working 'ftp' program available!\n"; chdir $dir; return; } unless (-f $file) { warn "Fetching failed: $@\n"; chdir $dir; return; } return if exists $args{size} and -s $file != $args{size}; system($args{run}) if exists $args{run}; unlink($file) if $args{remove}; print(((!exists $args{check_for} or -e $args{check_for}) ? "done!" : "failed! ($!)"), "\n"); chdir $dir; return !$?; } 1; Catalyst-Authentication-Credential-HTTP-1.016/inc/Module/Install/PaxHeader/Include.pm000644 777777 777777 00000000213 12175027561 032664 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221577 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/inc/Module/Install/Include.pm000644 €;Ðâp€tzÕß00000001015 12175027561 032367 0ustar00tdoranAD\Domain Users000000 000000 #line 1 package Module::Install::Include; use strict; use Module::Install::Base (); use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '1.06'; @ISA = 'Module::Install::Base'; $ISCORE = 1; } sub include { shift()->admin->include(@_); } sub include_deps { shift()->admin->include_deps(@_); } sub auto_include { shift()->admin->auto_include(@_); } sub auto_include_deps { shift()->admin->auto_include_deps(@_); } sub auto_include_dependent_dists { shift()->admin->auto_include_dependent_dists(@_); } 1; Catalyst-Authentication-Credential-HTTP-1.016/inc/Module/Install/PaxHeader/Makefile.pm000644 777777 777777 00000000213 12175027560 033015 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221572 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/inc/Module/Install/Makefile.pm000644 €;Ðâp€tzÕß00000027437 12175027560 032540 0ustar00tdoranAD\Domain Users000000 000000 #line 1 package Module::Install::Makefile; use strict 'vars'; use ExtUtils::MakeMaker (); use Module::Install::Base (); use Fcntl qw/:flock :seek/; use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '1.06'; @ISA = 'Module::Install::Base'; $ISCORE = 1; } sub Makefile { $_[0] } my %seen = (); sub prompt { shift; # Infinite loop protection my @c = caller(); if ( ++$seen{"$c[1]|$c[2]|$_[0]"} > 3 ) { die "Caught an potential prompt infinite loop ($c[1]|$c[2]|$_[0])"; } # In automated testing or non-interactive session, always use defaults if ( ($ENV{AUTOMATED_TESTING} or -! -t STDIN) and ! $ENV{PERL_MM_USE_DEFAULT} ) { local $ENV{PERL_MM_USE_DEFAULT} = 1; goto &ExtUtils::MakeMaker::prompt; } else { goto &ExtUtils::MakeMaker::prompt; } } # Store a cleaned up version of the MakeMaker version, # since we need to behave differently in a variety of # ways based on the MM version. my $makemaker = eval $ExtUtils::MakeMaker::VERSION; # If we are passed a param, do a "newer than" comparison. # Otherwise, just return the MakeMaker version. sub makemaker { ( @_ < 2 or $makemaker >= eval($_[1]) ) ? $makemaker : 0 } # Ripped from ExtUtils::MakeMaker 6.56, and slightly modified # as we only need to know here whether the attribute is an array # or a hash or something else (which may or may not be appendable). my %makemaker_argtype = ( C => 'ARRAY', CONFIG => 'ARRAY', # CONFIGURE => 'CODE', # ignore DIR => 'ARRAY', DL_FUNCS => 'HASH', DL_VARS => 'ARRAY', EXCLUDE_EXT => 'ARRAY', EXE_FILES => 'ARRAY', FUNCLIST => 'ARRAY', H => 'ARRAY', IMPORTS => 'HASH', INCLUDE_EXT => 'ARRAY', LIBS => 'ARRAY', # ignore '' MAN1PODS => 'HASH', MAN3PODS => 'HASH', META_ADD => 'HASH', META_MERGE => 'HASH', PL_FILES => 'HASH', PM => 'HASH', PMLIBDIRS => 'ARRAY', PMLIBPARENTDIRS => 'ARRAY', PREREQ_PM => 'HASH', CONFIGURE_REQUIRES => 'HASH', SKIP => 'ARRAY', TYPEMAPS => 'ARRAY', XS => 'HASH', # VERSION => ['version',''], # ignore # _KEEP_AFTER_FLUSH => '', clean => 'HASH', depend => 'HASH', dist => 'HASH', dynamic_lib=> 'HASH', linkext => 'HASH', macro => 'HASH', postamble => 'HASH', realclean => 'HASH', test => 'HASH', tool_autosplit => 'HASH', # special cases where you can use makemaker_append CCFLAGS => 'APPENDABLE', DEFINE => 'APPENDABLE', INC => 'APPENDABLE', LDDLFLAGS => 'APPENDABLE', LDFROM => 'APPENDABLE', ); sub makemaker_args { my ($self, %new_args) = @_; my $args = ( $self->{makemaker_args} ||= {} ); foreach my $key (keys %new_args) { if ($makemaker_argtype{$key}) { if ($makemaker_argtype{$key} eq 'ARRAY') { $args->{$key} = [] unless defined $args->{$key}; unless (ref $args->{$key} eq 'ARRAY') { $args->{$key} = [$args->{$key}] } push @{$args->{$key}}, ref $new_args{$key} eq 'ARRAY' ? @{$new_args{$key}} : $new_args{$key}; } elsif ($makemaker_argtype{$key} eq 'HASH') { $args->{$key} = {} unless defined $args->{$key}; foreach my $skey (keys %{ $new_args{$key} }) { $args->{$key}{$skey} = $new_args{$key}{$skey}; } } elsif ($makemaker_argtype{$key} eq 'APPENDABLE') { $self->makemaker_append($key => $new_args{$key}); } } else { if (defined $args->{$key}) { warn qq{MakeMaker attribute "$key" is overriden; use "makemaker_append" to append values\n}; } $args->{$key} = $new_args{$key}; } } return $args; } # For mm args that take multiple space-seperated args, # append an argument to the current list. sub makemaker_append { my $self = shift; my $name = shift; my $args = $self->makemaker_args; $args->{$name} = defined $args->{$name} ? join( ' ', $args->{$name}, @_ ) : join( ' ', @_ ); } sub build_subdirs { my $self = shift; my $subdirs = $self->makemaker_args->{DIR} ||= []; for my $subdir (@_) { push @$subdirs, $subdir; } } sub clean_files { my $self = shift; my $clean = $self->makemaker_args->{clean} ||= {}; %$clean = ( %$clean, FILES => join ' ', grep { length $_ } ($clean->{FILES} || (), @_), ); } sub realclean_files { my $self = shift; my $realclean = $self->makemaker_args->{realclean} ||= {}; %$realclean = ( %$realclean, FILES => join ' ', grep { length $_ } ($realclean->{FILES} || (), @_), ); } sub libs { my $self = shift; my $libs = ref $_[0] ? shift : [ shift ]; $self->makemaker_args( LIBS => $libs ); } sub inc { my $self = shift; $self->makemaker_args( INC => shift ); } sub _wanted_t { } sub tests_recursive { my $self = shift; my $dir = shift || 't'; unless ( -d $dir ) { die "tests_recursive dir '$dir' does not exist"; } my %tests = map { $_ => 1 } split / /, ($self->tests || ''); require File::Find; File::Find::find( sub { /\.t$/ and -f $_ and $tests{"$File::Find::dir/*.t"} = 1 }, $dir ); $self->tests( join ' ', sort keys %tests ); } sub write { my $self = shift; die "&Makefile->write() takes no arguments\n" if @_; # Check the current Perl version my $perl_version = $self->perl_version; if ( $perl_version ) { eval "use $perl_version; 1" or die "ERROR: perl: Version $] is installed, " . "but we need version >= $perl_version"; } # Make sure we have a new enough MakeMaker require ExtUtils::MakeMaker; if ( $perl_version and $self->_cmp($perl_version, '5.006') >= 0 ) { # This previous attempted to inherit the version of # ExtUtils::MakeMaker in use by the module author, but this # was found to be untenable as some authors build releases # using future dev versions of EU:MM that nobody else has. # Instead, #toolchain suggests we use 6.59 which is the most # stable version on CPAN at time of writing and is, to quote # ribasushi, "not terminally fucked, > and tested enough". # TODO: We will now need to maintain this over time to push # the version up as new versions are released. $self->build_requires( 'ExtUtils::MakeMaker' => 6.59 ); $self->configure_requires( 'ExtUtils::MakeMaker' => 6.59 ); } else { # Allow legacy-compatibility with 5.005 by depending on the # most recent EU:MM that supported 5.005. $self->build_requires( 'ExtUtils::MakeMaker' => 6.36 ); $self->configure_requires( 'ExtUtils::MakeMaker' => 6.36 ); } # Generate the MakeMaker params my $args = $self->makemaker_args; $args->{DISTNAME} = $self->name; $args->{NAME} = $self->module_name || $self->name; $args->{NAME} =~ s/-/::/g; $args->{VERSION} = $self->version or die <<'EOT'; ERROR: Can't determine distribution version. Please specify it explicitly via 'version' in Makefile.PL, or set a valid $VERSION in a module, and provide its file path via 'version_from' (or 'all_from' if you prefer) in Makefile.PL. EOT if ( $self->tests ) { my @tests = split ' ', $self->tests; my %seen; $args->{test} = { TESTS => (join ' ', grep {!$seen{$_}++} @tests), }; } elsif ( $Module::Install::ExtraTests::use_extratests ) { # Module::Install::ExtraTests doesn't set $self->tests and does its own tests via harness. # So, just ignore our xt tests here. } elsif ( -d 'xt' and ($Module::Install::AUTHOR or $ENV{RELEASE_TESTING}) ) { $args->{test} = { TESTS => join( ' ', map { "$_/*.t" } grep { -d $_ } qw{ t xt } ), }; } if ( $] >= 5.005 ) { $args->{ABSTRACT} = $self->abstract; $args->{AUTHOR} = join ', ', @{$self->author || []}; } if ( $self->makemaker(6.10) ) { $args->{NO_META} = 1; #$args->{NO_MYMETA} = 1; } if ( $self->makemaker(6.17) and $self->sign ) { $args->{SIGN} = 1; } unless ( $self->is_admin ) { delete $args->{SIGN}; } if ( $self->makemaker(6.31) and $self->license ) { $args->{LICENSE} = $self->license; } my $prereq = ($args->{PREREQ_PM} ||= {}); %$prereq = ( %$prereq, map { @$_ } # flatten [module => version] map { @$_ } grep $_, ($self->requires) ); # Remove any reference to perl, PREREQ_PM doesn't support it delete $args->{PREREQ_PM}->{perl}; # Merge both kinds of requires into BUILD_REQUIRES my $build_prereq = ($args->{BUILD_REQUIRES} ||= {}); %$build_prereq = ( %$build_prereq, map { @$_ } # flatten [module => version] map { @$_ } grep $_, ($self->configure_requires, $self->build_requires) ); # Remove any reference to perl, BUILD_REQUIRES doesn't support it delete $args->{BUILD_REQUIRES}->{perl}; # Delete bundled dists from prereq_pm, add it to Makefile DIR my $subdirs = ($args->{DIR} || []); if ($self->bundles) { my %processed; foreach my $bundle (@{ $self->bundles }) { my ($mod_name, $dist_dir) = @$bundle; delete $prereq->{$mod_name}; $dist_dir = File::Basename::basename($dist_dir); # dir for building this module if (not exists $processed{$dist_dir}) { if (-d $dist_dir) { # List as sub-directory to be processed by make push @$subdirs, $dist_dir; } # Else do nothing: the module is already present on the system $processed{$dist_dir} = undef; } } } unless ( $self->makemaker('6.55_03') ) { %$prereq = (%$prereq,%$build_prereq); delete $args->{BUILD_REQUIRES}; } if ( my $perl_version = $self->perl_version ) { eval "use $perl_version; 1" or die "ERROR: perl: Version $] is installed, " . "but we need version >= $perl_version"; if ( $self->makemaker(6.48) ) { $args->{MIN_PERL_VERSION} = $perl_version; } } if ($self->installdirs) { warn qq{old INSTALLDIRS (probably set by makemaker_args) is overriden by installdirs\n} if $args->{INSTALLDIRS}; $args->{INSTALLDIRS} = $self->installdirs; } my %args = map { ( $_ => $args->{$_} ) } grep {defined($args->{$_} ) } keys %$args; my $user_preop = delete $args{dist}->{PREOP}; if ( my $preop = $self->admin->preop($user_preop) ) { foreach my $key ( keys %$preop ) { $args{dist}->{$key} = $preop->{$key}; } } my $mm = ExtUtils::MakeMaker::WriteMakefile(%args); $self->fix_up_makefile($mm->{FIRST_MAKEFILE} || 'Makefile'); } sub fix_up_makefile { my $self = shift; my $makefile_name = shift; my $top_class = ref($self->_top) || ''; my $top_version = $self->_top->VERSION || ''; my $preamble = $self->preamble ? "# Preamble by $top_class $top_version\n" . $self->preamble : ''; my $postamble = "# Postamble by $top_class $top_version\n" . ($self->postamble || ''); local *MAKEFILE; open MAKEFILE, "+< $makefile_name" or die "fix_up_makefile: Couldn't open $makefile_name: $!"; eval { flock MAKEFILE, LOCK_EX }; my $makefile = do { local $/; }; $makefile =~ s/\b(test_harness\(\$\(TEST_VERBOSE\), )/$1'inc', /; $makefile =~ s/( -I\$\(INST_ARCHLIB\))/ -Iinc$1/g; $makefile =~ s/( "-I\$\(INST_LIB\)")/ "-Iinc"$1/g; $makefile =~ s/^(FULLPERL = .*)/$1 "-Iinc"/m; $makefile =~ s/^(PERL = .*)/$1 "-Iinc"/m; # Module::Install will never be used to build the Core Perl # Sometimes PERL_LIB and PERL_ARCHLIB get written anyway, which breaks # PREFIX/PERL5LIB, and thus, install_share. Blank them if they exist $makefile =~ s/^PERL_LIB = .+/PERL_LIB =/m; #$makefile =~ s/^PERL_ARCHLIB = .+/PERL_ARCHLIB =/m; # Perl 5.005 mentions PERL_LIB explicitly, so we have to remove that as well. $makefile =~ s/(\"?)-I\$\(PERL_LIB\)\1//g; # XXX - This is currently unused; not sure if it breaks other MM-users # $makefile =~ s/^pm_to_blib\s+:\s+/pm_to_blib :: /mg; seek MAKEFILE, 0, SEEK_SET; truncate MAKEFILE, 0; print MAKEFILE "$preamble$makefile$postamble" or die $!; close MAKEFILE or die $!; 1; } sub preamble { my ($self, $text) = @_; $self->{preamble} = $text . $self->{preamble} if defined $text; $self->{preamble}; } sub postamble { my ($self, $text) = @_; $self->{postamble} ||= $self->admin->postamble; $self->{postamble} .= $text if defined $text; $self->{postamble} } 1; __END__ #line 544 Catalyst-Authentication-Credential-HTTP-1.016/inc/Module/Install/PaxHeader/Metadata.pm000644 777777 777777 00000000213 12175027560 033020 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221570 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/inc/Module/Install/Metadata.pm000644 €;Ðâp€tzÕß00000043277 12175027560 032543 0ustar00tdoranAD\Domain Users000000 000000 #line 1 package Module::Install::Metadata; use strict 'vars'; use Module::Install::Base (); use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '1.06'; @ISA = 'Module::Install::Base'; $ISCORE = 1; } my @boolean_keys = qw{ sign }; my @scalar_keys = qw{ name module_name abstract version distribution_type tests installdirs }; my @tuple_keys = qw{ configure_requires build_requires requires recommends bundles resources }; my @resource_keys = qw{ homepage bugtracker repository }; my @array_keys = qw{ keywords author }; *authors = \&author; sub Meta { shift } sub Meta_BooleanKeys { @boolean_keys } sub Meta_ScalarKeys { @scalar_keys } sub Meta_TupleKeys { @tuple_keys } sub Meta_ResourceKeys { @resource_keys } sub Meta_ArrayKeys { @array_keys } foreach my $key ( @boolean_keys ) { *$key = sub { my $self = shift; if ( defined wantarray and not @_ ) { return $self->{values}->{$key}; } $self->{values}->{$key} = ( @_ ? $_[0] : 1 ); return $self; }; } foreach my $key ( @scalar_keys ) { *$key = sub { my $self = shift; return $self->{values}->{$key} if defined wantarray and !@_; $self->{values}->{$key} = shift; return $self; }; } foreach my $key ( @array_keys ) { *$key = sub { my $self = shift; return $self->{values}->{$key} if defined wantarray and !@_; $self->{values}->{$key} ||= []; push @{$self->{values}->{$key}}, @_; return $self; }; } foreach my $key ( @resource_keys ) { *$key = sub { my $self = shift; unless ( @_ ) { return () unless $self->{values}->{resources}; return map { $_->[1] } grep { $_->[0] eq $key } @{ $self->{values}->{resources} }; } return $self->{values}->{resources}->{$key} unless @_; my $uri = shift or die( "Did not provide a value to $key()" ); $self->resources( $key => $uri ); return 1; }; } foreach my $key ( grep { $_ ne "resources" } @tuple_keys) { *$key = sub { my $self = shift; return $self->{values}->{$key} unless @_; my @added; while ( @_ ) { my $module = shift or last; my $version = shift || 0; push @added, [ $module, $version ]; } push @{ $self->{values}->{$key} }, @added; return map {@$_} @added; }; } # Resource handling my %lc_resource = map { $_ => 1 } qw{ homepage license bugtracker repository }; sub resources { my $self = shift; while ( @_ ) { my $name = shift or last; my $value = shift or next; if ( $name eq lc $name and ! $lc_resource{$name} ) { die("Unsupported reserved lowercase resource '$name'"); } $self->{values}->{resources} ||= []; push @{ $self->{values}->{resources} }, [ $name, $value ]; } $self->{values}->{resources}; } # Aliases for build_requires that will have alternative # meanings in some future version of META.yml. sub test_requires { shift->build_requires(@_) } sub install_requires { shift->build_requires(@_) } # Aliases for installdirs options sub install_as_core { $_[0]->installdirs('perl') } sub install_as_cpan { $_[0]->installdirs('site') } sub install_as_site { $_[0]->installdirs('site') } sub install_as_vendor { $_[0]->installdirs('vendor') } sub dynamic_config { my $self = shift; my $value = @_ ? shift : 1; if ( $self->{values}->{dynamic_config} ) { # Once dynamic we never change to static, for safety return 0; } $self->{values}->{dynamic_config} = $value ? 1 : 0; return 1; } # Convenience command sub static_config { shift->dynamic_config(0); } sub perl_version { my $self = shift; return $self->{values}->{perl_version} unless @_; my $version = shift or die( "Did not provide a value to perl_version()" ); # Normalize the version $version = $self->_perl_version($version); # We don't support the really old versions unless ( $version >= 5.005 ) { die "Module::Install only supports 5.005 or newer (use ExtUtils::MakeMaker)\n"; } $self->{values}->{perl_version} = $version; } sub all_from { my ( $self, $file ) = @_; unless ( defined($file) ) { my $name = $self->name or die( "all_from called with no args without setting name() first" ); $file = join('/', 'lib', split(/-/, $name)) . '.pm'; $file =~ s{.*/}{} unless -e $file; unless ( -e $file ) { die("all_from cannot find $file from $name"); } } unless ( -f $file ) { die("The path '$file' does not exist, or is not a file"); } $self->{values}{all_from} = $file; # Some methods pull from POD instead of code. # If there is a matching .pod, use that instead my $pod = $file; $pod =~ s/\.pm$/.pod/i; $pod = $file unless -e $pod; # Pull the different values $self->name_from($file) unless $self->name; $self->version_from($file) unless $self->version; $self->perl_version_from($file) unless $self->perl_version; $self->author_from($pod) unless @{$self->author || []}; $self->license_from($pod) unless $self->license; $self->abstract_from($pod) unless $self->abstract; return 1; } sub provides { my $self = shift; my $provides = ( $self->{values}->{provides} ||= {} ); %$provides = (%$provides, @_) if @_; return $provides; } sub auto_provides { my $self = shift; return $self unless $self->is_admin; unless (-e 'MANIFEST') { warn "Cannot deduce auto_provides without a MANIFEST, skipping\n"; return $self; } # Avoid spurious warnings as we are not checking manifest here. local $SIG{__WARN__} = sub {1}; require ExtUtils::Manifest; local *ExtUtils::Manifest::manicheck = sub { return }; require Module::Build; my $build = Module::Build->new( dist_name => $self->name, dist_version => $self->version, license => $self->license, ); $self->provides( %{ $build->find_dist_packages || {} } ); } sub feature { my $self = shift; my $name = shift; my $features = ( $self->{values}->{features} ||= [] ); my $mods; if ( @_ == 1 and ref( $_[0] ) ) { # The user used ->feature like ->features by passing in the second # argument as a reference. Accomodate for that. $mods = $_[0]; } else { $mods = \@_; } my $count = 0; push @$features, ( $name => [ map { ref($_) ? ( ref($_) eq 'HASH' ) ? %$_ : @$_ : $_ } @$mods ] ); return @$features; } sub features { my $self = shift; while ( my ( $name, $mods ) = splice( @_, 0, 2 ) ) { $self->feature( $name, @$mods ); } return $self->{values}->{features} ? @{ $self->{values}->{features} } : (); } sub no_index { my $self = shift; my $type = shift; push @{ $self->{values}->{no_index}->{$type} }, @_ if $type; return $self->{values}->{no_index}; } sub read { my $self = shift; $self->include_deps( 'YAML::Tiny', 0 ); require YAML::Tiny; my $data = YAML::Tiny::LoadFile('META.yml'); # Call methods explicitly in case user has already set some values. while ( my ( $key, $value ) = each %$data ) { next unless $self->can($key); if ( ref $value eq 'HASH' ) { while ( my ( $module, $version ) = each %$value ) { $self->can($key)->($self, $module => $version ); } } else { $self->can($key)->($self, $value); } } return $self; } sub write { my $self = shift; return $self unless $self->is_admin; $self->admin->write_meta; return $self; } sub version_from { require ExtUtils::MM_Unix; my ( $self, $file ) = @_; $self->version( ExtUtils::MM_Unix->parse_version($file) ); # for version integrity check $self->makemaker_args( VERSION_FROM => $file ); } sub abstract_from { require ExtUtils::MM_Unix; my ( $self, $file ) = @_; $self->abstract( bless( { DISTNAME => $self->name }, 'ExtUtils::MM_Unix' )->parse_abstract($file) ); } # Add both distribution and module name sub name_from { my ($self, $file) = @_; if ( Module::Install::_read($file) =~ m/ ^ \s* package \s* ([\w:]+) \s* ; /ixms ) { my ($name, $module_name) = ($1, $1); $name =~ s{::}{-}g; $self->name($name); unless ( $self->module_name ) { $self->module_name($module_name); } } else { die("Cannot determine name from $file\n"); } } sub _extract_perl_version { if ( $_[0] =~ m/ ^\s* (?:use|require) \s* v? ([\d_\.]+) \s* ; /ixms ) { my $perl_version = $1; $perl_version =~ s{_}{}g; return $perl_version; } else { return; } } sub perl_version_from { my $self = shift; my $perl_version=_extract_perl_version(Module::Install::_read($_[0])); if ($perl_version) { $self->perl_version($perl_version); } else { warn "Cannot determine perl version info from $_[0]\n"; return; } } sub author_from { my $self = shift; my $content = Module::Install::_read($_[0]); if ($content =~ m/ =head \d \s+ (?:authors?)\b \s* ([^\n]*) | =head \d \s+ (?:licen[cs]e|licensing|copyright|legal)\b \s* .*? copyright .*? \d\d\d[\d.]+ \s* (?:\bby\b)? \s* ([^\n]*) /ixms) { my $author = $1 || $2; # XXX: ugly but should work anyway... if (eval "require Pod::Escapes; 1") { # Pod::Escapes has a mapping table. # It's in core of perl >= 5.9.3, and should be installed # as one of the Pod::Simple's prereqs, which is a prereq # of Pod::Text 3.x (see also below). $author =~ s{ E<( (\d+) | ([A-Za-z]+) )> } { defined $2 ? chr($2) : defined $Pod::Escapes::Name2character_number{$1} ? chr($Pod::Escapes::Name2character_number{$1}) : do { warn "Unknown escape: E<$1>"; "E<$1>"; }; }gex; } elsif (eval "require Pod::Text; 1" && $Pod::Text::VERSION < 3) { # Pod::Text < 3.0 has yet another mapping table, # though the table name of 2.x and 1.x are different. # (1.x is in core of Perl < 5.6, 2.x is in core of # Perl < 5.9.3) my $mapping = ($Pod::Text::VERSION < 2) ? \%Pod::Text::HTML_Escapes : \%Pod::Text::ESCAPES; $author =~ s{ E<( (\d+) | ([A-Za-z]+) )> } { defined $2 ? chr($2) : defined $mapping->{$1} ? $mapping->{$1} : do { warn "Unknown escape: E<$1>"; "E<$1>"; }; }gex; } else { $author =~ s{E}{<}g; $author =~ s{E}{>}g; } $self->author($author); } else { warn "Cannot determine author info from $_[0]\n"; } } #Stolen from M::B my %license_urls = ( perl => 'http://dev.perl.org/licenses/', apache => 'http://apache.org/licenses/LICENSE-2.0', apache_1_1 => 'http://apache.org/licenses/LICENSE-1.1', artistic => 'http://opensource.org/licenses/artistic-license.php', artistic_2 => 'http://opensource.org/licenses/artistic-license-2.0.php', lgpl => 'http://opensource.org/licenses/lgpl-license.php', lgpl2 => 'http://opensource.org/licenses/lgpl-2.1.php', lgpl3 => 'http://opensource.org/licenses/lgpl-3.0.html', bsd => 'http://opensource.org/licenses/bsd-license.php', gpl => 'http://opensource.org/licenses/gpl-license.php', gpl2 => 'http://opensource.org/licenses/gpl-2.0.php', gpl3 => 'http://opensource.org/licenses/gpl-3.0.html', mit => 'http://opensource.org/licenses/mit-license.php', mozilla => 'http://opensource.org/licenses/mozilla1.1.php', open_source => undef, unrestricted => undef, restrictive => undef, unknown => undef, ); sub license { my $self = shift; return $self->{values}->{license} unless @_; my $license = shift or die( 'Did not provide a value to license()' ); $license = __extract_license($license) || lc $license; $self->{values}->{license} = $license; # Automatically fill in license URLs if ( $license_urls{$license} ) { $self->resources( license => $license_urls{$license} ); } return 1; } sub _extract_license { my $pod = shift; my $matched; return __extract_license( ($matched) = $pod =~ m/ (=head \d \s+ L(?i:ICEN[CS]E|ICENSING)\b.*?) (=head \d.*|=cut.*|)\z /xms ) || __extract_license( ($matched) = $pod =~ m/ (=head \d \s+ (?:C(?i:OPYRIGHTS?)|L(?i:EGAL))\b.*?) (=head \d.*|=cut.*|)\z /xms ); } sub __extract_license { my $license_text = shift or return; my @phrases = ( '(?:under )?the same (?:terms|license) as (?:perl|the perl (?:\d )?programming language)' => 'perl', 1, '(?:under )?the terms of (?:perl|the perl programming language) itself' => 'perl', 1, 'Artistic and GPL' => 'perl', 1, 'GNU general public license' => 'gpl', 1, 'GNU public license' => 'gpl', 1, 'GNU lesser general public license' => 'lgpl', 1, 'GNU lesser public license' => 'lgpl', 1, 'GNU library general public license' => 'lgpl', 1, 'GNU library public license' => 'lgpl', 1, 'GNU Free Documentation license' => 'unrestricted', 1, 'GNU Affero General Public License' => 'open_source', 1, '(?:Free)?BSD license' => 'bsd', 1, 'Artistic license 2\.0' => 'artistic_2', 1, 'Artistic license' => 'artistic', 1, 'Apache (?:Software )?license' => 'apache', 1, 'GPL' => 'gpl', 1, 'LGPL' => 'lgpl', 1, 'BSD' => 'bsd', 1, 'Artistic' => 'artistic', 1, 'MIT' => 'mit', 1, 'Mozilla Public License' => 'mozilla', 1, 'Q Public License' => 'open_source', 1, 'OpenSSL License' => 'unrestricted', 1, 'SSLeay License' => 'unrestricted', 1, 'zlib License' => 'open_source', 1, 'proprietary' => 'proprietary', 0, ); while ( my ($pattern, $license, $osi) = splice(@phrases, 0, 3) ) { $pattern =~ s#\s+#\\s+#gs; if ( $license_text =~ /\b$pattern\b/i ) { return $license; } } return ''; } sub license_from { my $self = shift; if (my $license=_extract_license(Module::Install::_read($_[0]))) { $self->license($license); } else { warn "Cannot determine license info from $_[0]\n"; return 'unknown'; } } sub _extract_bugtracker { my @links = $_[0] =~ m#L<( https?\Q://rt.cpan.org/\E[^>]+| https?\Q://github.com/\E[\w_]+/[\w_]+/issues| https?\Q://code.google.com/p/\E[\w_\-]+/issues/list )>#gx; my %links; @links{@links}=(); @links=keys %links; return @links; } sub bugtracker_from { my $self = shift; my $content = Module::Install::_read($_[0]); my @links = _extract_bugtracker($content); unless ( @links ) { warn "Cannot determine bugtracker info from $_[0]\n"; return 0; } if ( @links > 1 ) { warn "Found more than one bugtracker link in $_[0]\n"; return 0; } # Set the bugtracker bugtracker( $links[0] ); return 1; } sub requires_from { my $self = shift; my $content = Module::Install::_readperl($_[0]); my @requires = $content =~ m/^use\s+([^\W\d]\w*(?:::\w+)*)\s+(v?[\d\.]+)/mg; while ( @requires ) { my $module = shift @requires; my $version = shift @requires; $self->requires( $module => $version ); } } sub test_requires_from { my $self = shift; my $content = Module::Install::_readperl($_[0]); my @requires = $content =~ m/^use\s+([^\W\d]\w*(?:::\w+)*)\s+([\d\.]+)/mg; while ( @requires ) { my $module = shift @requires; my $version = shift @requires; $self->test_requires( $module => $version ); } } # Convert triple-part versions (eg, 5.6.1 or 5.8.9) to # numbers (eg, 5.006001 or 5.008009). # Also, convert double-part versions (eg, 5.8) sub _perl_version { my $v = $_[-1]; $v =~ s/^([1-9])\.([1-9]\d?\d?)$/sprintf("%d.%03d",$1,$2)/e; $v =~ s/^([1-9])\.([1-9]\d?\d?)\.(0|[1-9]\d?\d?)$/sprintf("%d.%03d%03d",$1,$2,$3 || 0)/e; $v =~ s/(\.\d\d\d)000$/$1/; $v =~ s/_.+$//; if ( ref($v) ) { # Numify $v = $v + 0; } return $v; } sub add_metadata { my $self = shift; my %hash = @_; for my $key (keys %hash) { warn "add_metadata: $key is not prefixed with 'x_'.\n" . "Use appopriate function to add non-private metadata.\n" unless $key =~ /^x_/; $self->{values}->{$key} = $hash{$key}; } } ###################################################################### # MYMETA Support sub WriteMyMeta { die "WriteMyMeta has been deprecated"; } sub write_mymeta_yaml { my $self = shift; # We need YAML::Tiny to write the MYMETA.yml file unless ( eval { require YAML::Tiny; 1; } ) { return 1; } # Generate the data my $meta = $self->_write_mymeta_data or return 1; # Save as the MYMETA.yml file print "Writing MYMETA.yml\n"; YAML::Tiny::DumpFile('MYMETA.yml', $meta); } sub write_mymeta_json { my $self = shift; # We need JSON to write the MYMETA.json file unless ( eval { require JSON; 1; } ) { return 1; } # Generate the data my $meta = $self->_write_mymeta_data or return 1; # Save as the MYMETA.yml file print "Writing MYMETA.json\n"; Module::Install::_write( 'MYMETA.json', JSON->new->pretty(1)->canonical->encode($meta), ); } sub _write_mymeta_data { my $self = shift; # If there's no existing META.yml there is nothing we can do return undef unless -f 'META.yml'; # We need Parse::CPAN::Meta to load the file unless ( eval { require Parse::CPAN::Meta; 1; } ) { return undef; } # Merge the perl version into the dependencies my $val = $self->Meta->{values}; my $perl = delete $val->{perl_version}; if ( $perl ) { $val->{requires} ||= []; my $requires = $val->{requires}; # Canonize to three-dot version after Perl 5.6 if ( $perl >= 5.006 ) { $perl =~ s{^(\d+)\.(\d\d\d)(\d*)}{join('.', $1, int($2||0), int($3||0))}e } unshift @$requires, [ perl => $perl ]; } # Load the advisory META.yml file my @yaml = Parse::CPAN::Meta::LoadFile('META.yml'); my $meta = $yaml[0]; # Overwrite the non-configure dependency hashs delete $meta->{requires}; delete $meta->{build_requires}; delete $meta->{recommends}; if ( exists $val->{requires} ) { $meta->{requires} = { map { @$_ } @{ $val->{requires} } }; } if ( exists $val->{build_requires} ) { $meta->{build_requires} = { map { @$_ } @{ $val->{build_requires} } }; } return $meta; } 1; Catalyst-Authentication-Credential-HTTP-1.016/inc/Module/Install/PaxHeader/Win32.pm000644 777777 777777 00000000213 12175027561 032203 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221580 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/inc/Module/Install/Win32.pm000644 €;Ðâp€tzÕß00000003403 12175027561 031711 0ustar00tdoranAD\Domain Users000000 000000 #line 1 package Module::Install::Win32; use strict; use Module::Install::Base (); use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '1.06'; @ISA = 'Module::Install::Base'; $ISCORE = 1; } # determine if the user needs nmake, and download it if needed sub check_nmake { my $self = shift; $self->load('can_run'); $self->load('get_file'); require Config; return unless ( $^O eq 'MSWin32' and $Config::Config{make} and $Config::Config{make} =~ /^nmake\b/i and ! $self->can_run('nmake') ); print "The required 'nmake' executable not found, fetching it...\n"; require File::Basename; my $rv = $self->get_file( url => 'http://download.microsoft.com/download/vc15/Patch/1.52/W95/EN-US/Nmake15.exe', ftp_url => 'ftp://ftp.microsoft.com/Softlib/MSLFILES/Nmake15.exe', local_dir => File::Basename::dirname($^X), size => 51928, run => 'Nmake15.exe /o > nul', check_for => 'Nmake.exe', remove => 1, ); die <<'END_MESSAGE' unless $rv; ------------------------------------------------------------------------------- Since you are using Microsoft Windows, you will need the 'nmake' utility before installation. It's available at: http://download.microsoft.com/download/vc15/Patch/1.52/W95/EN-US/Nmake15.exe or ftp://ftp.microsoft.com/Softlib/MSLFILES/Nmake15.exe Please download the file manually, save it to a directory in %PATH% (e.g. C:\WINDOWS\COMMAND\), then launch the MS-DOS command line shell, "cd" to that directory, and run "Nmake15.exe" from there; that will create the 'nmake.exe' file needed by this module. You may then resume the installation process described in README. ------------------------------------------------------------------------------- END_MESSAGE } 1; Catalyst-Authentication-Credential-HTTP-1.016/inc/Module/Install/PaxHeader/WriteAll.pm000644 777777 777777 00000000213 12175027561 033024 xustar00tdoranAD\Domain Users000000 000000 18 gid=1954207199 18 uid=1003545200 20 ctime=1374957457 20 atime=1374957457 23 SCHILY.dev=16777218 22 SCHILY.ino=4221579 18 SCHILY.nlink=2 Catalyst-Authentication-Credential-HTTP-1.016/inc/Module/Install/WriteAll.pm000644 €;Ðâp€tzÕß00000002376 12175027561 032542 0ustar00tdoranAD\Domain Users000000 000000 #line 1 package Module::Install::WriteAll; use strict; use Module::Install::Base (); use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '1.06'; @ISA = qw{Module::Install::Base}; $ISCORE = 1; } sub WriteAll { my $self = shift; my %args = ( meta => 1, sign => 0, inline => 0, check_nmake => 1, @_, ); $self->sign(1) if $args{sign}; $self->admin->WriteAll(%args) if $self->is_admin; $self->check_nmake if $args{check_nmake}; unless ( $self->makemaker_args->{PL_FILES} ) { # XXX: This still may be a bit over-defensive... unless ($self->makemaker(6.25)) { $self->makemaker_args( PL_FILES => {} ) if -f 'Build.PL'; } } # Until ExtUtils::MakeMaker support MYMETA.yml, make sure # we clean it up properly ourself. $self->realclean_files('MYMETA.yml'); if ( $args{inline} ) { $self->Inline->write; } else { $self->Makefile->write; } # The Makefile write process adds a couple of dependencies, # so write the META.yml files after the Makefile. if ( $args{meta} ) { $self->Meta->write; } # Experimental support for MYMETA if ( $ENV{X_MYMETA} ) { if ( $ENV{X_MYMETA} eq 'JSON' ) { $self->Meta->write_mymeta_json; } else { $self->Meta->write_mymeta_yaml; } } return 1; } 1;