reactos/dll/win32/winhttp/cookie.c
2013-06-16 22:01:41 +00:00

283 lines
8 KiB
C

/*
* 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
*/
#define WIN32_NO_STATUS
#define _INC_WINDOWS
#define COM_NO_WINDOWS_H
#include <config.h>
//#include <stdarg.h>
#include <wine/debug.h>
//#include "wine/list.h"
//#include "windef.h"
#include <winbase.h>
#include <winhttp.h>
#include "winhttp_private.h"
WINE_DEFAULT_DEBUG_CHANNEL(winhttp);
static domain_t *add_domain( session_t *session, WCHAR *name )
{
domain_t *domain;
if (!(domain = heap_alloc_zero( sizeof(domain_t) ))) 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 cookie_t *find_cookie( domain_t *domain, const WCHAR *path, const WCHAR *name )
{
struct list *item;
cookie_t *cookie;
LIST_FOR_EACH( item, &domain->cookies )
{
cookie = LIST_ENTRY( item, cookie_t, entry );
if (!strcmpW( cookie->path, path ) && !strcmpiW( 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, domain_t *domain, BOOL partial )
{
TRACE("comparing %s with %s\n", debugstr_w(name), debugstr_w(domain->name));
if (partial && !strstrW( name, domain->name )) return FALSE;
else if (!partial && strcmpW( name, domain->name )) return FALSE;
return TRUE;
}
static void free_cookie( cookie_t *cookie )
{
heap_free( cookie->name );
heap_free( cookie->value );
heap_free( cookie->path );
heap_free( cookie );
}
static void delete_cookie( cookie_t *cookie )
{
list_remove( &cookie->entry );
free_cookie( cookie );
}
void delete_domain( domain_t *domain )
{
cookie_t *cookie;
struct list *item, *next;
LIST_FOR_EACH_SAFE( item, next, &domain->cookies )
{
cookie = LIST_ENTRY( item, cookie_t, entry );
delete_cookie( cookie );
}
list_remove( &domain->entry );
heap_free( domain->name );
heap_free( domain );
}
static BOOL add_cookie( session_t *session, cookie_t *cookie, WCHAR *domain_name, WCHAR *path )
{
domain_t *domain = NULL;
cookie_t *old_cookie;
struct list *item;
LIST_FOR_EACH( item, &session->cookie_cache )
{
domain = LIST_ENTRY( item, domain_t, entry );
if (domain_match( domain_name, domain, FALSE )) break;
domain = NULL;
}
if (!domain)
{
if (!(domain = add_domain( session, domain_name ))) return FALSE;
}
else if ((old_cookie = find_cookie( domain, path, cookie->name ))) delete_cookie( old_cookie );
cookie->path = strdupW( path );
list_add_tail( &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));
return TRUE;
}
static cookie_t *parse_cookie( const WCHAR *string )
{
cookie_t *cookie;
const WCHAR *p;
int len;
if (!(cookie = heap_alloc_zero( sizeof(cookie_t) ))) return NULL;
list_init( &cookie->entry );
if (!(p = strchrW( string, '=' )))
{
WARN("no '=' in %s\n", debugstr_w(string));
return NULL;
}
if (p == string)
{
WARN("empty cookie name in %s\n", debugstr_w(string));
return NULL;
}
len = p - string;
if (!(cookie->name = heap_alloc( (len + 1) * sizeof(WCHAR) )))
{
heap_free( cookie );
return NULL;
}
memcpy( cookie->name, string, len * sizeof(WCHAR) );
cookie->name[len] = 0;
p++; /* skip '=' */
while (*p == ' ') p++;
len = strlenW( p );
if (!(cookie->value = heap_alloc( (len + 1) * sizeof(WCHAR) )))
{
free_cookie( cookie );
return NULL;
}
memcpy( cookie->value, p, len * sizeof(WCHAR) );
cookie->value[len] = 0;
return cookie;
}
BOOL set_cookies( request_t *request, const WCHAR *cookies )
{
static const WCHAR pathW[] = {'p','a','t','h',0};
static const WCHAR domainW[] = {'d','o','m','a','i','n',0};
BOOL ret = FALSE;
WCHAR *buffer, *p, *q, *r;
WCHAR *cookie_domain = NULL, *cookie_path = NULL;
session_t *session = request->connect->session;
cookie_t *cookie;
int len;
len = strlenW( cookies );
if (!(buffer = heap_alloc( (len + 1) * sizeof(WCHAR) ))) return FALSE;
strcpyW( buffer, cookies );
p = buffer;
while (*p && *p != ';') p++;
if (*p == ';') *p++ = 0;
if (!(cookie = parse_cookie( buffer )))
{
heap_free( buffer );
return FALSE;
}
if ((q = strstrW( p, domainW ))) /* FIXME: do real attribute parsing */
{
while (*q && *q != '=') q++;
if (!*q) goto end;
r = ++q;
while (*r && *r != ';') r++;
len = r - q;
if (!(cookie_domain = heap_alloc( (len + 1) * sizeof(WCHAR) ))) goto end;
memcpy( cookie_domain, q, len * sizeof(WCHAR) );
cookie_domain[len] = 0;
}
if ((q = strstrW( p, pathW )))
{
while (*q && *q != '=') q++;
if (!*q) goto end;
r = ++q;
while (*r && *r != ';') r++;
len = r - q;
if (!(cookie_path = heap_alloc( (len + 1) * sizeof(WCHAR) ))) goto end;
memcpy( cookie_path, q, len * sizeof(WCHAR) );
cookie_path[len] = 0;
}
if (!cookie_domain && !(cookie_domain = strdupW( request->connect->servername ))) goto end;
if (!cookie_path && !(cookie_path = strdupW( request->path ))) goto end;
if ((p = strrchrW( cookie_path, '/' )) && p != cookie_path) *p = 0;
ret = add_cookie( session, cookie, cookie_domain, cookie_path );
end:
if (!ret) free_cookie( cookie );
heap_free( cookie_domain );
heap_free( cookie_path );
heap_free( buffer );
return ret;
}
BOOL add_cookie_headers( request_t *request )
{
struct list *domain_cursor;
session_t *session = request->connect->session;
LIST_FOR_EACH( domain_cursor, &session->cookie_cache )
{
domain_t *domain = LIST_ENTRY( domain_cursor, domain_t, 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 )
{
cookie_t *cookie = LIST_ENTRY( cookie_cursor, cookie_t, entry );
TRACE("comparing path %s with %s\n", debugstr_w(request->path), debugstr_w(cookie->path));
if (strstrW( request->path, cookie->path ) == request->path)
{
const WCHAR format[] = {'C','o','o','k','i','e',':',' ','%','s','=','%','s',0};
int len;
WCHAR *header;
len = strlenW( cookie->name ) + strlenW( format ) + strlenW( cookie->value );
if (!(header = heap_alloc( (len + 1) * sizeof(WCHAR) ))) return FALSE;
sprintfW( header, format, cookie->name, cookie->value );
TRACE("%s\n", debugstr_w(header));
add_request_headers( request, header, len, WINHTTP_ADDREQ_FLAG_ADD );
heap_free( header );
}
}
}
}
return TRUE;
}