/* GIO - GLib Input, Output and Streaming Library
*
* Copyright (C) 2006-2007 Red Hat, Inc.
* Copyright (C) 2008 Novell, Inc.
*
* 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, see <http://www.gnu.org/licenses/>.
*
* Author: Alexander Larsson <alexl@redhat.com>
* Author: Tor Lillqvist <tml@novell.com>
*/
#include "config.h"
#include <wchar.h>
#include "gio/gioerror.h"
#include "gio/giomodule.h"
#include "gio/gvfs.h"
#include "gwinhttpfile.h"
#include "gwinhttpvfs.h"
static gboolean lookup_done = FALSE;
static gboolean funcs_found = FALSE;
static GWinHttpDllFuncs funcs;
static void
lookup_funcs (void)
{
HMODULE winhttp = NULL;
char winhttp_dll[MAX_PATH + 100];
int n;
if (lookup_done)
return;
n = GetSystemDirectory (winhttp_dll, MAX_PATH);
if (n > 0 && n < MAX_PATH)
{
if (winhttp_dll[n-1] != '\\' &&
winhttp_dll[n-1] != '/')
strcat (winhttp_dll, "\\");
strcat (winhttp_dll, "winhttp.dll");
winhttp = LoadLibrary (winhttp_dll);
}
if (winhttp != NULL)
{
funcs.pWinHttpCloseHandle = (BOOL (WINAPI *) (HINTERNET)) GetProcAddress (winhttp, "WinHttpCloseHandle");
funcs.pWinHttpCrackUrl = (BOOL (WINAPI *) (LPCWSTR,DWORD,DWORD,LPURL_COMPONENTS)) GetProcAddress (winhttp, "WinHttpCrackUrl");
funcs.pWinHttpConnect = (HINTERNET (WINAPI *) (HINTERNET,LPCWSTR,INTERNET_PORT,DWORD)) GetProcAddress (winhttp, "WinHttpConnect");
funcs.pWinHttpCreateUrl = (BOOL (WINAPI *) (LPURL_COMPONENTS,DWORD,LPWSTR,LPDWORD)) GetProcAddress (winhttp, "WinHttpCreateUrl");
funcs.pWinHttpOpen = (HINTERNET (WINAPI *) (LPCWSTR,DWORD,LPCWSTR,LPCWSTR,DWORD)) GetProcAddress (winhttp, "WinHttpOpen");
funcs.pWinHttpOpenRequest = (HINTERNET (WINAPI *) (HINTERNET,LPCWSTR,LPCWSTR,LPCWSTR,LPCWSTR,LPCWSTR*,DWORD)) GetProcAddress (winhttp, "WinHttpOpenRequest");
funcs.pWinHttpQueryDataAvailable = (BOOL (WINAPI *) (HINTERNET,LPDWORD)) GetProcAddress (winhttp, "WinHttpQueryDataAvailable");
funcs.pWinHttpQueryHeaders = (BOOL (WINAPI *) (HINTERNET,DWORD,LPCWSTR,LPVOID,LPDWORD,LPDWORD)) GetProcAddress (winhttp, "WinHttpQueryHeaders");
funcs.pWinHttpReadData = (BOOL (WINAPI *) (HINTERNET,LPVOID,DWORD,LPDWORD)) GetProcAddress (winhttp, "WinHttpReadData");
funcs.pWinHttpReceiveResponse = (BOOL (WINAPI *) (HINTERNET,LPVOID)) GetProcAddress (winhttp, "WinHttpReceiveResponse");
funcs.pWinHttpSendRequest = (BOOL (WINAPI *) (HINTERNET,LPCWSTR,DWORD,LPVOID,DWORD,DWORD,DWORD_PTR)) GetProcAddress (winhttp, "WinHttpSendRequest");
funcs.pWinHttpWriteData = (BOOL (WINAPI *) (HINTERNET,LPCVOID,DWORD,LPDWORD)) GetProcAddress (winhttp, "WinHttpWriteData");
if (funcs.pWinHttpCloseHandle &&
funcs.pWinHttpCrackUrl &&
funcs.pWinHttpConnect &&
funcs.pWinHttpCreateUrl &&
funcs.pWinHttpOpen &&
funcs.pWinHttpOpenRequest &&
funcs.pWinHttpQueryDataAvailable &&
funcs.pWinHttpQueryHeaders &&
funcs.pWinHttpReadData &&
funcs.pWinHttpReceiveResponse &&
funcs.pWinHttpSendRequest &&
funcs.pWinHttpWriteData)
funcs_found = TRUE;
}
lookup_done = TRUE;
}
#define g_winhttp_vfs_get_type _g_winhttp_vfs_get_type
G_DEFINE_TYPE_WITH_CODE (GWinHttpVfs, g_winhttp_vfs, G_TYPE_VFS,
{
lookup_funcs ();
if (funcs_found)
g_io_extension_point_implement (G_VFS_EXTENSION_POINT_NAME,
g_define_type_id,
"winhttp",
10);
})
static const gchar *winhttp_uri_schemes[] = { "http", "https" };
static void
g_winhttp_vfs_finalize (GObject *object)
{
GWinHttpVfs *vfs;
vfs = G_WINHTTP_VFS (object);
(G_WINHTTP_VFS_GET_CLASS (vfs)->funcs->pWinHttpCloseHandle) (vfs->session);
vfs->session = NULL;
if (vfs->wrapped_vfs)
g_object_unref (vfs->wrapped_vfs);
vfs->wrapped_vfs = NULL;
G_OBJECT_CLASS (g_winhttp_vfs_parent_class)->finalize (object);
}
static void
g_winhttp_vfs_init (GWinHttpVfs *vfs)
{
wchar_t *wagent;
vfs->wrapped_vfs = g_vfs_get_local ();
wagent = g_utf8_to_utf16 (g_get_prgname (), -1, NULL, NULL, NULL);
if (!wagent)
wagent = g_utf8_to_utf16 ("GWinHttpVfs", -1, NULL, NULL, NULL);
vfs->session = (G_WINHTTP_VFS_GET_CLASS (vfs)->funcs->pWinHttpOpen)
(wagent,
WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
WINHTTP_NO_PROXY_NAME,
WINHTTP_NO_PROXY_BYPASS,
0);
g_free (wagent);
}
/**
* g_winhttp_vfs_new:
*
* Returns a new #GVfs handle for a WinHttp vfs.
*
* Returns: a new #GVfs handle.
**/
GVfs *
_g_winhttp_vfs_new (void)
{
return g_object_new (G_TYPE_WINHTTP_VFS, NULL);
}
static GFile *
g_winhttp_vfs_get_file_for_path (GVfs *vfs,
const char *path)
{
return g_vfs_get_file_for_path (G_WINHTTP_VFS (vfs)->wrapped_vfs, path);
}
static GFile *
g_winhttp_vfs_get_file_for_uri (GVfs *vfs,
const char *uri)
{
GWinHttpVfs *winhttp_vfs = G_WINHTTP_VFS (vfs);
int i;
/* If it matches one of "our" schemes, handle it */
for (i = 0; i < G_N_ELEMENTS (winhttp_uri_schemes); i++)
if (g_ascii_strncasecmp (uri, winhttp_uri_schemes[i], strlen (winhttp_uri_schemes[i])) == 0 &&
uri[strlen (winhttp_uri_schemes[i])] == ':')
return _g_winhttp_file_new (winhttp_vfs, uri);
/* For other URIs fallback to the wrapped GVfs */
return g_vfs_parse_name (winhttp_vfs->wrapped_vfs, uri);
}
static const gchar * const *
g_winhttp_vfs_get_supported_uri_schemes (GVfs *vfs)
{
GWinHttpVfs *winhttp_vfs = G_WINHTTP_VFS (vfs);
const gchar * const *wrapped_vfs_uri_schemes = g_vfs_get_supported_uri_schemes (winhttp_vfs->wrapped_vfs);
int i, n;
const gchar **retval;
n = 0;
while (wrapped_vfs_uri_schemes[n] != NULL)
n++;
retval = g_new (const gchar *, n + G_N_ELEMENTS (winhttp_uri_schemes) + 1);
n = 0;
while (wrapped_vfs_uri_schemes[n] != NULL)
{
retval[n] = wrapped_vfs_uri_schemes[n];
n++;
}
for (i = 0; i < G_N_ELEMENTS (winhttp_uri_schemes); i++)
{
retval[n] = winhttp_uri_schemes[i];
n++;
}
retval[n] = NULL;
return retval;
}
static GFile *
g_winhttp_vfs_parse_name (GVfs *vfs,
const char *parse_name)
{
GWinHttpVfs *winhttp_vfs = G_WINHTTP_VFS (vfs);
g_return_val_if_fail (G_IS_VFS (vfs), NULL);
g_return_val_if_fail (parse_name != NULL, NULL);
/* For plain file paths fallback to the wrapped GVfs */
if (g_path_is_absolute (parse_name))
return g_vfs_parse_name (winhttp_vfs->wrapped_vfs, parse_name);
/* Otherwise assume it is an URI, so pass on to
* g_winhttp_vfs_get_file_for_uri().
*/
return g_winhttp_vfs_get_file_for_uri (vfs, parse_name);
}
static gboolean
g_winhttp_vfs_is_active (GVfs *vfs)
{
return TRUE;
}
static void
g_winhttp_vfs_class_init (GWinHttpVfsClass *class)
{
GObjectClass *object_class;
GVfsClass *vfs_class;
object_class = (GObjectClass *) class;
object_class->finalize = g_winhttp_vfs_finalize;
vfs_class = G_VFS_CLASS (class);
vfs_class->is_active = g_winhttp_vfs_is_active;
vfs_class->get_file_for_path = g_winhttp_vfs_get_file_for_path;
vfs_class->get_file_for_uri = g_winhttp_vfs_get_file_for_uri;
vfs_class->get_supported_uri_schemes = g_winhttp_vfs_get_supported_uri_schemes;
vfs_class->parse_name = g_winhttp_vfs_parse_name;
lookup_funcs ();
if (funcs_found)
class->funcs = &funcs;
else
class->funcs = NULL;
}
char *
_g_winhttp_error_message (DWORD error_code)
{
/* The FormatMessage() API that g_win32_error_message() uses doesn't
* seem to know about WinHttp errors, unfortunately.
*/
if (error_code >= WINHTTP_ERROR_BASE && error_code < WINHTTP_ERROR_BASE + 200)
{
switch (error_code)
{
/* FIXME: Use meaningful error messages */
#define CASE(x) case ERROR_WINHTTP_##x: return g_strdup ("WinHttp error: " #x);
CASE (AUTO_PROXY_SERVICE_ERROR);
CASE (AUTODETECTION_FAILED);
CASE (BAD_AUTO_PROXY_SCRIPT);
CASE (CANNOT_CALL_AFTER_OPEN);
CASE (CANNOT_CALL_AFTER_SEND);
CASE (CANNOT_CALL_BEFORE_OPEN);
CASE (CANNOT_CALL_BEFORE_SEND);
CASE (CANNOT_CONNECT);
CASE (CHUNKED_ENCODING_HEADER_SIZE_OVERFLOW);
CASE (CLIENT_AUTH_CERT_NEEDED);
CASE (CONNECTION_ERROR);
CASE (HEADER_ALREADY_EXISTS);
CASE (HEADER_COUNT_EXCEEDED);
CASE (HEADER_NOT_FOUND);
CASE (HEADER_SIZE_OVERFLOW);
CASE (INCORRECT_HANDLE_STATE);
CASE (INCORRECT_HANDLE_TYPE);
CASE (INTERNAL_ERROR);
CASE (INVALID_OPTION);
CASE (INVALID_QUERY_REQUEST);
CASE (INVALID_SERVER_RESPONSE);
CASE (INVALID_URL);
CASE (LOGIN_FAILURE);
CASE (NAME_NOT_RESOLVED);
CASE (NOT_INITIALIZED);
CASE (OPERATION_CANCELLED);
CASE (OPTION_NOT_SETTABLE);
CASE (OUT_OF_HANDLES);
CASE (REDIRECT_FAILED);
CASE (RESEND_REQUEST);
CASE (RESPONSE_DRAIN_OVERFLOW);
CASE (SECURE_CERT_CN_INVALID);
CASE (SECURE_CERT_DATE_INVALID);
CASE (SECURE_CERT_REV_FAILED);
CASE (SECURE_CERT_REVOKED);
CASE (SECURE_CERT_WRONG_USAGE);
CASE (SECURE_CHANNEL_ERROR);
CASE (SECURE_FAILURE);
CASE (SECURE_INVALID_CA);
CASE (SECURE_INVALID_CERT);
CASE (SHUTDOWN);
CASE (TIMEOUT);
CASE (UNABLE_TO_DOWNLOAD_SCRIPT);
CASE (UNRECOGNIZED_SCHEME);
#undef CASE
default:
return g_strdup_printf ("WinHttp error %ld", error_code);
}
}
else
return g_win32_error_message (error_code);
}
void
_g_winhttp_set_error (GError **error,
DWORD error_code,
const char *what)
{
char *emsg = _g_winhttp_error_message (error_code);
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"%s failed: %s", what, emsg);
g_free (emsg);
}
gboolean
_g_winhttp_response (GWinHttpVfs *vfs,
HINTERNET request,
GError **error,
const char *what)
{
wchar_t *status_code;
DWORD status_code_len;
if (!G_WINHTTP_VFS_GET_CLASS (vfs)->funcs->pWinHttpReceiveResponse (request, NULL))
{
_g_winhttp_set_error (error, GetLastError (), what);
return FALSE;
}
status_code_len = 0;
if (!G_WINHTTP_VFS_GET_CLASS (vfs)->funcs->pWinHttpQueryHeaders
(request,
WINHTTP_QUERY_STATUS_CODE,
NULL,
NULL,
&status_code_len,
NULL) &&
GetLastError () != ERROR_INSUFFICIENT_BUFFER)
{
_g_winhttp_set_error (error, GetLastError (), what);
return FALSE;
}
status_code = g_malloc (status_code_len);
if (!G_WINHTTP_VFS_GET_CLASS (vfs)->funcs->pWinHttpQueryHeaders
(request,
WINHTTP_QUERY_STATUS_CODE,
NULL,
status_code,
&status_code_len,
NULL))
{
_g_winhttp_set_error (error, GetLastError (), what);
g_free (status_code);
return FALSE;
}
if (status_code[0] != L'2')
{
wchar_t *status_text = NULL;
DWORD status_text_len;
if (!G_WINHTTP_VFS_GET_CLASS (vfs)->funcs->pWinHttpQueryHeaders
(request,
WINHTTP_QUERY_STATUS_TEXT,
NULL,
NULL,
&status_text_len,
NULL) &&
GetLastError () == ERROR_INSUFFICIENT_BUFFER)
{
status_text = g_malloc (status_text_len);
if (!G_WINHTTP_VFS_GET_CLASS (vfs)->funcs->pWinHttpQueryHeaders
(request,
WINHTTP_QUERY_STATUS_TEXT,
NULL,
status_text,
&status_text_len,
NULL))
{
g_free (status_text);
status_text = NULL;
}
}
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"%s failed: %S %S",
what, status_code, status_text ? status_text : L"");
g_free (status_code);
g_free (status_text);
return FALSE;
}
g_free (status_code);
return TRUE;
}
gboolean
_g_winhttp_query_header (GWinHttpVfs *vfs,
HINTERNET request,
const char *request_description,
DWORD which_header,
wchar_t **header,
GError **error)
{
DWORD header_len = 0;
if (!G_WINHTTP_VFS_GET_CLASS (vfs)->funcs->pWinHttpQueryHeaders
(request,
which_header,
NULL,
NULL,
&header_len,
NULL) &&
GetLastError () != ERROR_INSUFFICIENT_BUFFER)
{
_g_winhttp_set_error (error, GetLastError (), request_description);
return FALSE;
}
*header = g_malloc (header_len);
if (!G_WINHTTP_VFS_GET_CLASS (vfs)->funcs->pWinHttpQueryHeaders
(request,
which_header,
NULL,
*header,
&header_len,
NULL))
{
_g_winhttp_set_error (error, GetLastError (), request_description);
g_free (*header);
*header = NULL;
return FALSE;
}
return TRUE;
}