cookies.c File Reference

#include <string.h>
#include <ctype.h>
#include "gwlib/gwlib.h"
#include "wsp.h"
#include "cookies.h"

Go to the source code of this file.

Functions
static Octstr *	get_header_value (Octstr *)
static Cookie *	parse_cookie (Octstr *)
static void	add_cookie_to_cache (const WSPMachine *, Cookie *)
static void	expire_cookies (List *)
static void	cookie_destroy (void *)
static int	have_cookie (List *, Cookie *)
static int	parse_http_date (const char *)
Cookie *	cookie_create (void)
void	cookies_destroy (List *cookies)
int	get_cookies (List *headers, const WSPMachine *sm)
int	set_cookies (List *headers, WSPMachine *sm)
static int	month_index (const char *s)

Variables
static Cookie	emptyCookie
static const char *	months []

Function Documentation

add_cookie_to_cache()

static void add_cookie_to_cache ( const WSPMachine *  sm, Cookie *  value  )

static

Definition at line 344 of file cookies.c.

References gw_assert(), and gwlist_append().

Referenced by get_cookies().

{
    gw_assert(sm != NULL);
    gw_assert(sm->cookies != NULL);
    gw_assert(value != NULL);

    gwlist_append(sm->cookies, value);

    return;
}

cookie_create()

Cookie* cookie_create

(

void

)

Definition at line 88 of file cookies.c.

References emptyCookie.

Referenced by parse_cookie().

{
    Cookie *p;

    p = gw_malloc(sizeof(Cookie));  /* Never returns NULL */

    *p = emptyCookie;
    p -> max_age = -1;
    time (&p -> birth);
    return p;
}

cookie_destroy()

static void cookie_destroy ( void *  p )

static

Definition at line 455 of file cookies.c.

References debug(), _cookie::domain, _cookie::name, octstr_destroy(), _cookie::path, _cookie::value, and _cookie::version.

Referenced by cookies_destroy(), expire_cookies(), get_cookies(), have_cookie(), and parse_cookie().

{
    Cookie *cookie;
    
    if (p == NULL) 
        return;
    cookie = p;

    octstr_destroy(cookie->name);
    octstr_destroy(cookie->value);
    octstr_destroy(cookie->version);
    octstr_destroy(cookie->domain);
    octstr_destroy(cookie->path);

    gw_free(cookie);
    debug("wap.wsp.http", 0, "cookie_destroy: Destroyed cookie");
    return;
}

cookies_destroy()

void cookies_destroy

(

List *

cookies

)

Definition at line 100 of file cookies.c.

References cookie_destroy(), gwlib_assert_init(), and gwlist_destroy().

{
    gwlib_assert_init();

    if (cookies == NULL)
        return;

    gwlist_destroy(cookies, cookie_destroy);
}

expire_cookies()

static void expire_cookies ( List *  cookies )

static

Definition at line 419 of file cookies.c.

References _cookie::birth, cookie_destroy(), debug(), error(), gw_assert(), gwlist_delete(), gwlist_get(), gwlist_len(), _cookie::max_age, _cookie::name, and octstr_get_cstr.

Referenced by set_cookies().

{
    Cookie *value = NULL;
    time_t now = 0;
    long pos = 0;

    if (cookies == NULL) {
        error(0, "expire_cookies: Null argument(s) - no Cookie list");
        return;
    }

    /* Walk through the cookie cache */

    time(&now);

    if (gwlist_len(cookies) > 0) {
        debug("wap.wsp.http", 0, "expire_cookies: Cookies in cache");
        for (pos = 0; pos < gwlist_len(cookies); pos++) {
            value = gwlist_get(cookies, pos);
            gw_assert(value != NULL);

            if (value->max_age != -1) {     /* Interesting value */
                if (value->max_age + value->birth < now) {
                    debug("wap.wsp.http", 0, "expire_cookies: Expired cookie (%s)",
                          octstr_get_cstr(value->name));
                    cookie_destroy(value);
                    gwlist_delete(cookies, pos, 1);
                }
            }
        }
    } else
        debug("wap.wsp.http", 0, "expire_cookies: No cookies in cache");

    return;
}

get_cookies()

int get_cookies	(	List *	headers,
		const WSPMachine *	sm
	)

Definition at line 111 of file cookies.c.

References add_cookie_to_cache(), cookie_destroy(), debug(), error(), get_header_value(), gwlist_get(), gwlist_len(), have_cookie(), info(), name, octstr_get_cstr, and parse_cookie().

Referenced by return_reply().

{
    Octstr *header = NULL;
    Octstr *value = NULL;
    Cookie *cookie = NULL;
    long pos = 0;

    /* 
     * This can happen if the user aborts while the HTTP request is pending from the server.
     * In that case, the session machine is destroyed and is not available to this function
     * for cookie caching.
     */

    if (sm == NULL) {
        info (0, "No session machine for cookie retrieval");
        return 0;
    }

    for (pos = 0; pos < gwlist_len(headers); pos++) {
        header = gwlist_get(headers, pos);
        /* debug ("wap.wsp.http", 0, "get_cookies: Examining header (%s)", octstr_get_cstr (header)); */
        if (strncasecmp ("set-cookie", octstr_get_cstr (header),10) == 0) {     
            debug ("wap.wsp.http", 0, "Caching cookie (%s)", octstr_get_cstr (header));

            if ((value = get_header_value (header)) == NULL) {
                error (0, "get_cookies: No value in (%s)", octstr_get_cstr(header));
                continue;
            }

            /* Parse the received cookie */
            if ((cookie = parse_cookie(value)) != NULL) {

                /* Check to see if this cookie is already present */
                if (have_cookie(sm->cookies, cookie) == 1) {
                    debug("wap.wsp.http", 0, "parse_cookie: Cookie present");
                          cookie_destroy(cookie);
                    continue;
                } else {
                    add_cookie_to_cache(sm, cookie);
                    debug("wap.wsp.http", 0, "get_cookies: Added (%s)", 
                          octstr_get_cstr(cookie -> name));
                }
            }
        }
    }

    debug("wap.wsp.http", 0, "get_cookies: End");
    return 0;
}

get_header_value()

static Octstr * get_header_value ( Octstr *  header )

static

Definition at line 218 of file cookies.c.

References colon, debug(), error(), octstr_copy, octstr_get_cstr, octstr_len(), octstr_search_char(), and octstr_strip_blanks().

Referenced by get_cookies().

{
    Octstr *h = NULL;
    long colon = -1;
    
    if (header == NULL) {
        error(0, "get_header_value: NULL argument");
        return NULL;
    }

    octstr_strip_blanks(header);
    colon = octstr_search_char(header, ':', 0);
    if (colon == -1) {
        error(0, "get_header_value: Malformed header (%s)", octstr_get_cstr (header));
        return NULL;
    } else {
        h = octstr_copy(header, colon + 1, octstr_len(header));
        octstr_strip_blanks(h);
    }

    debug("wap.wsp.http", 0, "get_header_value: Value (%s)", octstr_get_cstr (h));
    return h;
}

have_cookie()

static int have_cookie ( List *  cookies, Cookie *  cookie  )

static

Definition at line 361 of file cookies.c.

References cookie_destroy(), debug(), _cookie::domain, error(), gwlist_delete(), gwlist_get(), gwlist_len(), _cookie::max_age, _cookie::name, octstr_compare(), octstr_get_cstr, and _cookie::path.

Referenced by get_cookies().

{
    Cookie *value = NULL;
    long pos = 0;

    if (cookies == NULL || cookie == NULL) {
        error(0, "have_cookie: Null argument(s) - no Cookie list, Cookie or both");
        return 0;
    }

    /* Walk through the cookie cache, comparing cookie */
    while (pos < gwlist_len(cookies)) {
        value = gwlist_get(cookies, pos);

        /* octstr_compare() now only returns 0 on an exact match or if both args are 0 */
        debug ("wap.wsp.http", 0, "have_cookie: Comparing name (%s:%s), path (%s:%s), domain (%s:%s)",
               octstr_get_cstr(cookie->name), octstr_get_cstr(value->name),
               octstr_get_cstr(cookie->path), octstr_get_cstr(value->path),
               octstr_get_cstr(cookie->domain), octstr_get_cstr(value->domain));

        /* Match on no value or value and value equality for name, path and domain */
        if ( 
            (value->name == NULL || 
                ((value->name != NULL && cookie->name != NULL) && octstr_compare(value->name, cookie->name) == 0)) &&
            (value->path == NULL || 
                ((value->path != NULL && cookie->path != NULL) && octstr_compare(value->path, cookie->path) == 0)) &&
            (value->domain == NULL || 
                ((value->domain != NULL && cookie->domain != NULL) && octstr_compare(value->domain, cookie->domain) == 0))
           ) {
            
            /* We have a match according to 4.3.3 - discard the old one */
            cookie_destroy(value);
            gwlist_delete(cookies, pos, 1);

            /* Discard the new cookie also if max-age is 0 - set if expiry date is up */
            if (cookie->max_age == 0) {
                debug("wap.wsp.http", 0, "have_cookie: Discarding expired cookie (%s)",
                      octstr_get_cstr(cookie->name));
                return 1;
            }

            debug("wap.wsp.http", 0, "have_cookie: Updating cached cookie (%s)", 
                  octstr_get_cstr (cookie->name));
            break;
        } else {
            pos++;
        }
    }

    return 0;
}

month_index()

static int month_index ( const char *  s )

static

Definition at line 508 of file cookies.c.

References months.

Referenced by parse_http_date().

{
    const char **p = &months[0];
    int i = 0;

    while (*p != NULL) {
        if (strcmp(s, *p) == 0)
            return i;
        p++, i++;
    }

    return -1;
}

parse_cookie()

static Cookie * parse_cookie ( Octstr *  cookiestr )

static

Definition at line 248 of file cookies.c.

References cookie_create(), cookie_destroy(), error(), _cookie::max_age, _cookie::name, octstr_append_cstr(), octstr_create, octstr_get_cstr, parse_http_date(), and _cookie::value.

Referenced by get_cookies().

{
    char *v = NULL;
    char *p = NULL;
    int delta = 0;
    Cookie *c = NULL;
    Octstr **f = NULL;

    if (cookiestr == NULL) {
        error(0, "parse_cookie: NULL argument");
        return NULL;
    }

    v = gw_strdup(octstr_get_cstr (cookiestr));
    p = strtok(v, ";");
    
    c = cookie_create();    /* Never returns NULL */

    while (p != NULL) {
        while (isspace((int)*p)) p++;       /* Skip leading whitespace */

        if (strncasecmp("version", p, 7) == 0)
            f = &c -> version;
        else if (strncasecmp("path", p, 4) == 0)
            f = &c -> path;
        else if (strncasecmp("domain", p, 6) == 0)
            f = &c -> domain;   /* XXX DAVI: Shouldn't we check if domain is similar 
                         *           to real domain, and to set domain to
                         *           real domain if not set by header ??? */
        else if (strncasecmp("max-age", p, 7) == 0) {
            c -> max_age = atol(strrchr (p, '=') + 1);
            p = strtok(NULL, ";");
            continue;
        } 
        else if (strncasecmp("expires", p, 7) == 0) {
            delta = parse_http_date(p);
            if (delta != -1) 
                c->max_age = delta;
            p = strtok(NULL, ";");
            continue;
        }
        else if (strncasecmp("comment", p, 7) == 0 ) { /* Ignore comments */
            p = strtok(NULL, ";");
            continue;
        }
        else if (strncasecmp("secure", p, 6) == 0 ) { /* XXX DAVI: this should processed */
            p = strtok(NULL, ";");
            continue;
        }
        else {      /* Name value pair - this should be first */
            char *equals = NULL;

            if ((equals = strchr(p, '=')) != NULL) {
                *equals = '\0';

                c->name = octstr_create(p);
                c->value = octstr_create(equals + 1);
            } else {
                error(0, "parse_cookie: Bad name=value cookie component (%s)", p);
                cookie_destroy(c);
                return NULL;
            }
            p = strtok(NULL, ";");
            continue;
        }

        if (*f != NULL) {   /* Undefined behaviour - 4.2.2 */
            error(0, "parse_cookie: Duplicate cookie field (%s), discarding", p);
            p = strtok(NULL, ";");
            continue;
        }

        *f = octstr_create("$");
        octstr_append_cstr(*f, p);
        p = strtok(NULL, ";");
    }

    /* Process version - 4.3.4 
         * XXX DAVI: Altough it seems to be "MUST" in RFC, no one sends a Version 
         * tag when it's value is "0" 
    if (c->version == NULL) {
        c->version = octstr_create("");
        octstr_append_cstr(c->version, "$Version=\"0\";");
    }
    */

    gw_free (v);
    return c;
}

parse_http_date()

static int parse_http_date ( const char *  expires )

static

Definition at line 522 of file cookies.c.

References date(), debug(), error(), gw_mktime(), MAX_HTTP_DATE_LENGTH, and month_index().

Referenced by parse_cookie().

{
    struct tm ti;
    char *p = NULL;
    char *date = NULL;
    char month[MAX_HTTP_DATE_LENGTH];
    time_t rv;
    time_t now;

    memset(&ti, 0, sizeof(struct tm));

    /* Break up the Expires: header */
    if (!(date = strchr(expires, '='))) {
        error(0, "parse_http_date: Bogus expires type=value header (%s)", expires);
        return -1;
    } else {
        date++;
        while (isspace((int)*date))
            ++date;
    }

    /* Onto the date value */
    if (!(p = strchr (date,' '))) {
        error(0, "parse_http_date: Bogus date string (%s)", date);
        return -1;
    } else
        while (isspace((int)*p))
            ++p;

    if (MAX_HTTP_DATE_LENGTH < strlen(p)) {
        error(0, "parse_http_date: %s blows length limit (%d)", date, MAX_HTTP_DATE_LENGTH);
        return -1;
    }

    if (isalpha((int)*p)) {
        /* ctime */
        sscanf(p, (strstr(p, "DST") ? "%s %d %d:%d:%d %*s %d" : "%s %d %d:%d:%d %d"),
               month, &ti.tm_mday, &ti.tm_hour, &ti.tm_min,
               &ti.tm_sec, &ti.tm_year);
        ti.tm_year -= 1900;

    } else if (p[2] == '-') {
        /* RFC 850 (normal HTTP) */
        char  buf[MAX_HTTP_DATE_LENGTH];

        sscanf(p, "%s %d:%d:%d", buf, &ti.tm_hour, &ti.tm_min, &ti.tm_sec);
        buf[2] = '\0';
        ti.tm_mday = atoi(buf);
        buf[6] = '\0';

        strcpy(month, &buf[3]);
        ti.tm_year = atoi(&buf[7]);

        /* Prevent wraparound from ambiguity */

        if (ti.tm_year < 70) {
            ti.tm_year += 100;
        } else if (ti.tm_year > 1900) {
            ti.tm_year -= 1900;
        }
    } else {
        /* RFC 822 */
        sscanf(p,"%d %s %d %d:%d:%d",&ti.tm_mday, month, &ti.tm_year,
               &ti.tm_hour, &ti.tm_min, &ti.tm_sec);

        /* 
         * since tm_year is years since 1900 and the year we parsed
         * is absolute, we need to subtract 1900 years from it
         */
        ti.tm_year -= 1900;
    }

    ti.tm_mon = month_index(month);
    if (ti.tm_mon == -1) {
        error(0, "parse_http_date () failed on bad month value (%s)", month);
        return -1;
    }

    ti.tm_isdst = -1;

    rv = gw_mktime(&ti);
    if (ti.tm_isdst)
        rv -= 3600;

    if (rv == -1) {
        error(0, "parse_http_date(): mktime() was unable to resolve date/time: %s", 
              asctime(&ti));
        return -1;
    }

    debug("parse_http_date", 0, "Parsed date (%s) as: %s", date, asctime(&ti));

    /* 
     * If rv is valid, it should be some time in the (near) future. Normalise this to
     * a max-age semantic so we can use the same expiry mechanism 
     */
    now = time(NULL);

    if (rv - now < 0) {
        /* This is bad - set the delta to 0 so we expire next time around */
        error(0, "parse_http_date () Expiry time (%s) (delta=%ld) is in the past !", 
              asctime(&ti), rv-now);
        return 0;
    }

    return rv - now;
}

set_cookies()

int set_cookies	(	List *	headers,
		WSPMachine *	sm
	)

Definition at line 162 of file cookies.c.

References debug(), _cookie::domain, error(), expire_cookies(), gwlist_append(), gwlist_get(), gwlist_len(), _cookie::name, octstr_append(), octstr_append_char(), octstr_create, octstr_get_cstr, _cookie::path, _cookie::value, and _cookie::version.

Referenced by start_fetch().

{
    Cookie *value = NULL;
    Octstr *cookie = NULL;
    long pos = 0;

    if (headers == NULL || sm == NULL) {
        error (0, "set_cookies: Null argument(s) - no headers, WSPMachine or both");
        return -1;
    }

    /* Expire cookies that have timed out */
    expire_cookies(sm->cookies);

    /* Walk through the cookie cache, adding the cookie to the request headers */
    if (gwlist_len(sm->cookies) > 0) {
        debug("wap.wsp.http", 0, "set_cookies: Cookies in cache");

        for (pos = 0; pos < gwlist_len(sm->cookies); pos++) {
            value = gwlist_get(sm->cookies, pos);

            cookie = octstr_create("Cookie: ");
            if (value->version) 
                octstr_append(cookie, value->version);
            octstr_append(cookie, value->name);
            octstr_append_char(cookie, '=');
            octstr_append(cookie, value->value);

            if (value->path) {
                octstr_append_char(cookie, ';');
                octstr_append(cookie, value->path);
            }
            if (value->domain) {
                octstr_append_char(cookie, ';');
                octstr_append(cookie, value->domain);
            }

            gwlist_append(headers, cookie);
            debug("wap.wsp.http", 0, "set_cookies: Added (%s)", octstr_get_cstr (cookie));
        }
    } else
        debug("wap.wsp.http", 0, "set_cookies: No cookies in cache");

    return 0;
}

Variable Documentation

emptyCookie

Cookie emptyCookie

static

Definition at line 85 of file cookies.c.

Referenced by cookie_create().

months

const char* months[]

static

Initial value:

= {
    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", NULL
}

Definition at line 503 of file cookies.c.

Referenced by month_index().