cookie.c File Reference

#include <stdarg.h>
#include <wchar.h>
#include "windef.h"
#include "winbase.h"
#include "ws2tcpip.h"
#include "winhttp.h"
#include "wine/debug.h"
#include "wine/list.h"
#include "winhttp_private.h"

Include dependency graph for cookie.c:

Go to the source code of this file.

Classes
struct	cookie
struct	domain
struct	attr

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (winhttp)
static struct domain *	add_domain (struct session *session, WCHAR *name)
static struct cookie *	find_cookie (struct domain *domain, const WCHAR *path, const WCHAR *name)
static BOOL	domain_match (const WCHAR *name, struct domain *domain, BOOL partial)
static void	free_cookie (struct cookie *cookie)
static void	delete_cookie (struct cookie *cookie)
static void	delete_domain (struct domain *domain)
void	destroy_cookies (struct session *session)
static BOOL	add_cookie (struct session *session, struct cookie *cookie, WCHAR *domain_name, WCHAR *path)
static struct cookie *	parse_cookie (const WCHAR *string)
static void	free_attr (struct attr *attr)
static struct attr *	parse_attr (const WCHAR *str, int *used)
BOOL	set_cookies (struct request *request, const WCHAR *cookies)
DWORD	add_cookie_headers (struct request *request)

Function Documentation

add_cookie()

static BOOL add_cookie ( struct session *  session, struct cookie *  cookie, WCHAR *  domain_name, WCHAR *  path  )

static

Definition at line 132 of file cookie.c.

{
    struct domain *domain = NULL;
    struct cookie *old_cookie;
    struct list *item;
 
    if (!(cookie->path = wcsdup( path ))) return FALSE;
 
    EnterCriticalSection( &session->cs );
 
    LIST_FOR_EACH( item, &session->cookie_cache )
    {
        domain = LIST_ENTRY( item, struct domain, entry );
        if (domain_match( domain_name, domain, FALSE )) break;
        domain = NULL;
    }
    if (!domain) domain = add_domain( session, domain_name );
    else if ((old_cookie = find_cookie( domain, path, cookie->name ))) delete_cookie( old_cookie );
 
    if (domain)
    {
        list_add_head( &domain->cookies, &cookie->entry );
        TRACE("domain %s path %s <- %s=%s\n", debugstr_w(domain_name), debugstr_w(cookie->path),
              debugstr_w(cookie->name), debugstr_w(cookie->value));
    }
 
    LeaveCriticalSection( &session->cs );
    return domain != NULL;
}

Referenced by replace_cookie(), set_cookie(), and set_cookies().

add_cookie_headers()

DWORD add_cookie_headers

(

struct request *

request

)

Definition at line 322 of file cookie.c.

{
    struct list *domain_cursor;
    struct session *session = request->connect->session;
    DWORD ret = ERROR_SUCCESS;
 
    EnterCriticalSection( &session->cs );
 
    LIST_FOR_EACH( domain_cursor, &session->cookie_cache )
    {
        struct domain *domain = LIST_ENTRY( domain_cursor, struct domain, entry );
        if (domain_match( request->connect->servername, domain, TRUE ))
        {
            struct list *cookie_cursor;
            TRACE("found domain %s\n", debugstr_w(domain->name));
 
            LIST_FOR_EACH( cookie_cursor, &domain->cookies )
            {
                struct cookie *cookie = LIST_ENTRY( cookie_cursor, struct cookie, entry );
 
                TRACE("comparing path %s with %s\n", debugstr_w(request->path), debugstr_w(cookie->path));
 
                if (wcsstr( request->path, cookie->path ) == request->path)
                {
                    static const WCHAR cookieW[] = {'C','o','o','k','i','e',':',' '};
                    int len, len_cookie = ARRAY_SIZE( cookieW ), len_name = lstrlenW( cookie->name );
                    WCHAR *header;
 
                    len = len_cookie + len_name;
                    if (cookie->value) len += lstrlenW( cookie->value ) + 1;
                    if (!(header = malloc( (len + 1) * sizeof(WCHAR) )))
                    {
                        LeaveCriticalSection( &session->cs );
                        return ERROR_OUTOFMEMORY;
                    }
 
                    memcpy( header, cookieW, len_cookie * sizeof(WCHAR) );
                    lstrcpyW( header + len_cookie, cookie->name );
                    if (cookie->value)
                    {
                        header[len_cookie + len_name] = '=';
                        lstrcpyW( header + len_cookie + len_name + 1, cookie->value );
                    }
 
                    TRACE("%s\n", debugstr_w(header));
                    ret = add_request_headers( request, header, len,
                                               WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON );
                    free( header );
                }
            }
        }
    }
 
    LeaveCriticalSection( &session->cs );
    return ret;
}

Referenced by send_request().

add_domain()

static struct domain * add_domain ( struct session *  session, WCHAR *  name  )

static

Definition at line 48 of file cookie.c.

{
    struct domain *domain;
 
    if (!(domain = calloc( 1, sizeof(*domain) ))) return NULL;
 
    list_init( &domain->entry );
    list_init( &domain->cookies );
 
    domain->name = wcsdup( name );
    list_add_tail( &session->cookie_cache, &domain->entry );
 
    TRACE("%s\n", debugstr_w(domain->name));
    return domain;
}

Referenced by add_cookie(), and map_nfs4ace_who().

delete_cookie()

static void delete_cookie ( struct cookie *  cookie )

static

Definition at line 98 of file cookie.c.

{
    list_remove( &cookie->entry );
    free_cookie( cookie );
}

Referenced by add_cookie(), alloc_cookie(), delete_domain(), free_cookie_domain_list(), get_cookie(), replace_cookie(), save_persistent_cookie(), and set_cookie().

delete_domain()

static void delete_domain ( struct domain *  domain )

static

Definition at line 104 of file cookie.c.

{
    struct cookie *cookie;
    struct list *item, *next;
 
    LIST_FOR_EACH_SAFE( item, next, &domain->cookies )
    {
        cookie = LIST_ENTRY( item, struct cookie, entry );
        delete_cookie( cookie );
    }
 
    list_remove( &domain->entry );
    free( domain->name );
    free( domain );
}

Referenced by destroy_cookies().

destroy_cookies()

void destroy_cookies

(

struct session *

session

)

Definition at line 120 of file cookie.c.

{
    struct list *item, *next;
    struct domain *domain;
 
    LIST_FOR_EACH_SAFE( item, next, &session->cookie_cache )
    {
        domain = LIST_ENTRY( item, struct domain, entry );
        delete_domain( domain );
    }
}

Referenced by session_destroy().

domain_match()

static BOOL domain_match ( const WCHAR *  name, struct domain *  domain, BOOL  partial  )

static

Definition at line 81 of file cookie.c.

{
    TRACE("comparing %s with %s\n", debugstr_w(name), debugstr_w(domain->name));
 
    if (partial && !wcsstr( name, domain->name )) return FALSE;
    else if (!partial && wcscmp( name, domain->name )) return FALSE;
    return TRUE;
}

Referenced by add_cookie(), and add_cookie_headers().

find_cookie()

static struct cookie * find_cookie ( struct domain *  domain, const WCHAR *  path, const WCHAR *  name  )

static

Definition at line 64 of file cookie.c.

{
    struct list *item;
    struct cookie *cookie;
 
    LIST_FOR_EACH( item, &domain->cookies )
    {
        cookie = LIST_ENTRY( item, struct cookie, entry );
        if (!wcscmp( cookie->path, path ) && !wcscmp( cookie->name, name ))
        {
            TRACE("found %s=%s\n", debugstr_w(cookie->name), debugstr_w(cookie->value));
            return cookie;
         }
    }
    return NULL;
}

Referenced by add_cookie(), replace_cookie(), and set_cookie().

free_attr()

static void free_attr ( struct attr *  attr )

static

Definition at line 207 of file cookie.c.

{
    if (!attr) return;
    free( attr->name );
    free( attr->value );
    free( attr );
}

Referenced by parse_attr(), and set_cookies().

free_cookie()

static void free_cookie ( struct cookie *  cookie )

static

Definition at line 90 of file cookie.c.

{
    free( cookie->name );
    free( cookie->value );
    free( cookie->path );
    free( cookie );
}

parse_attr()

static struct attr * parse_attr ( const WCHAR *  str, int *  used  )

static

Definition at line 215 of file cookie.c.

{
    const WCHAR *p = str, *q;
    struct attr *attr;
    int len;
 
    while (*p == ' ') p++;
    q = p;
    while (*q && *q != ' ' && *q != '=' && *q != ';') q++;
    len = q - p;
    if (!len) return NULL;
 
    if (!(attr = malloc( sizeof(*attr) ))) return NULL;
    if (!(attr->name = malloc( (len + 1) * sizeof(WCHAR) )))
    {
        free( attr );
        return NULL;
    }
    memcpy( attr->name, p, len * sizeof(WCHAR) );
    attr->name[len] = 0;
    attr->value = NULL;
 
    p = q;
    while (*p == ' ') p++;
    if (*p++ == '=')
    {
        while (*p == ' ') p++;
        q = p;
        while (*q && *q != ';') q++;
        len = q - p;
        while (len && p[len - 1] == ' ') len--;
 
        if (!(attr->value = malloc( (len + 1) * sizeof(WCHAR) )))
        {
            free_attr( attr );
            return NULL;
        }
        memcpy( attr->value, p, len * sizeof(WCHAR) );
        attr->value[len] = 0;
    }
 
    while (*q == ' ') q++;
    if (*q == ';') q++;
    *used = q - str;
 
    return attr;
}

Referenced by set_cookies().

parse_cookie()

static struct cookie * parse_cookie ( const WCHAR *  string )

static

Definition at line 162 of file cookie.c.

{
    struct cookie *cookie;
    const WCHAR *p;
    int len;
 
    if (!(p = wcschr( string, '=' ))) p = string + lstrlenW( string );
    len = p - string;
    while (len && string[len - 1] == ' ') len--;
    if (!len) return NULL;
 
    if (!(cookie = calloc( 1, sizeof(*cookie) ))) return NULL;
    list_init( &cookie->entry );
 
    if (!(cookie->name = malloc( (len + 1) * sizeof(WCHAR) )))
    {
        free( cookie );
        return NULL;
    }
    memcpy( cookie->name, string, len * sizeof(WCHAR) );
    cookie->name[len] = 0;
 
    if (*p++ == '=')
    {
        while (*p == ' ') p++;
        len = lstrlenW( p );
        while (len && p[len - 1] == ' ') len--;
 
        if (!(cookie->value = malloc( (len + 1) * sizeof(WCHAR) )))
        {
            free_cookie( cookie );
            return NULL;
        }
        memcpy( cookie->value, p, len * sizeof(WCHAR) );
        cookie->value[len] = 0;
    }
    return cookie;
}

Referenced by set_cookies().

set_cookies()

BOOL set_cookies	(	struct request *	request,
		const WCHAR *	cookies
	)

Definition at line 263 of file cookie.c.

{
    BOOL ret = FALSE;
    WCHAR *buffer, *p;
    WCHAR *cookie_domain = NULL, *cookie_path = NULL;
    struct attr *attr, *domain = NULL, *path = NULL;
    struct session *session = request->connect->session;
    struct cookie *cookie;
    int len, used;
 
    len = lstrlenW( cookies );
    if (!(buffer = malloc( (len + 1) * sizeof(WCHAR) ))) return FALSE;
    lstrcpyW( buffer, cookies );
 
    p = buffer;
    while (*p && *p != ';') p++;
    if (*p == ';') *p++ = 0;
    if (!(cookie = parse_cookie( buffer )))
    {
        free( buffer );
        return FALSE;
    }
    len = lstrlenW( p );
    while (len && (attr = parse_attr( p, &used )))
    {
        if (!wcsicmp( attr->name, L"domain" ))
        {
            domain = attr;
            cookie_domain = attr->value;
        }
        else if (!wcsicmp( attr->name, L"path" ))
        {
            path = attr;
            cookie_path = attr->value;
        }
        else
        {
            FIXME( "unhandled attribute %s\n", debugstr_w(attr->name) );
            free_attr( attr );
        }
        len -= used;
        p += used;
    }
    if (!cookie_domain && !(cookie_domain = wcsdup( request->connect->servername ))) goto end;
    if (!cookie_path && !(cookie_path = wcsdup( request->path ))) goto end;
 
    if ((p = wcsrchr( cookie_path, '/' )) && p != cookie_path) *p = 0;
    ret = add_cookie( session, cookie, cookie_domain, cookie_path );
 
end:
    if (!ret) free_cookie( cookie );
    if (domain) free_attr( domain );
    else free( cookie_domain );
    if (path) free_attr( path );
    else free( cookie_path );
    free( buffer );
    return ret;
}

Referenced by record_cookies().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

winhttp

)