Changeset 549

Show
Ignore:
Timestamp:
03/15/02 15:57:39
Author:
miyagawa
Message:

0.03 rel

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • PHP-Session/trunk/Changes

    r548 r549  
    11Revision history for Perl extension PHP::Session 
     2 
     30.03 
     4        * added session ID validation 
     5        * implemented save() 
    26 
    370.02  Thu Mar 14 04:37:39 JST 2002 
  • PHP-Session/trunk/MANIFEST

    r545 r549  
    77t/00_compile.t 
    88t/01_deserialize.t 
     9t/02_validate.t 
     10t/03_methods.t 
     11t/04_save.t 
    912t/lib/TestUtil.pm 
  • PHP-Session/trunk/README

    r545 r549  
    2323      $session->is_registerd('bar'); 
    2424 
    25       # save session data (*UNIMPLEMENTED*) 
     25      # save session data 
    2626      $session->save; 
    2727 
    2828DESCRIPTION 
    2929    PHP::Session provides a way to read / write PHP4 session files, with 
    30     which you can make your Perl applicatiion session shared with PHP4. 
     30    which you can make your Perl application session shared with PHP4. 
     31 
     32NOTES 
     33    *   Array in PHP is hash in Perl. 
     34 
     35    *   Objects in PHP are deserialized as hash reference, blessed into 
     36        PHP::Session::Object (Null class). 
     37 
     38    *   Locking when save()ing data is acquired via exclusive flock, same as 
     39        PHP implementation. 
    3140 
    3241TODO 
    33     *   saving session data into file is UNIMPLEMENTED. 
    34  
    3542    *   WDDX support, using WDDX.pm 
    3643 
  • PHP-Session/trunk/lib/PHP/Session.pm

    r548 r549  
    33use strict; 
    44use vars qw($VERSION); 
    5 $VERSION = 0.02
     5$VERSION = 0.03
    66 
    77use vars qw(%SerialImpl); 
     
    1010); 
    1111 
     12use Fcntl qw(:flock); 
    1213use FileHandle; 
    1314use UNIVERSAL::require; 
     
    2829        _data => {}, 
    2930    }, $class; 
     31    $self->_validate_sid; 
    3032    $self->_parse_session; 
    3133    return $self; 
     
    6163} 
    6264 
    63 sub save { 
    64     die 'UNIMPLEMENTED'; 
    65 } 
    66  
    67 # private methods 
    68  
    69 sub _parse_session { 
    70     my $self = shift; 
    71     my $cont = $self->_slurp_content; 
    72     $self->{_data} = $self->decode($cont); 
    73 } 
    74  
    7565sub decode { 
    7666    my($self, $data) = @_; 
    7767    $self->serializer->decode($data); 
     68} 
     69 
     70sub encode { 
     71    my($self, $data) = @_; 
     72    $self->serializer->encode($data); 
     73} 
     74 
     75sub save { 
     76    my $self = shift; 
     77    my $handle = FileHandle->new("> " . $self->_file_path) 
     78        or _croak("can't write session file: $!"); 
     79    flock $handle, LOCK_EX; 
     80    $handle->print($self->encode($self->{_data})); 
     81    $handle->close; 
     82} 
     83 
     84# private methods 
     85 
     86sub _validate_sid { 
     87    my $self = shift; 
     88    my($id) = $self->id =~ /^([0-9a-zA-Z]*)$/; # untaint 
     89    defined $id or _croak("Invalid session id: ", $self->id); 
     90    $self->{_sid} = $id; 
     91} 
     92 
     93sub _parse_session { 
     94    my $self = shift; 
     95    my $cont = $self->_slurp_content; 
     96    $self->{_data} = $self->decode($cont); 
    7897} 
    7998 
     
    127146  $session->is_registerd('bar'); 
    128147 
    129   # save session data (*UNIMPLEMENTED*) 
     148  # save session data 
    130149  $session->save; 
    131150 
     
    133152 
    134153PHP::Session provides a way to read / write PHP4 session files, with 
    135 which you can make your Perl applicatiion session shared with PHP4. 
     154which you can make your Perl application session shared with PHP4. 
     155 
     156=head1 NOTES 
     157 
     158=over 4 
     159 
     160=item * 
     161 
     162Array in PHP is hash in Perl. 
     163 
     164=item * 
     165 
     166Objects in PHP are deserialized as hash reference, blessed into 
     167PHP::Session::Object (Null class). 
     168 
     169=item * 
     170 
     171Locking when save()ing data is acquired via exclusive flock, same as 
     172PHP implementation. 
     173 
     174=back 
    136175 
    137176=head1 TODO 
    138177 
    139178=over 4 
    140  
    141 =item * 
    142  
    143 saving session data into file is B<UNIMPLEMENTED>. 
    144179 
    145180=item * 
  • PHP-Session/trunk/lib/PHP/Session/Serializer/PHP.pm

    r548 r549  
    55 
    66use vars qw($VERSION); 
    7 $VERSION = 0.02; 
     7$VERSION = 0.03; 
     8 
     9sub _croak { require Carp; Carp::croak(@_) } 
    810 
    911sub new { 
     
    8486} 
    8587 
     88sub encode { 
     89    my($self, $data) = @_; 
     90    my $body; 
     91    for my $key (keys %$data) { 
     92        $body .= "$key|" . $self->do_encode($data->{$key}); 
     93    } 
     94    return $body; 
     95} 
     96 
     97sub do_encode { 
     98    my($self, $value) = @_; 
     99    if (! defined $value) { 
     100        return $self->encode_undef($value); 
     101    } 
     102    elsif (! ref $value) { 
     103        if ($value =~ /^\d+$/) { 
     104            return $self->encode_int($value); 
     105        } 
     106        elsif ($value =~ /^[\d\-\.]+$/) { 
     107            return $self->encode_digit($value); 
     108        } 
     109        else { 
     110            return $self->encode_string($value); 
     111        } 
     112    } 
     113    elsif (ref $value eq 'HASH') { 
     114        return $self->encode_hash($value); 
     115    } 
     116    elsif (ref $value eq 'PHP::Session::Object') { 
     117        return $self->encode_object($value); 
     118    } 
     119    else { 
     120        _croak("Can't encode ", ref($value)); 
     121    } 
     122} 
     123 
     124sub encode_undef { 
     125    my($self, $value) = @_; 
     126    return 'N;'; 
     127} 
     128 
     129sub encode_int { 
     130    my($self, $value) = @_; 
     131    return sprintf 'i:%d;', $value; 
     132} 
     133 
     134sub encode_digit { 
     135    my($self, $value) = @_; 
     136    return sprintf "d:%d;", $value; 
     137} 
     138 
     139sub encode_string { 
     140    my($self, $value) = @_; 
     141    return sprintf 's:%d:"%s";', length($value), $value; 
     142} 
     143 
     144sub encode_hash { 
     145    my($self, $value) = @_; 
     146    return sprintf 'a:%d:{%s}', 2 * (keys %$value), join('', map $self->do_encode($_), %$value); 
     147} 
     148 
     149sub encode_object { 
     150    my($self, $value) = @_; 
     151    my %impl = %$value; 
     152    my $class = delete $impl{_class}; 
     153    return sprintf 'O:%d:"%s":%d:{%s}', length($class), $class, 2 * (keys %impl), 
     154        join('', map $self->do_encode($_), %impl); 
     155} 
     156 
    861571; 
    87158__END__