dlls/winhttp/cookie.c - wine - Git at Google

 /*
  * 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 "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;
 }
	/*
	* 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 "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;
	}