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/;

=head1 NAME

CWMP::Request - parse SOAP request metods

=head1 CPE metods

=cut

my $tree = CWMP::Tree->new({ debug => 0 });

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

];

=head2 Inform

Generate InformResponse to CPE

=cut

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

=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' );
                };

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

                        # XXX dragons ahead: convert name to tree rewriting it into perl
                        my $s = '$state->{ParameterInfo}->' . $tree->name2perl( $name ) . "->{writable} = $writable;";
                        eval "$s";
                        confess "can't eval $s : $@" if ($@);

                        #warn "## state = dump( $state ), "\n";
                };
        
=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";
                };

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

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