lib/CWMP/Request.pm

package CWMP::Request;

use warnings;
use strict;

use XML::Rules;
use Data::Dump qw/dump/;
use Carp qw/confess cluck/;
use Class::Trigger;

#use Devel::LeakTrace::Fast;

=head1 NAME

CWMP::Request - parse SOAP request metods

=head1 CPE metods

All methods described below call triggers with same name

=cut

our $state;     # FIXME check this!

our $rules =  [
                #_default => 'content trim',
                x_default => sub {
                        my ($tag_name, $tag_hash, $context, $parent_data) = @_;
                        warn dump( $tag_name, $tag_hash, $context );
                },
                'ID' => sub {
                        my ($tag_name, $tag_hash, $context, $parent_data) = @_;
                        $state->{ID} = $tag_hash->{_content};
                },

                'DeviceId' => sub {
                        my ($tag_name, $tag_hash, $context, $parent_data) = @_;
                        foreach my $name ( keys %$tag_hash ) {
                                next if $name eq '_content';
                                my $key = $name;
                                $key =~ s/^\w+://;      # stip namespace
                                $state->{DeviceID}->{ $key } = _tag( $tag_hash, $name, '_content' );
                        }
                },
                'EventStruct' => sub {
                        my ($tag_name, $tag_hash, $context, $parent_data) = @_;
                        push @{ $state->{EventStruct} }, $tag_hash->{EventCode}->{_content};
                },
                qr/(MaxEnvelopes|CurrentTime|RetryCount)/ => sub {
                        my ($tag_name, $tag_hash, $context, $parent_data) = @_;
                        $state->{$tag_name} = $tag_hash->{_content};
                },
                'ParameterValueStruct' => sub {
                        my ($tag_name, $tag_hash, $context, $parent_data) = @_;
                        # Name/Value tags must be case insnesitive
                        my $value = (grep( /value/i, keys %$tag_hash ))[0];
                        $state->{Parameter}->{ _tag($tag_hash, 'Name', '_content') } = _tag($tag_hash, 'Value', '_content' );
                        $state->{_trigger} = 'ParameterValue';
                },

];

=head2 Inform

Generate InformResponse to CPE

=cut

push @$rules,
        'Inform' => sub {
                $state->{_dispatch} = 'InformResponse';         # what reponse to call
                $state->{_trigger} = 'Inform';
        };

=head2 GetRPCMethodsResponse

=cut

push @$rules,
                qr/^(?:^\w+:)*string$/ => 'content array',
                'MethodList' => sub {
                        my ($tag_name, $tag_hash, $context, $parent_data) = @_;
                        $state->{MethodList} = _tag( $tag_hash, 'string' );
                        $state->{_trigger} = 'GetRPCMethodsResponse';
                };

=head2 GetParameterNamesResponse

=cut

push @$rules,
                'ParameterInfoStruct' => sub {
                        my ($tag_name, $tag_hash, $context, $parent_data) = @_;
                        my $name = _tag($tag_hash, 'Name', '_content');
                        my $writable = _tag($tag_hash, 'Writable', '_content' );

                        confess "need state" unless ( $state ); # don't remove!

                        $state->{ParameterInfo}->{$name} = $writable;

                        #warn "## state = dump( $state ), "\n";

                        $state->{_trigger} = 'GetParameterNamesResponse';
                };
        
=head2 GetParameterAttributesResponse

=cut

push @$rules,
                'ParameterAttributeStruct' => sub {
                        my ($tag_name, $tag_hash, $context, $parent_data) = @_;
                        warn dump( $tag_name, $tag_hash, $context );
        
                        confess "need state" unless ( $state ); # don't remove!

                        my $name = _tag($tag_hash, 'Name', '_content');


                        $state->{ParameterAttribute}->{$name} = {
                                Notification => _tag($tag_hash, 'Notification', '_content' ),
                                AccessList => _tag($tag_hash, 'AccessList', 'string' ),
                        };

                        $state->{_trigger} = 'GetParameterAttributesResponse';
                };

=head2 Fault

=cut

push @$rules,
                'Fault' => sub {
                        my ($tag_name, $tag_hash, $context, $parent_data) = @_;
                        $state->{Fault} = {
                                FaultCode => _tag( $tag_hash, 'FaultCode', '_content' ),
                                FaultString => _tag( $tag_hash, 'FaultString', '_content' ),
                        };
                        warn "FAULT: ", $state->{Fault}->{FaultCode}, " ", $state->{Fault}->{FaultString}, "\n";
                        $state->{_trigger} = 'Fault';
                };

=head1 METHODS

=head2 parse

  my $state = CWMP::Request->parse( "<soap>request</soap>" );

=cut

sub parse {
        my $self = shift;

        my $xml = shift || confess "no xml?";

        $state = {};

        my $parser = XML::Rules->new(
#               start_rules => [
#                       '^division_name,fax' => 'skip',
#               ],
                namespaces => {
                        'http://schemas.xmlsoap.org/soap/envelope/' => 'soapenv',
                        'http://schemas.xmlsoap.org/soap/encoding/' => 'soap',
                        'http://www.w3.org/2001/XMLSchema' => 'xsd',
                        'http://www.w3.org/2001/XMLSchema-instance' => 'xsi',
                        'urn:dslforum-org:cwmp-1-0' => '',
                },
                rules => $rules,
        );

#       warn "## created $parser\n";

        $parser->parsestring( $xml );

        undef $parser;

        if ( my $trigger = $state->{_trigger} ) {
                warn "### call_trigger( $trigger )\n";
                $self->call_trigger( $trigger, $state );
        }
        # XXX propagate _trigger (useful for symlinks)

        return $state;
}

=head2 _tag

Get value of tag. Tag name is case insensitive (don't ask why),
we ignore namespaces and can take optional C<sub_key>
(usually C<_content>).

  _tag( $tag_hash, $name, $sub_key )

=cut

sub _tag {
        my ( $tag_hash, $name, $sub_key ) = @_;
        confess "need hash as first argument" unless ( ref $tag_hash eq 'HASH' );
        $name = (grep { m/^(?:\w+:)*$name$/i } keys %$tag_hash )[0];
#       $name =~ s/^\w+://;
        if ( defined $tag_hash->{$name} ) {
                if ( ! defined $sub_key ) {
                        return $tag_hash->{$name};
                } elsif ( defined $tag_hash->{$name}->{$sub_key} ) {
                        return $tag_hash->{$name}->{$sub_key};
                } else {
                        return if ( $name =~ m/^value$/i );
                        warn "can't find '$name/$sub_key' in ", dump( $tag_hash );
                        return;
                }
        } else {
                warn "can't find '$name' in ", dump( $tag_hash );
                return;
        }
}

1;
1	dpavlin	31	package CWMP::Request;
2
3			use warnings;
4			use strict;
5
6			use XML::Rules;
7			use Data::Dump qw/dump/;
8			use Carp qw/confess cluck/;
9	dpavlin	200	use Class::Trigger;
10	dpavlin	31
11	dpavlin	224	#use Devel::LeakTrace::Fast;
12
13	dpavlin	31	=head1 NAME
14
15	dpavlin	186	CWMP::Request - parse SOAP request metods
16	dpavlin	31
17	dpavlin	187	=head1 CPE metods
18	dpavlin	31
19	dpavlin	200	All methods described below call triggers with same name
20
21	dpavlin	31	=cut
22
23	dpavlin	90	our $state; # FIXME check this!
24	dpavlin	31
25	dpavlin	223	our $rules = [
26	dpavlin	31	#_default => 'content trim',
27			x_default => sub {
28			my ($tag_name, $tag_hash, $context, $parent_data) = @_;
29			warn dump( $tag_name, $tag_hash, $context );
30			},
31			'ID' => sub {
32			my ($tag_name, $tag_hash, $context, $parent_data) = @_;
33			$state->{ID} = $tag_hash->{_content};
34			},
35	dpavlin	186
36	dpavlin	65	'DeviceId' => sub {
37	dpavlin	31	my ($tag_name, $tag_hash, $context, $parent_data) = @_;
38			foreach my $name ( keys %$tag_hash ) {
39			next if $name eq '_content';
40			my $key = $name;
41			$key =~ s/^\w+://; # stip namespace
42			$state->{DeviceID}->{ $key } = _tag( $tag_hash, $name, '_content' );
43			}
44			},
45	dpavlin	65	'EventStruct' => sub {
46	dpavlin	31	my ($tag_name, $tag_hash, $context, $parent_data) = @_;
47			push @{ $state->{EventStruct} }, $tag_hash->{EventCode}->{_content};
48			},
49			qr/(MaxEnvelopes\|CurrentTime\|RetryCount)/ => sub {
50			my ($tag_name, $tag_hash, $context, $parent_data) = @_;
51			$state->{$tag_name} = $tag_hash->{_content};
52			},
53	dpavlin	65	'ParameterValueStruct' => sub {
54	dpavlin	31	my ($tag_name, $tag_hash, $context, $parent_data) = @_;
55			# Name/Value tags must be case insnesitive
56			my $value = (grep( /value/i, keys %$tag_hash ))[0];
57			$state->{Parameter}->{ _tag($tag_hash, 'Name', '_content') } = _tag($tag_hash, 'Value', '_content' );
58	dpavlin	203	$state->{_trigger} = 'ParameterValue';
59	dpavlin	31	},
60	dpavlin	186
61	dpavlin	187	];
62
63			=head2 Inform
64
65			Generate InformResponse to CPE
66
67			=cut
68
69			push @$rules,
70			'Inform' => sub {
71			$state->{_dispatch} = 'InformResponse'; # what reponse to call
72	dpavlin	200	$state->{_trigger} = 'Inform';
73	dpavlin	187	};
74
75	dpavlin	186	=head2 GetRPCMethodsResponse
76
77			=cut
78	dpavlin	187
79			push @$rules,
80	dpavlin	31	qr/^(?:^\w+:)*string$/ => 'content array',
81	dpavlin	65	'MethodList' => sub {
82	dpavlin	31	my ($tag_name, $tag_hash, $context, $parent_data) = @_;
83			$state->{MethodList} = _tag( $tag_hash, 'string' );
84	dpavlin	200	$state->{_trigger} = 'GetRPCMethodsResponse';
85	dpavlin	187	};
86	dpavlin	186
87			=head2 GetParameterNamesResponse
88
89			=cut
90
91	dpavlin	187	push @$rules,
92	dpavlin	65	'ParameterInfoStruct' => sub {
93			my ($tag_name, $tag_hash, $context, $parent_data) = @_;
94	dpavlin	90	my $name = _tag($tag_hash, 'Name', '_content');
95			my $writable = _tag($tag_hash, 'Writable', '_content' );
96
97			confess "need state" unless ( $state ); # don't remove!
98
99	dpavlin	214	$state->{ParameterInfo}->{$name} = $writable;
100
101	dpavlin	92	#warn "## state = dump( $state ), "\n";
102	dpavlin	200
103			$state->{_trigger} = 'GetParameterNamesResponse';
104	dpavlin	187	};
105	dpavlin	186
106	dpavlin	237	=head2 GetParameterAttributesResponse
107
108			=cut
109
110			push @$rules,
111	dpavlin	238	'ParameterAttributeStruct' => sub {
112	dpavlin	237	my ($tag_name, $tag_hash, $context, $parent_data) = @_;
113			warn dump( $tag_name, $tag_hash, $context );
114	dpavlin	238
115			confess "need state" unless ( $state ); # don't remove!
116
117			my $name = _tag($tag_hash, 'Name', '_content');
118
119
120			$state->{ParameterAttribute}->{$name} = {
121			Notification => _tag($tag_hash, 'Notification', '_content' ),
122			AccessList => _tag($tag_hash, 'AccessList', 'string' ),
123			};
124
125	dpavlin	237	$state->{_trigger} = 'GetParameterAttributesResponse';
126			};
127
128	dpavlin	186	=head2 Fault
129
130			=cut
131
132	dpavlin	187	push @$rules,
133	dpavlin	65	'Fault' => sub {
134	dpavlin	50	my ($tag_name, $tag_hash, $context, $parent_data) = @_;
135			$state->{Fault} = {
136			FaultCode => _tag( $tag_hash, 'FaultCode', '_content' ),
137			FaultString => _tag( $tag_hash, 'FaultString', '_content' ),
138			};
139			warn "FAULT: ", $state->{Fault}->{FaultCode}, " ", $state->{Fault}->{FaultString}, "\n";
140	dpavlin	200	$state->{_trigger} = 'Fault';
141	dpavlin	187	};
142
143			=head1 METHODS
144
145			=head2 parse
146
147			my $state = CWMP::Request->parse( "<soap>request</soap>" );
148
149			=cut
150
151	dpavlin	227	sub parse {
152			my $self = shift;
153
154			my $xml = shift \|\| confess "no xml?";
155
156			$state = {};
157
158			my $parser = XML::Rules->new(
159	dpavlin	221	# start_rules => [
160			# '^division_name,fax' => 'skip',
161			# ],
162			namespaces => {
163			'http://schemas.xmlsoap.org/soap/envelope/' => 'soapenv',
164			'http://schemas.xmlsoap.org/soap/encoding/' => 'soap',
165			'http://www.w3.org/2001/XMLSchema' => 'xsd',
166			'http://www.w3.org/2001/XMLSchema-instance' => 'xsi',
167			'urn:dslforum-org:cwmp-1-0' => '',
168			},
169			rules => $rules,
170	dpavlin	227	);
171	dpavlin	221
172	dpavlin	231	# warn "## created $parser\n";
173	dpavlin	223
174	dpavlin	227	$parser->parsestring( $xml );
175	dpavlin	223
176	dpavlin	227	undef $parser;
177	dpavlin	221
178	dpavlin	200	if ( my $trigger = $state->{_trigger} ) {
179	dpavlin	203	warn "### call_trigger( $trigger )\n";
180			$self->call_trigger( $trigger, $state );
181	dpavlin	200	}
182	dpavlin	230	# XXX propagate _trigger (useful for symlinks)
183
184	dpavlin	187	return $state;
185			}
186
187			=head2 _tag
188
189			Get value of tag. Tag name is case insensitive (don't ask why),
190			we ignore namespaces and can take optional C<sub_key>
191			(usually C<_content>).
192
193			_tag( $tag_hash, $name, $sub_key )
194
195			=cut
196
197			sub _tag {
198			my ( $tag_hash, $name, $sub_key ) = @_;
199			confess "need hash as first argument" unless ( ref $tag_hash eq 'HASH' );
200			$name = (grep { m/^(?:\w+:)*$name$/i } keys %$tag_hash )[0];
201			# $name =~ s/^\w+://;
202			if ( defined $tag_hash->{$name} ) {
203			if ( ! defined $sub_key ) {
204			return $tag_hash->{$name};
205			} elsif ( defined $tag_hash->{$name}->{$sub_key} ) {
206			return $tag_hash->{$name}->{$sub_key};
207			} else {
208			return if ( $name =~ m/^value$/i );
209			warn "can't find '$name/$sub_key' in ", dump( $tag_hash );
210			return;
211			}
212			} else {
213			warn "can't find '$name' in ", dump( $tag_hash );
214			return;
215			}
216			}
217
218	dpavlin	32	1;