If you are building this stuff at run time then some sort of decision tree is probably the best technique. I'd be inclined to use a nested hash. Consider:

use strict;
use warnings;

my $input = <<INPUT;
5600
5679
5700
INPUT

# Build the tree
my %tree;

while (<DATA>) {
    chomp;
    next unless length;

    my ($number, $port) = split ',';
    my @digits = split '', $number;
    my $node = \%tree;

    for my $digit (@digits) {
        last if $digit eq '.';

        if (exists $node->{$digit}) {
            $node = $node->{$digit};
            next;
        }

        $node = $node->{$digit} = {};
    }

    $node->{port} = $port;
}


# Process input numbers
open my $inFile, '<', \$input or die "Failed to open input file: $!";

while (defined (my $number = <$inFile>)) {
    chomp $number;

    my @digits = split '', $number;
    my $node = \%tree;

    for my $digit (@digits) {
        last unless exists $node->{$digit};

        $node = $node->{$digit};
    }

    print "$number---port$node->{port}\n";
}


__DATA__
56..,1
567.,2
5...,x
[download]

Prints:

5600---port1
5679---port2
5700---portx
[download]

if ( /567./ ) {
    # port 2
}
elsif ( /56../ ) {
    # port 1
}
elsif ( /5.../ ) {
    # port x
}
else {
    # what do we do in this case?
}
[download]

But these patterns are not known while coding time. It will be extracted from live gateways.

Well, how do you as a human know which pattern to use?

Encode the same criterion in your program.

Maybe you meant to direct to the "most specific" pattern. Then just sort the patterns according to their specificity:

my @sorted_patterns = sort { my $spec_a = ($a =~ tr[.][.]);
                             my $spec_b = ($b =~ tr[.][.]);
                                $spec_b <=> $spec_a
                             || $a cmp $b
                           } @patterns;
[download]