cookie.c

/*
 * cookie.c - The Apache::Cookie class
 * $Id$
 *
 * Author: Michael Granger <mgranger@RubyCrafters.com>
 * Copyright (c) 2003 RubyCrafters, LLC. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * 
 */

#include "mod_ruby.h"
#include "apachelib.h"

VALUE rb_cApacheCookie;

/* Cookie option IDs */
static ID id_name, id_value, id_expires, id_domain, id_path, id_secure;
static VALUE cookie_date_format;


VALUE rb_apache_cookie_new(ApacheCookie *cookie)
{
    return Data_Wrap_Struct(rb_cApacheCookie, 0, 0, cookie);
}


/*
 * Object validity checker. Returns the data pointer.
 */
static ApacheCookie *check_cookie( VALUE self )
{
    Check_Type( self, T_DATA );
    if ( !rb_obj_is_instance_of(self, rb_cApacheCookie) ) {
        rb_raise( rb_eTypeError,
                  "wrong argument type %s (expected Apache::Cookie)",
                  rb_class2name(CLASS_OF( self )) );
    }
    return DATA_PTR( self );
}


/*
 * Fetch the data pointer and check it for sanity.
 */
static ApacheCookie *get_cookie( VALUE self )
{
    ApacheCookie *ptr = check_cookie( self );
    if ( !ptr ) rb_raise( rb_eRuntimeError, "uninitialized Apache::Cookie" );
    return ptr;
}



/* Class methods */

/*
 * allocate()
 * --
 * Allocate a new Apache::Cookie object.
 */
static VALUE cookie_s_alloc( VALUE klass )
{
    return Data_Wrap_Struct( klass, 0, 0, 0 );
}



/* Instance methods */

/*
 * name
 * --
 * Returns the name of the cookie.
 */
static VALUE cookie_name( VALUE self )
{
    ApacheCookie *cookie = get_cookie( self );
    return rb_tainted_str_new2( cookie->name );
}


/*
 * name=
 * --
 * Sets the name of the cookie.
 */
static VALUE cookie_name_eq( VALUE self, VALUE arg )
{
    ApacheCookie *cookie = get_cookie( self );
    VALUE name = rb_check_convert_type( arg, T_STRING, "String", "to_s" );

    cookie->name = StringValuePtr( name );
    return name;
}


/*
 * value
 * --
 * Returns the first value stored in the cookie as a String.
 */
static VALUE cookie_value( VALUE self )
{
    ApacheCookie *cookie = get_cookie( self );
    VALUE item;

    item = rb_tainted_str_new2( ApacheCookieFetch(cookie, 0) );
    return item;
}


/*
 * values
 * --
 * Returns all the values stored in the cookie as an Array.
 */
static VALUE cookie_values( VALUE self )
{
    ApacheCookie *cookie = get_cookie( self );
    VALUE items = rb_ary_new();
    int i;

    for ( i = 0; i < ApacheCookieItems(cookie); i++ ) {
        VALUE val = rb_tainted_str_new2( ApacheCookieFetch(cookie, i) );
        rb_ary_push( items, val );
    }

    return items;
	
}


/*
 * Iterator: stringify the +val+ and push it onto the given +ary+.
 */
static VALUE cookie_stringify_push( VALUE val, VALUE ary )
{
    VALUE sval = rb_check_convert_type( val, T_STRING, "String", "to_s" );
    rb_ary_push( ary, sval );
    return ary;
}

    
/*
 * value=( newval )
 * --
 * Sets the value of the cookie to +newval+. If the +newval+ responds to
 * #each, it will be called, and the iterated value will be added by calling
 * ##to_s on it.  Otherwise, just the given +newval+ object will be
 * turned into a string via #to_s.
 */
static VALUE cookie_value_eq( VALUE self, VALUE newval )
{
    ApacheCookie *cookie = get_cookie( self );
    VALUE items = rb_ary_new();
    int i;

    if ( rb_respond_to(newval, rb_intern("each")) ) {
        rb_iterate( rb_each, newval, cookie_stringify_push, items );
    }
    else {
        rb_ary_push( items,
                     rb_check_convert_type(newval, T_STRING, "String", "to_s") );
    }

    ApacheCookieItems(cookie) = 0;
    for ( i = 0; i < RARRAY_LEN(items); i++ ) {
        ApacheCookieAddLen( cookie,
                            RSTRING_PTR(*(RARRAY_PTR(items) + i)),
                            RSTRING_LEN(*(RARRAY_PTR(items) + i)) );
    }

    return items;
}


/*
 * domain
 * --
 * Returns the domain of the cookie.
 */
static VALUE cookie_domain( VALUE self )
{
    ApacheCookie *cookie = get_cookie( self );
    if ( cookie->domain == NULL ) 
        return Qnil;
    else
        return rb_tainted_str_new2( cookie->domain );
}

    
/*
 * domain=( newdomain )
 * --
 * Sets the domain of the cookie to the specified +newdomain+.
 */
static VALUE cookie_domain_eq( VALUE self, VALUE newdomain )
{
    ApacheCookie *cookie = get_cookie( self );
    cookie->domain = StringValuePtr( newdomain );
    return newdomain;
}


/*
 * path
 * --
 * Returns the path of the cookie.
 */
static VALUE cookie_path( VALUE self )
{
    ApacheCookie *cookie = get_cookie( self );
    return rb_tainted_str_new2( cookie->path );
}

    
/*
 * path=( newpath )
 * --
 * Sets the path of the cookie to +newpath+.
 */
static VALUE cookie_path_eq( VALUE self, VALUE newpath )
{
    ApacheCookie *cookie = get_cookie( self );
    cookie->path = StringValuePtr( newpath );
    return newpath;
}


/*
 * expires
 * --
 * Returns the value of the 'expires' field.
 */
static VALUE cookie_expires( VALUE self )
{
    ApacheCookie *cookie = get_cookie( self );
    if ( cookie->expires == NULL )
        return Qnil;
    else
        return rb_tainted_str_new2( cookie->expires );
}


/*
 * expires=( expiration )
 * --
 * Sets the 'expires' field. The +expiration+ object can be either a String or a
 * Time object. If it is a string, any of the following formats are permitted:
 *
 *   +30s::                                30 seconds from now 
 *   +10m::                                ten minutes from now 
 *   +1h::                                 one hour from now 
 *   -1d::                                 yesterday (i.e. "ASAP!") 
 *   now::                                 immediately 
 *   +3M::                                 in three months 
 *   +10y::                                in ten years time 
 *   Thursday, 25-Apr-1999 00:40:33 GMT::  at the indicated time & date
 */
static VALUE cookie_expires_eq( VALUE self, VALUE expiration )
{
    ApacheCookie *cookie = get_cookie( self );
    
    if ( rb_obj_is_kind_of(expiration, rb_cTime) ) {
        expiration = rb_funcall( expiration, rb_intern("gmtime"), 0 );
        expiration = rb_funcall( expiration, rb_intern("strftime"),
                                 1, cookie_date_format );
    }

    ApacheCookie_expires( cookie, StringValuePtr(expiration) );
    return expiration;
}


/*
 * secure?
 * --
 * Returns +true+ if the cookie's 'secure' flag is set.
 */
static VALUE cookie_secure( VALUE self )
{
    ApacheCookie *cookie = get_cookie( self );
    return cookie->secure ? Qtrue : Qfalse;
}

    
/*
 * secure=( bool )
 * --
 * Sets the 'secure' flag of the cookie to either +true+ or +false+.
 */
static VALUE cookie_secure_eq( VALUE self, VALUE val )
{
    ApacheCookie *cookie = get_cookie( self );
    cookie->secure = RTEST(val) ? 1 : 0;
    return cookie->secure ? Qtrue : Qfalse;
}


/*
 * Iterator: set attributes one at a time.
 */
static VALUE cookie_set_attr( VALUE pair, VALUE self )
{
    ID attr;
    VALUE val;

    /* Make sure the argument's an Array. */
    Check_Type( pair, T_ARRAY );
    if ( !RARRAY_LEN(pair) == 2 )
        rb_raise( rb_eArgError, "Expected an array of 2 elements, not %d",
                  (int) RARRAY_LEN(pair) );

    /* Pick the attr name (converted to an ID) and value out of the iterator
       pair. */
    attr = rb_to_id( *(RARRAY_PTR(pair)) );
    val = *(RARRAY_PTR(pair) + 1);

    /* Set the option specified. */
    if ( attr == id_name ) {
        cookie_name_eq( self, val );
    }
    else if ( attr == id_value ) {
        cookie_value_eq( self, val );
    }
    else if ( attr == id_expires ) {
        cookie_expires_eq( self, val );
    }
    else if ( attr == id_domain ) {
        cookie_domain_eq( self, val );
    }
    else if ( attr == id_path ) {
        cookie_path_eq( self, val );
    }
    else if ( attr == id_secure ) {
        cookie_secure_eq( self, val );
    }
    else {
	VALUE s = rb_inspect(*( RARRAY_PTR(pair) ));
        rb_raise( rb_eArgError, "Unknown attribute %s",
                  StringValuePtr(s) );
    }

    return val;
}


/*
 * initialize( request, options={} )
 * --
 * Returns a new Apache::Cookie for the specified +request+ (an Apache::Request
 * object). The optional +options+ Hash may be used to initialize the cookie's
 * attributes. The following keys are supported:
 *
 *   :name
 *	    Sets the name field to the given value. 
 *	 :value
 *	    Adds the value to values field. 
 *	 :expires
 *	    Sets the expires field to the calculated date String or Time object. See
 *	    Apache::Cookie#expires for a listing of format options. The default is
 *	    +nil+.
 *	 :domain
 *	    Sets the domain field to the given value. The default is nil. 
 *	 :path
 *	    Sets the path field to the given value. The default path is derived from
 *	    the requested uri.
 *	 :secure
 *	    Sets the secure field to +true+ or +false+.
 */
static VALUE cookie_init( int argc, VALUE *argv, VALUE self )
{
    if ( !check_cookie(self) ) {
        ApacheCookie *ptr;
        request_rec *r;
        VALUE request, attrs;
    
        /* Read arguments, making sure the second one is a Hash if given */
        if ( rb_scan_args(argc, argv, "11", &request, &attrs) == 2 ) {
            Check_Type( attrs, T_HASH );
        }

        /* Check request argument to be sure it's an Apache::Request */
        if ( !rb_obj_is_instance_of(request, rb_cApacheRequest) )
            rb_raise( rb_eTypeError, "wrong argument type %s: expected a %s",
                      rb_class2name(CLASS_OF(request)),
                      rb_class2name(rb_cApacheRequest) );

        /* Fetch the request_rec* from the request object and create the new
           ApacheCookie* */
        r = rb_get_request_rec( request );
        DATA_PTR( self ) = ptr = ApacheCookie_new( r, NULL );

        /* Set attributes if there were any */
        if ( RTEST(attrs) )
            rb_iterate( rb_each, attrs, cookie_set_attr, self );
    }
    else {
        rb_raise( rb_eArgError, "Cannot re-initialize Apache::Cookie object." );
    }
    
    return self;
}

    
/*
 * bake
 * --
 * Add the cookie to the output headers of the request to which it belongs.
 */
static VALUE cookie_bake( VALUE self )
{
    ApacheCookie *cookie = get_cookie( self );
    ApacheCookie_bake(cookie);
    return Qtrue;
}


/*
 * to_s
 * --
 * Returns the cookie as a String.
 */
static VALUE cookie_to_s( VALUE self )
{
    ApacheCookie *cookie = get_cookie( self );
    return rb_tainted_str_new2( ApacheCookie_as_string(cookie) );
}





/* --- End of stuff from table.c ------------------------------ */


#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE cookie_s_new(int argc, VALUE *argv, VALUE klass)
{
    VALUE obj = cookie_s_alloc(klass);
    cookie_init(argc, argv, obj);
    return obj;
}
#endif


/* Module initializer */
void rb_init_apache_cookie()
{
    id_name		= rb_intern( "name" );
    id_value	= rb_intern( "value" );
    id_expires	= rb_intern( "expires" );
    id_domain	= rb_intern( "domain" );
    id_path		= rb_intern( "path" );
    id_secure	= rb_intern( "secure" );

    cookie_date_format = rb_str_new2( "%A, %d-%b-%Y %H:%M:%S GMT" );

    /* Kluge to make Rdoc see the associations in this file */
#if FOR_RDOC_PARSER
    rb_mApache = rb_define_module( "Apache" );
#endif

    rb_cApacheCookie = rb_define_class_under( rb_mApache, "Cookie", rb_cObject );

    /* Constants */
    rb_obj_freeze( cookie_date_format );
    rb_define_const( rb_cApacheCookie, "DateFormat", cookie_date_format );


    /* Allocator */
#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_define_alloc_func( rb_cApacheCookie, cookie_s_alloc );
#else
    rb_define_singleton_method( rb_cApacheCookie, "allocate", cookie_s_alloc, 0 );
    rb_define_singleton_method(rb_cApacheCookie, "new", cookie_s_new, -1);
#endif

    /* Instance methods */
    rb_define_method( rb_cApacheCookie, "initialize", cookie_init, -1 );

    rb_define_method( rb_cApacheCookie, "name", cookie_name, 0 );
    rb_define_method( rb_cApacheCookie, "name=", cookie_name_eq, 1 );
    rb_define_method( rb_cApacheCookie, "value", cookie_value, 0 );
    rb_define_method( rb_cApacheCookie, "values", cookie_values, 0 );
    rb_define_method( rb_cApacheCookie, "value=", cookie_value_eq, 1 );
    rb_define_method( rb_cApacheCookie, "domain", cookie_domain, 0 );
    rb_define_method( rb_cApacheCookie, "domain=", cookie_domain_eq, 1 );
    rb_define_method( rb_cApacheCookie, "path", cookie_path, 0 );
    rb_define_method( rb_cApacheCookie, "path=", cookie_path_eq, 1 );
    rb_define_method( rb_cApacheCookie, "expires", cookie_expires, 0 );
    rb_define_method( rb_cApacheCookie, "expires=", cookie_expires_eq, 1 );
    rb_define_method( rb_cApacheCookie, "secure", cookie_secure, 0 );
    rb_define_method( rb_cApacheCookie, "secure=", cookie_secure_eq, 1 );

    rb_define_method( rb_cApacheCookie, "bake", cookie_bake, 0 );
    rb_define_method( rb_cApacheCookie, "to_s", cookie_to_s, 0 );
}

/* vim: set filetype=c ts=8 sw=4 : */