Thanks again. I don't think I'm fully grasping how vec works, even after reading the doc, or the routine using vec to map the bits to the vlans and creating the ranges.

The routine formating numbers like 1,2,3 as 1-3 is great, but doesn't seem to work properly with the octet string example. Of course it won't work with Grandfather's example from what I can see since @ports just contains the VLANs allowed

Trying to shoehorn the previous example into this one:

sub xlat {
  my ($octets) = @_ ;
  return pack('B*', unpack('b*', $octets)) ;
} ;

my $test = '0x4000040000000200800000000000000000000002'
            .'0000000000c004000108008000000000000000000'
            .'00000000000000000000000000000000000000000'
            .'00000000000000000000000000000000000000000'
            .'00000000000000000000000000000000000000000'
            .'00000000000000000000000000000000000000000'
            .'00000000000';
my $bits;

$bits = showbits($test);

my @s = ranges($bits);
print "Ranges: ", join(', ', @s);

$bits = showbits(xlat($test));
@s = ranges($bits);
print join(',',@s);

$bits = showbits(xlat(xlat($test)));
@s = ranges($bits);
print join(',',@s);

sub ranges{
my $test = shift;
my $r = undef ;
my @s = () ;
for my $vn (1..length($test) * 8) {
  if (vec($test, $vn, 1)) {
    if (!defined($r)) { push @s, "$vn-" ; } ;
    $r = $vn ;
  }
  else {
    if (defined($r))  { $s[-1] .= "$r" ;  $r = undef ; } ;
  } ;
} ;
return @s;
}

sub showbits {
  my ($octets) = @_ ;
  my $s = unpack('B*', $octets) ;
  $s =~ s/([01]{8})(?=[01])/$1/g ;
  ranges($s) ;
} ;
[download]

Should, at least in my misunderstanding, produce Ranges: 1,21,54,64,158,200-201,213,231,236,248.

Instead it produces:

Using GrandFather's example

my $ports = '0x4000040000000200800000000000000000000002'
            .'0000000000c004000108008000000000000000000'
            .'00000000000000000000000000000000000000000'
            .'00000000000000000000000000000000000000000'
            .'00000000000000000000000000000000000000000'
            .'00000000000000000000000000000000000000000'
            .'00000000000';
my $basePort = 0;
my @ports;

$ports = substr $ports, 2;

while ($ports) {
    my $octet = hex substr $ports, 0, 2, '';
    my $index = 0;
    
    while ($octet) {
        next unless $octet & 0x80;
        push @ports, $basePort + $index;
    } continue {
        ++$index;
        $octet = ($octet << 1) & 0xff;
    }
    
    $basePort += 8;
}

print join ',', @ports;
[download]

produces: 1,21,54,64,158,200,201,213,231,236,248

After hours of playing with both these examples I managed to confuse myself even more. Can you point out what I'm missing?

Update:After some more tinkering I came up with the following kludge to format Grandfather's example, but something tells me there's a better way to do this. Still haven't figured out how to convert the string properly with vec.

my $ports = '0x4000040000000200800000000000000000000002'
            .'0000000000c004000108008000000000000000000'
            .'00000000000000000000000000000000000000000'
            .'00000000000000000000000000000000000000000'
            .'00000000000000000000000000000000000000000'
            .'00000000000000000000000000000000000000000'
            .'00000000000';
my $basePort = 0;
my @ports;

$ports = substr $ports, 2;

while ($ports) {
    my $octet = hex substr $ports, 0, 2, '';
    my $index = 0;
    
    while ($octet) {
        next unless $octet & 0x80;
        push @ports, $basePort + $index;
    } continue {
        ++$index;
        $octet = ($octet << 1) & 0xff;
    }
    
    $basePort += 8;
}

print join ',', @ports,"\n";
range_format(@ports);

sub range_format{

my (@numbers,$i,$start,$end);
@numbers = @_;

for ($i = 0; $i < @numbers; ++$i){
    
    my $prev = $numbers[$i-1];
    my $next = $numbers[$i+1];
    my $cur = $numbers[$i];
    
    if (($cur+1 == $next) and ($cur-1!= $prev)){
        $start = $cur;
    }
    if (($cur-1 == $prev) and ($cur+1 != $next)){
        $end = $cur;
    }
    if ((defined $start) and (defined $end)){
        print "$start-$end,";
        $start = undef;
        $end = undef;
    }else{
        unless((defined $start)||(defined $end)){print "$cur,";}}
}
}
[download]

OK, it's all down to representations.

I suggested Perl bit-vectors, so let's start there and work back up.

A Perl bit-vector should be viewed as an abstract entity, which for these purposes we're going to treat as a collection of bits, numbered from 0..'n'. We can read bit '$b' by:  $v = vec($bits, 1, $b) ; where $bits contains the bit-vector, 1 indicates this is a vector of single bit values, and $b contains the number of the bit we want the value of. Similarly we can set a bit by:  vec($bits, 1, $b) = $v ;.

What we want to do is to translate from the forms you have, to a Perl bit-vector, so that the bit number corresponds to a VLAN number.

The documentation tells us that a Perl bit-vector is a string of bytes, where (for single bit values) bit number 1 is stored as Bit0 of Byte0, bit number 7 as Bit7 of Byte0, bit number 8 as Bit0 of Byte1, and so on.

The second form you mentioned claimed to be in octets, with VLAN 0 represented by Bit7 of Byte0, VLAN 7 by Bit0 of Byte0, VLAN 8, by Bit7 of Byte1, and so on. This is similar to a Perl bit-vector, but with the bit numbers within each byte reversed.

The xlat routine translates between these two forms.

Now, what you appear to have in your hands is the second form, but not as raw (binary) octets, but in a hex representation of those octets. So the first step is to pack from there to the binary. That can be given to xlat and the result is the Perl bit-vector form, which the range subroutine can unpick.

Code below illustrates all the above. Output is:

  01000000::00000100::::00000010::10000000:::::::::::00000010::::::11000000:00000100:...
  00000010::00100000::::01000000::00000001:::::::::::01000000::::::00000011:00100000:...
  Ranges: 1, 21, 54, 64, 158, 200-201, 213, 231, 236, 248

Hope this helps clarify.
Read more... See the code (2 kB)