Sweden-Number/dlls/winhttp/cookie.c

378 lines
10 KiB
C
Raw Normal View History

/*
* Copyright 2008 Hans Leidekker for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#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"
WINE_DEFAULT_DEBUG_CHANNEL(winhttp);
struct cookie
{
struct list entry;
WCHAR *name;
WCHAR *value;
WCHAR *path;
};
struct domain
{
struct list entry;
WCHAR *name;
struct list cookies;
};
static struct domain *add_domain( struct session *session, WCHAR *name )
{
struct domain *domain;
if (!(domain = calloc( 1, sizeof(*domain) ))) return NULL;
list_init( &domain->entry );
list_init( &domain->cookies );
domain->name = strdupW( name );
list_add_tail( &session->cookie_cache, &domain->entry );
TRACE("%s\n", debugstr_w(domain->name));
return domain;
}
static struct cookie *find_cookie( struct domain *domain, const WCHAR *path, const WCHAR *name )
{
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;
}
static BOOL domain_match( const WCHAR *name, struct domain *domain, BOOL partial )
{
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;
}
static void free_cookie( struct cookie *cookie )
{
free( cookie->name );
free( cookie->value );
free( cookie->path );
free( cookie );
}
static void delete_cookie( struct cookie *cookie )
{
list_remove( &cookie->entry );
free_cookie( cookie );
}
static void delete_domain( struct domain *domain )
{
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 );
}
void destroy_cookies( struct session *session )
{
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 );
}
}
static BOOL add_cookie( struct session *session, struct cookie *cookie, WCHAR *domain_name, WCHAR *path )
{
struct domain *domain = NULL;
struct cookie *old_cookie;
struct list *item;
if (!(cookie->path = strdupW( 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;
}
static struct cookie *parse_cookie( const WCHAR *string )
{
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;
}
struct attr
{
WCHAR *name;
WCHAR *value;
};
static void free_attr( struct attr *attr )
{
if (!attr) return;
free( attr->name );
free( attr->value );
free( attr );
}
static struct attr *parse_attr( const WCHAR *str, int *used )
{
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;
}
BOOL set_cookies( struct request *request, const WCHAR *cookies )
{
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 = strdupW( request->connect->servername ))) goto end;
if (!cookie_path && !(cookie_path = strdupW( 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;
}
DWORD add_cookie_headers( struct request *request )
{
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;
}