I'd say read your config file, figure out all the files you're going to have to search and all the terms you're going to have to search for, then read the files line-by-line and do all your searches on each line as you go.

select CDR_TDM;
print $_;
select STDOUT;
[download]

is a rather silly way of doing

print CDR_TDM $_;
[download]

Yes, it should be slow; you're reading 180 MB files 3000 or so times. Is there some ordering relationship that you can exploit so that you only have to read the 180MB files once? I can guess that the files would be ordered by date+time. If that's the case, you could do something like this (obviously untested):

#!/usr/bin/perl

use warnings; use strict;

$[ = 1;
$\ = "\n";

my ($last_xdrfile,$xline);
open CDR_DETAILS, "cdr_details.1" or die "couldn't open cdr_details.1:
+ $!\n";
open CDR_TDM, ">cdr_tdm.csv" or die "couldn't write cdr_tdm.csv: $!\n"
+;
while (<CDR_DETAILS>) {
    chomp;
    my ($cdrdate,$cdrtime,$cdrcli1,$cdrcli2,$xdrfile) = (split /,/)[1,
+2,3,7,8];
    $cdrtime += 0;
    print "Record number: $.";
    print "CDRDATE: $cdrdate";
    print "CDRTIME: $cdrtime";
    print "CLI1: $cdrcli1";
    print "CLI2: $cdrcli2";
    if ($last_xdrfile ne $xdrfile) {
       print "$xdrfile != $last_xdrfile, opening file!";
       open(XDR,$xdrfile) or die "couldn't open $xdrfile: $!\n";
       chomp($xline = <XDR>);
    }
    $last_xdrfile = $xdrfile;
    while (defined $xline) {
        my ($xdrdate,$xdrtime,$xdrcli1,$xdrcli2)=(split /,/, $xline)[2
+,3,5,7];
        last if $xdrdate gt $cdrdate;
        last if $xdrtime gt $cdrtime;
        next unless $xdrdate eq $cdrdate && $xdrtime eq $cdrtime &&
                    $xdrcli1 eq $cdrcli1 && $xdrcli1 eq $cdrcli2;

        print CDR_TDM $xline;
    } continue { chomp($xline = <XDR>) }
}
[download]

What my version does is rather than read the entire 180MB file into memory, it reads it a line at a time assuming both this file and the one generating the "searches" are in date+time order. There are a couple of gyrations to get the XDRFILE to read properly:

• we do a priming read as soon as we open the file
• subsequent reads happen in a continue block so that $xline has the last line read the next time we process a line from the CDRFILE.

Once the HoA structure is filled, loop over the hash keys (file names to open), and as you read each line from the current file, loop over the search patterns and output the current line if there's a match.

Something like this:

use strict;
use warnings;

my %search;

open( LIST, "cdr_details.1" ) or die "cdr_details.1: $!";
while (<LIST>) {
    chomp;
    my @terms = (split /,/, $_, -1 )[0,1,2,6,7];
    my $xdrfile = pop @terms;  # file to search is last term

    push @{$search{$xdrfile}}, join( "\0", @terms ); 
      # save remaining terms as a null-byte-separated string
      # multiple strings are pushed into an array for each xdr file
}
close LIST;

open( OUT, ">cdr_tdm.csv" ) or die "cdr_tdm.csv: $!";

for my $xdrfile ( sort keys %search )
{
    my @findsets = @{$search{$xdrfile}};

    open( XDR, $xdrfile ) or do { warn "$xdrfile: $!\n"; next };
    while (<XDR>) {
        chomp;
        my $fldset = join( "\0", (split /,/, $_, -1 )[1,2,4,6] );
           # $fldset is a null-byte-separated string that could match 
+findsets

        for my $findset ( @findsets ) {
            if ( $fldset eq $findset ) {
                print OUT;
                last;
            }
        }
    }
    close XDR;
}
[download]

If you want the "cdr_tdm" list sorted some other way, just sort that file after this script is done writing it. (The unix "sort" command is good for that, though a perl script to do the same thing would be pretty simple as well.)