• ref() returns false: The value should be used as a filename. Open the filename and parse the file.
• ref() returns SCALAR: The value should be used as a reference to a string to be parsed.
• ref() returns ARRAY: The value should be used as a ref to an array of strings to be parsed.
• ref() returns GLOB: The value should be used as a filehandle. Read from the filehandle and parse the file.

From any of those sources, the first sub will send string(s) to the parsing engine one at a time, which is a second sub. That parsing engine needs to only understand how to parse strings. It doesn't care whether it got that string from a filehandle or a scalar, because that's all handled by the invoking sub.

I'll start with a warning that you need to untaint this data carefully. This appears to be part of some CGI application, so that goes double. Also, the *DATA handle is reserved for data at the tail of your script, after a __END__ or __DATA__ or Ctrl-Z.

You have an error in if (ref($data) eq 'SCALAR'). That asks if $data is a reference to a scalar, but then you treat $data as a string.

This is a neat problem to solve in perl 5.8+ because you can open a string as a file. The open function is able to take either a handle or a filename on its own. The difficulty with your puzzle is to distinguish between a string that is a filename and one that is csv data. It looks easy to, say, look for commas with a regex or index but that discounts the possibility of unexpected filenames.

How about taking the calling convention that a reference to a scalar is data and a string is a filename? That gives you what you seem to be writing towards.

You can detect a reference to a file handle with ref($foo) eq 'GLOB'. Lexical handles will be of that type. You could also insist that global handles be passed by reference. There is a lot of dwimmerie in dealing with filehandles, so testing is much to be desired for your sub.

so how can I avoid having three separate csv parsing subs?

One way would be to build an iterator for each different input type and pass that to the parsing routine. Something like this:

use strict;
use warnings;
use Carp;
use Scalar::Util qw( openhandle );

sub filehandle_iterator {
    my $fh = shift;
    return unless openhandle( $fh );
    return sub { 
        my $row = <$fh>;
        chomp $row if defined($row);
        return $row;
    };
};

sub file_iterator {
    my $filename = shift;
    no warnings; # to avoid warnings about filenames with \n in
    return unless open my $fh, '<', $filename;
    return filehandle_iterator( $fh );
};

sub string_iterator {
    my $csv_string = shift;
    my @lines = split( /\n/, $csv_string );
    return sub { shift @lines };
};

sub parse_csv {
    my $csv_input = shift;
    my $row_iterator = 
        file_iterator( $csv_input )
        || filehandle_iterator( $csv_input )
        || string_iterator( $csv_input )
        || croak 'could not find iterator';
    while ( my $row = $row_iterator->() ) {
        # ... do stuff with row ...
        print "> $row <\n";
    };
};
[download]