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

}