gio/win32/gwinhttpvfs.c

   1 /* GIO - GLib Input, Output and Streaming Library
   2  *
   3  * Copyright (C) 2006-2007 Red Hat, Inc.
   4  * Copyright (C) 2008 Novell, Inc.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General
  17  * Public License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  *
  21  * Author: Alexander Larsson <alexl@redhat.com>
  22  * Author: Tor Lillqvist <tml@novell.com>
  23  */
  24
  25 #include "config.h"
  26
  27 #include <wchar.h>
  28
  29 #include "gioerror.h"
  30 #include "giomodule.h"
  31 #include "gvfs.h"
  32
  33 #include "gwinhttpfile.h"
  34 #include "gwinhttpvfs.h"
  35
  36 #include "gioalias.h"
  37
  38 static gboolean lookup_done = FALSE;
  39 static gboolean funcs_found = FALSE;
  40 static GWinHttpDllFuncs funcs;
  41
  42 static void
  43 lookup_funcs (void)
  44 {
  45   HMODULE winhttp;
  46
  47   if (lookup_done)
  48     return;
  49
  50   winhttp = LoadLibrary ("winhttp.dll");
  51   if (winhttp != NULL)
  52     {
  53       funcs.pWinHttpCloseHandle = (BOOL (WINAPI *) (HINTERNET)) GetProcAddress (winhttp, "WinHttpCloseHandle");
  54       funcs.pWinHttpCrackUrl = (BOOL (WINAPI *) (LPCWSTR,DWORD,DWORD,LPURL_COMPONENTS)) GetProcAddress (winhttp, "WinHttpCrackUrl");
  55       funcs.pWinHttpConnect = (HINTERNET (WINAPI *) (HINTERNET,LPCWSTR,INTERNET_PORT,DWORD)) GetProcAddress (winhttp, "WinHttpConnect");
  56       funcs.pWinHttpCreateUrl = (BOOL (WINAPI *) (LPURL_COMPONENTS,DWORD,LPWSTR,LPDWORD)) GetProcAddress (winhttp, "WinHttpCreateUrl");
  57       funcs.pWinHttpOpen = (HINTERNET (WINAPI *) (LPCWSTR,DWORD,LPCWSTR,LPCWSTR,DWORD)) GetProcAddress (winhttp, "WinHttpOpen");
  58       funcs.pWinHttpOpenRequest = (HINTERNET (WINAPI *) (HINTERNET,LPCWSTR,LPCWSTR,LPCWSTR,LPCWSTR,LPCWSTR*,DWORD)) GetProcAddress (winhttp, "WinHttpOpenRequest");
  59       funcs.pWinHttpQueryDataAvailable = (BOOL (WINAPI *) (HINTERNET,LPDWORD)) GetProcAddress (winhttp, "WinHttpQueryDataAvailable");
  60       funcs.pWinHttpQueryHeaders = (BOOL (WINAPI *) (HINTERNET,DWORD,LPCWSTR,LPVOID,LPDWORD,LPDWORD)) GetProcAddress (winhttp, "WinHttpQueryHeaders");
  61       funcs.pWinHttpReadData = (BOOL (WINAPI *) (HINTERNET,LPVOID,DWORD,LPDWORD)) GetProcAddress (winhttp, "WinHttpReadData");
  62       funcs.pWinHttpReceiveResponse = (BOOL (WINAPI *) (HINTERNET,LPVOID)) GetProcAddress (winhttp, "WinHttpReceiveResponse");
  63       funcs.pWinHttpSendRequest = (BOOL (WINAPI *) (HINTERNET,LPCWSTR,DWORD,LPVOID,DWORD,DWORD,DWORD_PTR)) GetProcAddress (winhttp, "WinHttpSendRequest");
  64       funcs.pWinHttpWriteData = (BOOL (WINAPI *) (HINTERNET,LPCVOID,DWORD,LPDWORD)) GetProcAddress (winhttp, "WinHttpWriteData");
  65
  66       if (funcs.pWinHttpCloseHandle &&
  67           funcs.pWinHttpCrackUrl &&
  68           funcs.pWinHttpConnect &&
  69           funcs.pWinHttpCreateUrl &&
  70           funcs.pWinHttpOpen &&
  71           funcs.pWinHttpOpenRequest &&
  72           funcs.pWinHttpQueryDataAvailable &&
  73           funcs.pWinHttpQueryHeaders &&
  74           funcs.pWinHttpReadData &&
  75           funcs.pWinHttpReceiveResponse &&
  76           funcs.pWinHttpSendRequest &&
  77           funcs.pWinHttpWriteData)
  78         funcs_found = TRUE;
  79     }
  80   lookup_done = TRUE;
  81 }
  82
  83 #define g_winhttp_vfs_get_type _g_winhttp_vfs_get_type
  84 G_DEFINE_TYPE_WITH_CODE (GWinHttpVfs, g_winhttp_vfs, G_TYPE_VFS,
  85                          {
  86                            lookup_funcs ();
  87                            if (funcs_found)
  88                              g_io_extension_point_implement (G_VFS_EXTENSION_POINT_NAME,
  89                                                              g_define_type_id,
  90                                                              "winhttp",
  91                                                              10);
  92                          })
  93
  94 static const gchar *winhttp_uri_schemes[] = { "http", "https" };
  95
  96 static void
  97 g_winhttp_vfs_finalize (GObject *object)
  98 {
  99   GWinHttpVfs *vfs;
 100
 101   vfs = G_WINHTTP_VFS (object);
 102
 103   (G_WINHTTP_VFS_GET_CLASS (vfs)->funcs->pWinHttpCloseHandle) (vfs->session);
 104   vfs->session = NULL;
 105
 106   if (vfs->wrapped_vfs)
 107     g_object_unref (vfs->wrapped_vfs);
 108   vfs->wrapped_vfs = NULL;
 109
 110   G_OBJECT_CLASS (g_winhttp_vfs_parent_class)->finalize (object);
 111 }
 112
 113 static void
 114 g_winhttp_vfs_init (GWinHttpVfs *vfs)
 115 {
 116   wchar_t *wagent;
 117
 118   vfs->wrapped_vfs = g_vfs_get_local ();
 119
 120   wagent = g_utf8_to_utf16 (g_get_prgname (), -1, NULL, NULL, NULL);
 121
 122   if (!wagent)
 123     wagent = g_utf8_to_utf16 ("GWinHttpVfs", -1, NULL, NULL, NULL);
 124
 125   vfs->session = (G_WINHTTP_VFS_GET_CLASS (vfs)->funcs->pWinHttpOpen)
 126     (wagent,
 127      WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
 128      WINHTTP_NO_PROXY_NAME,
 129      WINHTTP_NO_PROXY_BYPASS,
 130      0);
 131 }
 132
 133 /*
 134  * g_winhttp_vfs_new:
 135  *
 136  * Returns a new #GVfs handle for a WinHttp vfs.
 137  *
 138  * Returns: a new #GVfs handle.
 139  **/
 140 GVfs *
 141 _g_winhttp_vfs_new (void)
 142 {
 143   return g_object_new (G_TYPE_WINHTTP_VFS, NULL);
 144 }
 145
 146 static GFile *
 147 g_winhttp_vfs_get_file_for_path (GVfs       *vfs,
 148                                  const char *path)
 149 {
 150   return g_vfs_get_file_for_path (G_WINHTTP_VFS (vfs)->wrapped_vfs, path);
 151 }
 152
 153 static GFile *
 154 g_winhttp_vfs_get_file_for_uri (GVfs       *vfs,
 155                                 const char *uri)
 156 {
 157   GWinHttpVfs *winhttp_vfs = G_WINHTTP_VFS (vfs);
 158   int i;
 159
 160   /* If it matches one of "our" schemes, handle it */
 161   for (i = 0; i < G_N_ELEMENTS (winhttp_uri_schemes); i++)
 162     if (g_ascii_strncasecmp (uri, winhttp_uri_schemes[i], strlen (winhttp_uri_schemes[i])) == 0 &&
 163         uri[strlen (winhttp_uri_schemes[i])] == ':')
 164       return _g_winhttp_file_new (winhttp_vfs, uri);
 165
 166   /* For other URIs fallback to the wrapped GVfs */
 167   return g_vfs_parse_name (winhttp_vfs->wrapped_vfs, uri);
 168 }
 169
 170 static const gchar * const *
 171 g_winhttp_vfs_get_supported_uri_schemes (GVfs *vfs)
 172 {
 173   GWinHttpVfs *winhttp_vfs = G_WINHTTP_VFS (vfs);
 174   const gchar * const *wrapped_vfs_uri_schemes = g_vfs_get_supported_uri_schemes (winhttp_vfs->wrapped_vfs);
 175   int i, n;
 176   const gchar **retval;
 177
 178   n = 0;
 179   while (wrapped_vfs_uri_schemes[n] != NULL)
 180     n++;
 181
 182   retval = g_new (const gchar *, n + G_N_ELEMENTS (winhttp_uri_schemes) + 1);
 183   n = 0;
 184   while (wrapped_vfs_uri_schemes[n] != NULL)
 185     {
 186       retval[n] = wrapped_vfs_uri_schemes[n];
 187       n++;
 188     }
 189
 190   for (i = 0; i < G_N_ELEMENTS (winhttp_uri_schemes); i++)
 191     {
 192       retval[n] = winhttp_uri_schemes[i];
 193       n++;
 194     }
 195
 196   retval[n] = NULL;
 197
 198   return retval;
 199 }
 200
 201 static GFile *
 202 g_winhttp_vfs_parse_name (GVfs       *vfs,
 203                           const char *parse_name)
 204 {
 205   GWinHttpVfs *winhttp_vfs = G_WINHTTP_VFS (vfs);
 206
 207   g_return_val_if_fail (G_IS_VFS (vfs), NULL);
 208   g_return_val_if_fail (parse_name != NULL, NULL);
 209
 210   /* For plain file paths fallback to the wrapped GVfs */
 211   if (g_path_is_absolute (parse_name))
 212     return g_vfs_parse_name (winhttp_vfs->wrapped_vfs, parse_name);
 213
 214   /* Otherwise assume it is an URI, so pass on to
 215    * g_winhttp_vfs_get_file_for_uri().
 216    */
 217   return g_winhttp_vfs_get_file_for_uri (vfs, parse_name);
 218 }
 219
 220 static gboolean
 221 g_winhttp_vfs_is_active (GVfs *vfs)
 222 {
 223   return TRUE;
 224 }
 225
 226 static void
 227 g_winhttp_vfs_class_init (GWinHttpVfsClass *class)
 228 {
 229   GObjectClass *object_class;
 230   GVfsClass *vfs_class;
 231
 232   object_class = (GObjectClass *) class;
 233
 234   object_class->finalize = g_winhttp_vfs_finalize;
 235
 236   vfs_class = G_VFS_CLASS (class);
 237
 238   vfs_class->is_active = g_winhttp_vfs_is_active;
 239   vfs_class->get_file_for_path = g_winhttp_vfs_get_file_for_path;
 240   vfs_class->get_file_for_uri = g_winhttp_vfs_get_file_for_uri;
 241   vfs_class->get_supported_uri_schemes = g_winhttp_vfs_get_supported_uri_schemes;
 242   vfs_class->parse_name = g_winhttp_vfs_parse_name;
 243
 244   lookup_funcs ();
 245   if (funcs_found)
 246     class->funcs = &funcs;
 247   else
 248     class->funcs = NULL;
 249 }
 250
 251 char *
 252 _g_winhttp_error_message (DWORD error_code)
 253 {
 254   /* The FormatMessage() API that g_win32_error_message() uses doesn't
 255    * seem to know about WinHttp errors, unfortunately.
 256    */
 257   if (error_code >= WINHTTP_ERROR_BASE && error_code < WINHTTP_ERROR_BASE + 200)
 258     {
 259       switch (error_code)
 260         {
 261           /* FIXME: Use meaningful error messages */
 262 #define CASE(x) case ERROR_WINHTTP_##x: return g_strdup ("WinHttp error: " #x);
 263           CASE (AUTO_PROXY_SERVICE_ERROR);
 264           CASE (AUTODETECTION_FAILED);
 265           CASE (BAD_AUTO_PROXY_SCRIPT);
 266           CASE (CANNOT_CALL_AFTER_OPEN);
 267           CASE (CANNOT_CALL_AFTER_SEND);
 268           CASE (CANNOT_CALL_BEFORE_OPEN);
 269           CASE (CANNOT_CALL_BEFORE_SEND);
 270           CASE (CANNOT_CONNECT);
 271           CASE (CHUNKED_ENCODING_HEADER_SIZE_OVERFLOW);
 272           CASE (CLIENT_AUTH_CERT_NEEDED);
 273           CASE (CONNECTION_ERROR);
 274           CASE (HEADER_ALREADY_EXISTS);
 275           CASE (HEADER_COUNT_EXCEEDED);
 276           CASE (HEADER_NOT_FOUND);
 277           CASE (HEADER_SIZE_OVERFLOW);
 278           CASE (INCORRECT_HANDLE_STATE);
 279           CASE (INCORRECT_HANDLE_TYPE);
 280           CASE (INTERNAL_ERROR);
 281           CASE (INVALID_OPTION);
 282           CASE (INVALID_QUERY_REQUEST);
 283           CASE (INVALID_SERVER_RESPONSE);
 284           CASE (INVALID_URL);
 285           CASE (LOGIN_FAILURE);
 286           CASE (NAME_NOT_RESOLVED);
 287           CASE (NOT_INITIALIZED);
 288           CASE (OPERATION_CANCELLED);
 289           CASE (OPTION_NOT_SETTABLE);
 290           CASE (OUT_OF_HANDLES);
 291           CASE (REDIRECT_FAILED);
 292           CASE (RESEND_REQUEST);
 293           CASE (RESPONSE_DRAIN_OVERFLOW);
 294           CASE (SECURE_CERT_CN_INVALID);
 295           CASE (SECURE_CERT_DATE_INVALID);
 296           CASE (SECURE_CERT_REV_FAILED);
 297           CASE (SECURE_CERT_REVOKED);
 298           CASE (SECURE_CERT_WRONG_USAGE);
 299           CASE (SECURE_CHANNEL_ERROR);
 300           CASE (SECURE_FAILURE);
 301           CASE (SECURE_INVALID_CA);
 302           CASE (SECURE_INVALID_CERT);
 303           CASE (SHUTDOWN);
 304           CASE (TIMEOUT);
 305           CASE (UNABLE_TO_DOWNLOAD_SCRIPT);
 306           CASE (UNRECOGNIZED_SCHEME);
 307           #undef CASE
 308         default:
 309           return g_strdup_printf ("WinHttp error %ld", error_code);
 310         }
 311     }
 312   else
 313     return g_win32_error_message (error_code);
 314 }
 315
 316 void
 317 _g_winhttp_set_error (GError     **error,
 318                       DWORD        error_code,
 319                       const char  *what)
 320 {
 321   char *emsg = _g_winhttp_error_message (error_code);
 322
 323   g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
 324                "%s failed: %s", what, emsg);
 325   g_free (emsg);
 326 }
 327
 328 gboolean
 329 _g_winhttp_response (GWinHttpVfs *vfs,
 330                      HINTERNET    request,
 331                      GError     **error,
 332                      const char  *what)
 333 {
 334   wchar_t *status_code;
 335   DWORD status_code_len;
 336
 337   if (!G_WINHTTP_VFS_GET_CLASS (vfs)->funcs->pWinHttpReceiveResponse (request, NULL))
 338     {
 339       _g_winhttp_set_error (error, GetLastError (), what);
 340
 341       return FALSE;
 342     }
 343
 344   status_code_len = 0;
 345   if (!G_WINHTTP_VFS_GET_CLASS (vfs)->funcs->pWinHttpQueryHeaders
 346       (request,
 347        WINHTTP_QUERY_STATUS_CODE,
 348        NULL,
 349        NULL,
 350        &status_code_len,
 351        NULL) &&
 352       GetLastError () != ERROR_INSUFFICIENT_BUFFER)
 353     {
 354       _g_winhttp_set_error (error, GetLastError (), what);
 355
 356       return FALSE;
 357     }
 358
 359   status_code = g_malloc (status_code_len);
 360
 361   if (!G_WINHTTP_VFS_GET_CLASS (vfs)->funcs->pWinHttpQueryHeaders
 362       (request,
 363        WINHTTP_QUERY_STATUS_CODE,
 364        NULL,
 365        status_code,
 366        &status_code_len,
 367        NULL))
 368     {
 369       _g_winhttp_set_error (error, GetLastError (), what);
 370       g_free (status_code);
 371
 372       return FALSE;
 373     }
 374
 375   if (status_code[0] != L'2')
 376     {
 377       wchar_t *status_text = NULL;
 378       DWORD status_text_len;
 379
 380       if (!G_WINHTTP_VFS_GET_CLASS (vfs)->funcs->pWinHttpQueryHeaders
 381           (request,
 382            WINHTTP_QUERY_STATUS_TEXT,
 383            NULL,
 384            NULL,
 385            &status_text_len,
 386            NULL) &&
 387           GetLastError () == ERROR_INSUFFICIENT_BUFFER)
 388         {
 389           status_text = g_malloc (status_text_len);
 390
 391           if (!G_WINHTTP_VFS_GET_CLASS (vfs)->funcs->pWinHttpQueryHeaders
 392               (request,
 393                WINHTTP_QUERY_STATUS_TEXT,
 394                NULL,
 395                status_text,
 396                &status_text_len,
 397                NULL))
 398             {
 399               g_free (status_text);
 400               status_text = NULL;
 401             }
 402         }
 403
 404       g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
 405                    "%s failed: %S %S",
 406                    what, status_code, status_text ? status_text : L"");
 407       g_free (status_code);
 408       g_free (status_text);
 409
 410       return FALSE;
 411     }
 412
 413   g_free (status_code);
 414
 415   return TRUE;
 416 }
 417
 418 gboolean
 419 _g_winhttp_query_header (GWinHttpVfs *vfs,
 420                          HINTERNET    request,
 421                          const char  *request_description,
 422                          DWORD        which_header,
 423                          wchar_t    **header,
 424                          GError     **error)
 425 {
 426   DWORD header_len = 0;
 427
 428   if (!G_WINHTTP_VFS_GET_CLASS (vfs)->funcs->pWinHttpQueryHeaders
 429       (request,
 430        which_header,
 431        NULL,
 432        NULL,
 433        &header_len,
 434        NULL) &&
 435       GetLastError () != ERROR_INSUFFICIENT_BUFFER)
 436     {
 437       _g_winhttp_set_error (error, GetLastError (), request_description);
 438
 439       return FALSE;
 440     }
 441
 442   *header = g_malloc (header_len);
 443   if (!G_WINHTTP_VFS_GET_CLASS (vfs)->funcs->pWinHttpQueryHeaders
 444       (request,
 445        which_header,
 446        NULL,
 447        *header,
 448        &header_len,
 449        NULL))
 450     {
 451       _g_winhttp_set_error (error, GetLastError (), request_description);
 452       g_free (*header);
 453       *header = NULL;
 454
 455       return FALSE;
 456     }
 457
 458   return TRUE;
 459 }