DNS/RR/AMTRELAY.pm

filter: Statementstmt 99.0% 99 / 100 Branchbran 100% 36 / 36 Conditioncond 100% 6 / 6 MC/DCmcdc 100% 3 / 3 Subroutinesub 94.7% 18 / 19 Podpod 80.0% 3 / 5 (1 uncoverable) totaltotal 98.2% 165 / 169 (1 uncoverable) CC 30 SCAR 17.5
CC
30
Cov
99%
relay
13.0
_decode_rdata
5.0
_encode_rdata
5.0
CRAP 5.8
« DNS/RR.pm ↑ Summary DNS/Resolver/Recurse.pm »
1 package Net::DNS::RR::AMTRELAY;
2  
3 1 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
4 1 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
5 1 our $VERSION = (qw$Id: AMTRELAY.pm 2003 2025-01-21 12:06:06Z willem $)[2];
6  
7 1 ▶use base qw(Net::DNS::RR);
Subroutine BEGIN: called CC=1 SCAR=0.0
8  
9  
10 =head1 NAME
11  
12 Net::DNS::RR::AMTRELAY - DNS AMTRELAY resource record
13  
14 =cut
15  
16 1 ▶use integer;
Subroutine BEGIN: called CC=1 SCAR=0.0
17  
18 1 ▶use Carp;
Subroutine BEGIN: called CC=1 SCAR=0.0
19  
20 1 ▶use Net::DNS::DomainName;
Subroutine BEGIN: called CC=1 SCAR=0.0
21 1 ▶use Net::DNS::RR::A;
Subroutine BEGIN: called CC=1 SCAR=0.0
22 1 ▶use Net::DNS::RR::AAAA;
Subroutine BEGIN: called CC=1 SCAR=0.0
23  
24  
25 5 ▶sub _decode_rdata { ## decode rdata from wire-format octet string
Subroutine _decode_rdata: called CC=5 SCAR=16.1
26 5 my ( $self, $data, $offset ) = @_;
27  
28 5 my $size = $self->{rdlength} - 2;
29 5 @{$self}{qw(precedence relaytype relay)} = unpack "\@$offset C2 a$size", $$data;
30  
31 5 for ( $self->relaytype ) {
32 5 ▶ /^3$/ && return $self->{relay} = Net::DNS::DomainName->decode( $data, $offset + 2 );
Branch: 1 branch
BranchTrueFalseTotal
/^3$/ and return $self->{"relay"} = "Net::DNS::DomainName"->decode($data, $offset + 2) 2 3 5
33 3 ▶ /^2$/ && return $self->{relay} = pack( 'a16', $self->{relay} );
Branch: 1 branch
BranchTrueFalseTotal
/^2$/ and return $self->{"relay"} = pack("a16", $self->{"relay"}) 1 2 3
34 2 ▶ /^1$/ && return $self->{relay} = pack( 'a4', $self->{relay} );
Branch: 1 branch
BranchTrueFalseTotal
/^1$/ and return $self->{"relay"} = pack("a4", $self->{"relay"}) 1 1 2
35 }
36 1 $self->{relay} = '';
37 1 return;
38 }
39  
40  
41 9 ▶sub _encode_rdata { ## encode rdata as wire-format octet string
Subroutine _encode_rdata: called CC=5 SCAR=16.1
42 9 my $self = shift;
43  
44 9 for ( $self->relaytype ) {
45 9 ▶ /^3$/ && return pack( 'C2 a*', @{$self}{qw(precedence relaytype)}, $self->{relay}->encode );
Branch: 1 branch
BranchTrueFalseTotal
/^3$/ and return pack("C2 a*", @{$self;}{"precedence", "relaytype"}, $self->{"relay"}->encode) 6 3 9
46 3 ▶ /^2$/ && return pack( 'C2 a16', @{$self}{qw(precedence relaytype relay)} );
Branch: 1 branch
BranchTrueFalseTotal
/^2$/ and return pack("C2 a16", @{$self;}{"precedence", "relaytype", "relay"}) 1 2 3
47 2 ▶ /^1$/ && return pack( 'C2 a4', @{$self}{qw(precedence relaytype relay)} );
Branch: 1 branch
BranchTrueFalseTotal
/^1$/ and return pack("C2 a4", @{$self;}{"precedence", "relaytype", "relay"}) 1 1 2
48 }
49 1 return pack( 'C2', @{$self}{qw(precedence relaytype)} );
50 }
51  
52  
53 23 ▶sub _format_rdata { ## format rdata portion of RR string.
Subroutine _format_rdata: called CC=1 SCAR=0.0
54 23 my $self = shift;
55  
56 23 my @rdata = map { $self->$_ } qw(precedence dbit relaytype relay);
57 23 return @rdata;
58 }
59  
60  
61 7 ▶sub _parse_rdata { ## populate RR from rdata in argument list
Subroutine _parse_rdata: called CC=2 SCAR=6.9
62 7 my ( $self, @argument ) = @_;
63  
64 7 foreach (qw(precedence dbit relaytype relay)) {
65 28 $self->$_( shift @argument );
66 }
67 7 return;
68 }
69  
70  
71 1 ▶sub _defaults { ## specify RR attribute default values
Subroutine _defaults: called CC=1 SCAR=0.0
72 1 my $self = shift;
73  
74 1 @{$self}{qw(precedence relaytype relay)} = ( 0, 0, '' );
75 1 return;
76 }
77  
78  
79 33 ▶sub precedence {
Subroutine precedence: called CC=3 SCAR=11.0
Pod documented
80 33 my ( $self, @value ) = @_;
81 33 for (@value) { $self->{precedence} = 0 + $_ }
82 33 ▶ return $self->{precedence} || 0;
Condition100%2/2
$self->{'precedence'} || 0
l!l
321
MC/DC100%1/1
$self->{'precedence'} || 0
$self->{'precedence'}
Truth table100%2/2
A
A= $self->{'precedence'}
Aresult
11
00
83 }
84  
85  
86 61 ▶sub dbit {
Subroutine dbit: called CC=4 SCAR=13.9
Pod undocumented
87 61 my ( $self, @value ) = @_; # uncoverable pod
88 61 ▶ for (@value) { $self->{relaytype} = $self->relaytype | ( $_ ? 0x80 : 0 ) }
Branch: 1 branch
BranchTrueFalseTotal
$_ ? : 8 4 12
89 61 ▶ return ( $self->{relaytype} || 0 ) >> 7;
Condition100%2/2
$self->{'relaytype'} || 0
l!l
4912
MC/DC100%1/1
$self->{'relaytype'} || 0
$self->{'relaytype'}
Truth table100%2/2
A
A= $self->{'relaytype'}
Aresult
11
00
90 }
91  
92 11 ▶sub d { return &dbit } # uncoverable pod
Subroutine d: called CC=1 SCAR=0.0
Pod undocumented (uncoverable)
93  
94  
95 100 ▶sub relaytype {
Subroutine relaytype: called CC=4 SCAR=13.9
Pod documented
96 100 my ( $self, @value ) = @_;
97 100 ▶ for (@value) { $self->{relaytype} = $self->dbit ? ( 0x80 | $_ ) : $_ }
Branch: 1 branch
BranchTrueFalseTotal
$self->dbit ? : 14 6 20
98 100 ▶ return 0x7f & ( $self->{relaytype} || 0 );
Condition100%2/2
$self->{'relaytype'} || 0
l!l
7327
MC/DC100%1/1
$self->{'relaytype'} || 0
$self->{'relaytype'}
Truth table100%2/2
A
A= $self->{'relaytype'}
Aresult
11
00
99 }
100  
101  
102 42 ▶sub relay {
Subroutine relay: called CC=13 SCAR=25.6
Pod documented
103 42 my ( $self, @value ) = @_;
104  
105 42 for (@value) {
106 13 ▶ /^\.*$/ && do {
Branch: 1 branch
BranchTrueFalseTotal
/^\.*$/ and do { $self->relaytype(0); $self->{"relay"} = ""; last } 2 11 13
107 2 $self->relaytype(0);
108 2 $self->{relay} = ''; # no relay
109 2 last;
110 };
111 11 ▶ /:.*:/ && do {
Branch: 1 branch
BranchTrueFalseTotal
/:.*:/ and do { $self->relaytype(2); $self->{"relay"} = Net::DNS::RR::AAAA::address(scalar {}, $_); last } 2 9 11
112 2 $self->relaytype(2);
113 2 $self->{relay} = Net::DNS::RR::AAAA::address( {}, $_ );
114 2 last;
115 };
116 9 ▶ /\.\d+$/ && do {
Branch: 1 branch
BranchTrueFalseTotal
/\.\d+$/ and do { $self->relaytype(1); $self->{"relay"} = Net::DNS::RR::A::address(scalar {}, $_); last } 2 7 9
117 2 $self->relaytype(1);
118 2 $self->{relay} = Net::DNS::RR::A::address( {}, $_ );
119 2 last;
120 };
121 7 ▶ /\..+/ && do {
Branch: 1 branch
BranchTrueFalseTotal
/\..+/ and do { $self->relaytype(3); $self->{"relay"} = "Net::DNS::DomainName"->new($_); last } 6 1 7
122 6 $self->relaytype(3);
123 6 $self->{relay} = Net::DNS::DomainName->new($_);
124 6 last;
125 };
126 1 croak 'unrecognised relay type';
127 }
128  
129 41 ▶ if ( defined wantarray ) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined wantarray) 29 12 41
130 29 for ( $self->relaytype ) {
131 29 ▶ /^1$/ && return Net::DNS::RR::A::address( {address => $self->{relay}} );
Branch: 1 branch
BranchTrueFalseTotal
/^1$/ and return Net::DNS::RR::A::address({"address", $self->{"relay"}}) 6 23 29
132 23 ▶ /^2$/ && return Net::DNS::RR::AAAA::address( {address => $self->{relay}} );
Branch: 1 branch
BranchTrueFalseTotal
/^2$/ and return Net::DNS::RR::AAAA::address({"address", $self->{"relay"}}) 6 17 23
133 17 ▶ /^3$/ && return wantarray ? $self->{relay}->string : $self->{relay}->name;
Branch: 2 branches
BranchTrueFalseTotal
/^3$/ and return wantarray ? $self->{"relay"}->string : $self->{"relay"}->name 10 7 17
wantarray ? : 8 2 10
134 }
135 }
136 19 ▶ return wantarray ? '.' : undef;
Branch: 1 branch
BranchTrueFalseTotal
wantarray ? : 5 14 19
137 }
138  
139  
140 0 ▶my $function = sub { ## sort RRs in numerically ascending order.
Subroutine __ANON__: not called CC=1 SCAR=6.9
141 0 $Net::DNS::a->{'preference'} <=> $Net::DNS::b->{'preference'};
142 1 };
143  
144 1 __PACKAGE__->set_rrsort_func( 'preference', $function );
145  
146 1 __PACKAGE__->set_rrsort_func( 'default_sort', $function );
147  
148  
149 1 1;
150 __END__
« DNS/RR.pm ↑ Summary DNS/Resolver/Recurse.pm »