DNS/RR/SOA.pm

filter: Statementstmt 100% 93 / 93 Branchbran 100% 24 / 24 Conditioncond 100% 12 / 12 MC/DCmcdc 100% 6 / 6 Subroutinesub 100% 20 / 20 Podpod 100% 7 / 7 totaltotal 100% 162 / 162 CC 27 SCAR 12.3
CC
27
Cov
100%
serial
7.0
_parse_rdata
5.0
_ordered
4.0
CRAP 3.4
« DNS/Resolver/android.pm ↑ Summary DNS/RR/DS.pm »
1 package Net::DNS::RR::SOA;
2  
3 7 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
4 7 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
5 7 our $VERSION = (qw$Id: SOA.pm 2002 2025-01-07 09:57:46Z willem $)[2];
6  
7 7 ▶use base qw(Net::DNS::RR);
Subroutine BEGIN: called CC=1 SCAR=0.0
8  
9  
10 =head1 NAME
11  
12 Net::DNS::RR::SOA - DNS SOA resource record
13  
14 =cut
15  
16 7 ▶use integer;
Subroutine BEGIN: called CC=1 SCAR=0.0
17  
18 7 ▶use Net::DNS::DomainName;
Subroutine BEGIN: called CC=1 SCAR=0.0
19 7 ▶use Net::DNS::Mailbox;
Subroutine BEGIN: called CC=1 SCAR=0.0
20  
21  
22 28 ▶sub _decode_rdata { ## decode rdata from wire-format octet string
Subroutine _decode_rdata: called CC=1 SCAR=0.0
23 28 my ( $self, $data, $offset, @opaque ) = @_;
24  
25 28 ( $self->{mname}, $offset ) = Net::DNS::DomainName1035->decode( $data, $offset, @opaque );
26 28 ( $self->{rname}, $offset ) = Net::DNS::Mailbox1035->decode( $data, $offset, @opaque );
27 28 @{$self}{qw(serial refresh retry expire minimum)} = unpack "\@$offset N5", $$data;
28 28 return;
29 }
30  
31  
32 12 ▶sub _encode_rdata { ## encode rdata as wire-format octet string
Subroutine _encode_rdata: called CC=1 SCAR=0.0
33 12 my ( $self, @argument ) = @_;
34 12 my ( $offset, @opaque ) = @argument;
35  
36 12 my $rname = $self->{rname};
37 12 my $rdata = $self->{mname}->encode(@argument);
38 12 $rdata .= $rname->encode( $offset + length($rdata), @opaque );
39 12 $rdata .= pack 'N5', $self->serial, @{$self}{qw(refresh retry expire minimum)};
40 12 return $rdata;
41 }
42  
43  
44 8 ▶sub _format_rdata { ## format rdata portion of RR string.
Subroutine _format_rdata: called CC=2 SCAR=6.9
45 8 my $self = shift;
46  
47 8 my $mname = $self->{mname}->string;
48 8 my $rname = $self->{rname}->string;
49 8 my $serial = $self->serial;
50 8 ▶ my $spacer = length "$serial" > 7 ? "" : "\t";
Branch: 1 branch
BranchTrueFalseTotal
length "$serial" > 7 ? : 6 2 8
51 8 return ($mname, $rname,
52 join( "\n\t\t\t\t",
53 "\t\t\t$serial$spacer\t;serial", "$self->{refresh}\t\t;refresh",
54 "$self->{retry}\t\t;retry", "$self->{expire}\t\t;expire",
55 "$self->{minimum}\t\t;minimum\n" ) );
56 }
57  
58  
59 22 ▶sub _parse_rdata { ## populate RR from rdata in argument list
Subroutine _parse_rdata: called CC=5 SCAR=16.1
60 22 my ( $self, @argument ) = @_;
61  
62 22 for (qw(mname rname)) { $self->$_( shift @argument ) }
63 22 ▶ $self->serial( shift @argument ) if scalar @argument; # possibly undefined
Branch: 1 branch
BranchTrueFalseTotal
if scalar @argument 19 3 22
64 22 for (qw(refresh retry expire minimum)) {
65 70 ▶ last unless scalar @argument;
Branch: 1 branch
BranchTrueFalseTotal
unless scalar @argument 6 64 70
66 64 $self->$_( Net::DNS::RR::ttl( {}, shift @argument ) );
67 }
68 22 return;
69 }
70  
71  
72 7 ▶sub _defaults { ## specify RR attribute default values
Subroutine _defaults: called CC=1 SCAR=0.0
73 7 my $self = shift;
74  
75 7 $self->_parse_rdata(qw(. . 0 4h 1h 3w 1h));
76 7 delete $self->{serial};
77 7 return;
78 }
79  
80  
81 25 ▶sub mname {
Subroutine mname: called CC=3 SCAR=11.0
Pod documented
82 25 my ( $self, @value ) = @_;
83 25 for (@value) { $self->{mname} = Net::DNS::DomainName1035->new($_) }
84 25 ▶ return $self->{mname} ? $self->{mname}->name : undef;
Branch: 1 branch
BranchTrueFalseTotal
$self->{'mname'} ? : 24 1 25
85 }
86  
87  
88 25 ▶sub rname {
Subroutine rname: called CC=3 SCAR=11.0
Pod documented
89 25 my ( $self, @value ) = @_;
90 25 for (@value) { $self->{rname} = Net::DNS::Mailbox1035->new($_) }
91 25 ▶ return $self->{rname} ? $self->{rname}->address : undef;
Branch: 1 branch
BranchTrueFalseTotal
$self->{'rname'} ? : 24 1 25
92 }
93  
94  
95 81 ▶sub serial {
Subroutine serial: called CC=7 SCAR=19.5
Pod documented
96 81 my ( $self, @value ) = @_;
97  
98 81 ▶ return $self->{serial} || 0 unless scalar @value; # current/default value
Branch: 1 branch
BranchTrueFalseTotal
unless scalar @value 24 57 81
Condition100%2/2
$self->{'serial'} || 0
l!l
159
MC/DC100%1/1
$self->{'serial'} || 0
$self->{'serial'}
Truth table100%2/2
A
A= $self->{'serial'}
Aresult
11
00
99  
100 57 my $value = shift @value; # replace if in sequence
101 57 ▶ return $self->{serial} = ( $value & 0xFFFFFFFF ) if _ordered( $self->{serial}, $value );
Branch: 1 branch
BranchTrueFalseTotal
if &_ordered($self->{"serial"}, $value) 35 22 57
102  
103 # unwise to assume 64-bit arithmetic, or that 32-bit integer overflow goes unpunished
104 22 ▶ my $serial = 0xFFFFFFFF & ( $self->{serial} || 0 );
Condition100%2/2
$self->{'serial'} || 0
l!l
211
MC/DC100%1/1
$self->{'serial'} || 0
$self->{'serial'}
Truth table100%2/2
A
A= $self->{'serial'}
Aresult
11
00
105 22 ▶ return $self->{serial} = 0x80000000 if $serial == 0x7FFFFFFF; # wrap
Branch: 1 branch
BranchTrueFalseTotal
if $serial == 2147483647 1 21 22
106 21 ▶ return $self->{serial} = 0x00000000 if $serial == 0xFFFFFFFF; # wrap
Branch: 1 branch
BranchTrueFalseTotal
if $serial == 4294967295 1 20 21
107 20 return $self->{serial} = $serial + 1; # increment
108 }
109  
110  
111 19 ▶sub refresh {
Subroutine refresh: called CC=3 SCAR=11.0
Pod documented
112 19 my ( $self, @value ) = @_;
113 19 for (@value) { $self->{refresh} = 0 + $_ }
114 19 ▶ return $self->{refresh} || 0;
Condition100%2/2
$self->{'refresh'} || 0
l!l
181
MC/DC100%1/1
$self->{'refresh'} || 0
$self->{'refresh'}
Truth table100%2/2
A
A= $self->{'refresh'}
Aresult
11
00
115 }
116  
117  
118 19 ▶sub retry {
Subroutine retry: called CC=3 SCAR=11.0
Pod documented
119 19 my ( $self, @value ) = @_;
120 19 for (@value) { $self->{retry} = 0 + $_ }
121 19 ▶ return $self->{retry} || 0;
Condition100%2/2
$self->{'retry'} || 0
l!l
181
MC/DC100%1/1
$self->{'retry'} || 0
$self->{'retry'}
Truth table100%2/2
A
A= $self->{'retry'}
Aresult
11
00
122 }
123  
124  
125 19 ▶sub expire {
Subroutine expire: called CC=3 SCAR=11.0
Pod documented
126 19 my ( $self, @value ) = @_;
127 19 for (@value) { $self->{expire} = 0 + $_ }
128 19 ▶ return $self->{expire} || 0;
Condition100%2/2
$self->{'expire'} || 0
l!l
181
MC/DC100%1/1
$self->{'expire'} || 0
$self->{'expire'}
Truth table100%2/2
A
A= $self->{'expire'}
Aresult
11
00
129 }
130  
131  
132 24 ▶sub minimum {
Subroutine minimum: called CC=3 SCAR=11.0
Pod documented
133 24 my ( $self, @value ) = @_;
134 24 for (@value) { $self->{minimum} = 0 + $_ }
135 24 ▶ return $self->{minimum} || 0;
Condition100%2/2
$self->{'minimum'} || 0
l!l
231
MC/DC100%1/1
$self->{'minimum'} || 0
$self->{'minimum'}
Truth table100%2/2
A
A= $self->{'minimum'}
Aresult
11
00
136 }
137  
138  
139 ########################################
140  
141 57 ▶sub _ordered() { ## irreflexive 32-bit partial ordering
Subroutine _ordered: called CC=4 SCAR=13.9
142 57 my ( $n1, $n2 ) = @_;
143  
144 57 ▶ return 0 unless defined $n2; # ( any, undef )
Branch: 1 branch
BranchTrueFalseTotal
unless defined $n2 4 53 57
145 53 ▶ return 1 unless defined $n1; # ( undef, any )
Branch: 1 branch
BranchTrueFalseTotal
unless defined $n1 22 31 53
146  
147 # unwise to assume 64-bit arithmetic, or that 32-bit integer overflow goes unpunished
148 7 ▶ use integer; # fold, leaving $n2 non-negative
Subroutine BEGIN: called CC=1 SCAR=0.0
149 31 $n1 = ( $n1 & 0xFFFFFFFF ) ^ ( $n2 & 0x80000000 ); # -2**31 <= $n1 < 2**32
150 31 $n2 = ( $n2 & 0x7FFFFFFF ); # 0 <= $n2 < 2**31
151  
152 31 ▶ return $n1 < $n2 ? ( $n1 > ( $n2 - 0x80000000 ) ) : ( $n2 < ( $n1 - 0x80000000 ) );
Branch: 1 branch
BranchTrueFalseTotal
$n1 < $n2 ? : 8 23 31
153 }
154  
155 ########################################
156  
157  
158 7 1;
159 __END__
« DNS/Resolver/android.pm ↑ Summary DNS/RR/DS.pm »