lib/CWMP/Request.pm

package CWMP::Request;

use warnings;
use strict;

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

=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!

my $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 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?";

        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,
        );

        $state = {};

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