File Coverage

blib/lib/Net/DNS/RR/PX.pm
Criterion Covered Total %
statement 45 45 100.0
branch 4 4 100.0
condition 2 2 100.0
subroutine 12 12 100.0
pod 3 3 100.0
total 66 66 100.0


line stmt bran cond sub pod time code
1             package Net::DNS::RR::PX;
2              
3 1     1   8 use strict;
  1         3  
  1         49  
4 1     1   8 use warnings;
  1         2  
  1         137  
5             our $VERSION = (qw$Id: PX.pm 2003 2025-01-21 12:06:06Z willem $)[2];
6              
7 1     1   25 use base qw(Net::DNS::RR);
  1         2  
  1         129  
8              
9              
10             =head1 NAME
11              
12             Net::DNS::RR::PX - DNS PX resource record
13              
14             =cut
15              
16 1     1   8 use integer;
  1         1  
  1         8  
17              
18 1     1   51 use Net::DNS::DomainName;
  1         2  
  1         874  
19              
20              
21             sub _decode_rdata { ## decode rdata from wire-format octet string
22 1     1   2 my ( $self, $data, $offset, @opaque ) = @_;
23              
24 1         5 $self->{preference} = unpack( "\@$offset n", $$data );
25 1         9 ( $self->{map822}, $offset ) = Net::DNS::DomainName2535->decode( $data, $offset + 2, @opaque );
26 1         5 ( $self->{mapx400}, $offset ) = Net::DNS::DomainName2535->decode( $data, $offset, @opaque );
27 1         5 return;
28             }
29              
30              
31             sub _encode_rdata { ## encode rdata as wire-format octet string
32 5     5   13 my ( $self, $offset, @opaque ) = @_;
33              
34 5         39 my $mapx400 = $self->{mapx400};
35 5         15 my $rdata = pack( 'n', $self->{preference} );
36 5         20 $rdata .= $self->{map822}->encode( $offset + 2, @opaque );
37 5         16 $rdata .= $mapx400->encode( $offset + length($rdata), @opaque );
38 5         21 return $rdata;
39             }
40              
41              
42             sub _format_rdata { ## format rdata portion of RR string.
43 2     2   37 my $self = shift;
44              
45 2         6 my @rdata = ( $self->preference, $self->{map822}->string, $self->{mapx400}->string );
46 2         8 return @rdata;
47             }
48              
49              
50             sub _parse_rdata { ## populate RR from rdata in argument list
51 1     1   4 my ( $self, @argument ) = @_;
52              
53 1         3 for (qw(preference map822 mapx400)) { $self->$_( shift @argument ) }
  3         25  
54 1         3 return;
55             }
56              
57              
58             sub preference {
59 6     6 1 24 my ( $self, @value ) = @_;
60 6         15 for (@value) { $self->{preference} = 0 + $_ }
  2         10  
61 6   100     77 return $self->{preference} || 0;
62             }
63              
64              
65             sub map822 {
66 4     4 1 1363 my ( $self, @value ) = @_;
67 4         12 for (@value) { $self->{map822} = Net::DNS::DomainName2535->new($_) }
  2         7  
68 4 100       21 return $self->{map822} ? $self->{map822}->name : undef;
69             }
70              
71              
72             sub mapx400 {
73 4     4 1 1370 my ( $self, @value ) = @_;
74 4         10 for (@value) { $self->{mapx400} = Net::DNS::DomainName2535->new($_) }
  2         14  
75 4 100       25 return $self->{mapx400} ? $self->{mapx400}->name : undef;
76             }
77              
78              
79             my $function = sub { ## sort RRs in numerically ascending order.
80             return $Net::DNS::a->{'preference'} <=> $Net::DNS::b->{'preference'};
81             };
82              
83             __PACKAGE__->set_rrsort_func( 'preference', $function );
84              
85             __PACKAGE__->set_rrsort_func( 'default_sort', $function );
86              
87              
88             1;
89             __END__