File Coverage

blib/lib/CGI/Application/Plugin/Stream.pm

Criterion	Covered	Total	%
statement	59	61	96.7
branch	11	14	78.5
condition	11	16	68.7
subroutine	8	8	100.0
pod	2	2	100.0
total	91	101	90.1

package CGI::Application::Plugin::Stream;

use 5.006;
use strict;
use warnings;

use CGI::Application 3.21;
use File::Basename;
require Exporter;
use vars (qw/@ISA @EXPORT_OK/);
@ISA = qw(Exporter);

@EXPORT_OK = qw(stream stream_file);

our $VERSION = '3.00_1';

sub stream {
    my ( $self, $file_or_fh, $bytes ) = @_;

    $bytes ||= 1024;

    # Use unbuffered output, but return the state of $| to its previous state when we are done.
    local $| = 1;

    my ($fh, $basename);
    my  $size = (stat( $file_or_fh ))[7];

    # If we have a file path
    if ( ref( \$file_or_fh ) eq 'SCALAR' ) {
        # They passed along a scalar, pointing to the path of the file
        # So we need to open the file
        open($fh,"<$file_or_fh"  ) || die "failed to open file: $file_or_fh: $!";
        # Now let's go binmode (Thanks, William!)
        binmode $fh;
        $basename = basename( $file_or_fh );
    }
    # We have a file handle.
    else {
        $fh = $file_or_fh;
        $basename = 'FILE';
    }

    # Use FileHandle to make File::MMagic happy;
    # bless the filehandle into the FileHandle package to make File::MMagic happy
    require FileHandle;
    bless $fh,  "FileHandle";

    # Check what headers the user has already set and
    # don't override them.
    my %existing_headers = $self->header_props();

    # Check for a existing type header set with or without a hypheout a hyphen
    unless ( $existing_headers{'-type'} ||  $existing_headers{'type'} ) {
    	my $mime_type;

        eval {
            require File::MMagic;
            my $magic = File::MMagic->new();
            $mime_type = $magic->checktype_filehandle($fh);
        };
        warn "Failed to load File::MMagic module to determine mime type: $@" if $@;

        # Set Default
        $mime_type ||= 'application/octet-stream';

        $self->header_add('-type' => $mime_type);
    }


    unless ( $existing_headers{'Content_Length'}
        ||   $existing_headers{'-Content_Length'}
        ) {
        $self->header_add('-Content_Length' => $size);
    }

    unless ( $existing_headers{'-attachment'}
        ||   $existing_headers{'attachment'}
        ||   grep( /-?content-disposition/i, keys %existing_headers )
        ) {
        $self->header_add('-attachment' => $basename);
    }

    $self->header_type( 'none' );
    print $self->query->header( $self->header_props() );

    # This reads in the file in $byte size chunks
    my $first;
    # File::MMagic may have read some of the file, so seek back to the beginning
    seek($fh,0,0);
    while ( read( $fh, my $buffer, $bytes ) ) {
		print $buffer;
    }

    print '';	# print a null string at the end
    close ( $fh );
    return 1;
}

# The old way. Requires manually calling error_mode() if there's a problem,
# but error_mode() won't have access to "$@"
sub stream_file {
    my $self = shift;
    my $out;

    # Perhaps bad style to not use a method call here,
    # But this keeps the legacy case working, where only stream_file() was exported.
    eval { stream($self,@_) };

    # Starting with 3.0, we warn if there's a problem opening the file
    # instead of ignoring the error.
    if ($@) {
        warn $@;
        return 0;
    }
    else {
        return 1;
    }
}

1;
__END__