OpenPlugin::Cookie - handler to parse/output cookies from/to the client

 # Retrieve the cookies from the client request

 $OP->cookies->get_incoming;

 # Create a new cookie

 $OP->cookies->set_outgoing({
                        name    => 'search_value',
                        expires => '+3M',
                        value   => 'this AND that',
                    });

 # Expire an old cookie

 $OP->cookies->set_outgoing({
                        name    => 'search_value',
                        expires => '-3d',
                        value   => undef,
                     });

 # The cookies are sent to the browser upon sending the HTTP Header

 $OP->httpheader->send_outgoing();

 http://www.ics.uci.edu/pub/ietf/http/rfc2109.txt

package OpenPlugin::Cookie;

# $Id: Cookie.pm,v 1.25 2003/04/03 01:51:23 andreychek Exp $

use strict;
use base                    qw( OpenPlugin::Plugin );
use Data::Dumper            qw( Dumper );

$OpenPlugin::Cookie::VERSION = sprintf("%d.%02d", q$Revision: 1.25 $ =~ /(\d+)\.(\d+)/);

sub OP   { return $_[0]->{_m}{OP} }
sub type { return 'cookie' }

# Tell OpenPlugin about the cookies we've been sent
sub set_incoming {
    my ( $self, $cookie ) = @_;

    return undef unless ( $cookie->{name} );

    $cookie->{value}     ||= "";
    $cookie->{domain}    ||= "";
    $cookie->{path}      ||= "";
    $cookie->{expires}   ||= "";
    $cookie->{secure}    ||= "";

    return $self->state->{ incoming }{ $cookie->{name} } = {
                                            value   => $cookie->{value},
                                            domain  => $cookie->{domain},
                                            path    => $cookie->{path},
                                            expires => $cookie->{expires},
                                            secure  => $cookie->{secure},
                                        };
}

*get = \*get_incoming;

# Retrieve cookies sent from the browser
sub get_incoming {
    my ( $self, $name ) = @_;

    # Just return a list of cookies
    unless ( $name ) {
        return keys %{ $self->state->{ incoming } };
    }

    # Return a single cookie as a hash
    return $self->state->{ incoming }{ $name };
}

# Display cookies in the outgoing cookies queue
sub get_outgoing {
    my ( $self, $name ) = @_;

     unless ( $name ) {
         return keys %{ $self->state->{ outgoing } };
     }

    return $self->state->{ outgoing }{ $name } || undef;

}

*set = \*set_outgoing;

# Save a cookie to the outgoing queue
sub set_outgoing {
    my ( $self, $args ) = @_;

    if( ref $args eq "HASH" ) {
        my @keys = keys %{ $args };

        # The cookie(s) were sent in as a hash of hashes
        if ( ref $args->{ $keys[0] } eq "HASH" ) {
            foreach my $key ( @keys ) {
                my $cookie = $args->{ $key };
                $cookie->{ name } = $key;
                $self->_set_outgoing( $cookie );
            }
        }

        # We were sent a single cookie as a hash
        else {
            $self->_set_outgoing( $args );
        }
    }

    # The cookies were sent in as an array of hashes
    elsif( ref $args eq "ARRAY" ) {
        foreach my $cookie ( @{ $args } ) {
            $self->_set_outgoing( $cookie );
        }
    }
    else {
        $self->OP->log->warn( "Unknown format used in attempt to create " .
                               "a cookie!" );
    }

    return 1;
}

# Called by set_outgoing, tells OpenPlugin to add a cookie to the outgoing
# queue
sub _set_outgoing {
    my ( $self, $args ) = @_;

    # Remove a cookie from the outgoing queue
    if (( $args->{ name } ) && ( !exists $args->{ value } )) {
        delete $self->{_m}{OP}{_state}{Cookie}{outgoing}{$args->{ name }};
        return;
    }

    $args->{path}    ||= "/";
    $args->{expires} ||= "";
    $args->{domain}  ||= "";
    $args->{secure}  ||= 0;

    return $self->state->{ outgoing }{ $args->{name} } = {
                                        value    => $args->{value},
                                        path     => $args->{path},
                                        expires  => $args->{expires},
                                        domain   => $args->{domain},
                                        secure   => $args->{secure},
                                    };
}

# These functions are defined in the individual drivers
sub init { }
sub bake { }


1;

__END__