dll/win32/urlmon/protocol.c

   1 /*
   2  * Copyright 2007 Misha Koshelev
   3  * Copyright 2009 Jacek Caban for CodeWeavers
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include "urlmon_main.h"
  21
  22 #include "wine/debug.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(urlmon);
  25
  26 /* Flags are needed for, among other things, return HRESULTs from the Read function
  27  * to conform to native. For example, Read returns:
  28  *
  29  * 1. E_PENDING if called before the request has completed,
  30  *        (flags = 0)
  31  * 2. S_FALSE after all data has been read and S_OK has been reported,
  32  *        (flags = FLAG_REQUEST_COMPLETE | FLAG_ALL_DATA_READ | FLAG_RESULT_REPORTED)
  33  * 3. INET_E_DATA_NOT_AVAILABLE if InternetQueryDataAvailable fails. The first time
  34  *    this occurs, INET_E_DATA_NOT_AVAILABLE will also be reported to the sink,
  35  *        (flags = FLAG_REQUEST_COMPLETE)
  36  *    but upon subsequent calls to Read no reporting will take place, yet
  37  *    InternetQueryDataAvailable will still be called, and, on failure,
  38  *    INET_E_DATA_NOT_AVAILABLE will still be returned.
  39  *        (flags = FLAG_REQUEST_COMPLETE | FLAG_RESULT_REPORTED)
  40  *
  41  * FLAG_FIRST_DATA_REPORTED and FLAG_LAST_DATA_REPORTED are needed for proper
  42  * ReportData reporting. For example, if OnResponse returns S_OK, Continue will
  43  * report BSCF_FIRSTDATANOTIFICATION, and when all data has been read Read will
  44  * report BSCF_INTERMEDIATEDATANOTIFICATION|BSCF_LASTDATANOTIFICATION. However,
  45  * if OnResponse does not return S_OK, Continue will not report data, and Read
  46  * will report BSCF_FIRSTDATANOTIFICATION|BSCF_LASTDATANOTIFICATION when all
  47  * data has been read.
  48  */
  49 #define FLAG_REQUEST_COMPLETE         0x0001
  50 #define FLAG_FIRST_CONTINUE_COMPLETE  0x0002
  51 #define FLAG_FIRST_DATA_REPORTED      0x0004
  52 #define FLAG_ALL_DATA_READ            0x0008
  53 #define FLAG_LAST_DATA_REPORTED       0x0010
  54 #define FLAG_RESULT_REPORTED          0x0020
  55
  56 static inline HRESULT report_progress(Protocol *protocol, ULONG status_code, LPCWSTR status_text)
  57 {
  58     return IInternetProtocolSink_ReportProgress(protocol->protocol_sink, status_code, status_text);
  59 }
  60
  61 static inline HRESULT report_result(Protocol *protocol, HRESULT hres)
  62 {
  63     if (!(protocol->flags & FLAG_RESULT_REPORTED) && protocol->protocol_sink) {
  64         protocol->flags |= FLAG_RESULT_REPORTED;
  65         IInternetProtocolSink_ReportResult(protocol->protocol_sink, hres, 0, NULL);
  66     }
  67
  68     return hres;
  69 }
  70
  71 static void report_data(Protocol *protocol)
  72 {
  73     DWORD bscf;
  74
  75     if((protocol->flags & FLAG_LAST_DATA_REPORTED) || !protocol->protocol_sink)
  76         return;
  77
  78     if(protocol->flags & FLAG_FIRST_DATA_REPORTED) {
  79         bscf = BSCF_INTERMEDIATEDATANOTIFICATION;
  80     }else {
  81         protocol->flags |= FLAG_FIRST_DATA_REPORTED;
  82         bscf = BSCF_FIRSTDATANOTIFICATION;
  83     }
  84
  85     if(protocol->flags & FLAG_ALL_DATA_READ && !(protocol->flags & FLAG_LAST_DATA_REPORTED)) {
  86         protocol->flags |= FLAG_LAST_DATA_REPORTED;
  87         bscf |= BSCF_LASTDATANOTIFICATION;
  88     }
  89
  90     IInternetProtocolSink_ReportData(protocol->protocol_sink, bscf,
  91             protocol->current_position+protocol->available_bytes,
  92             protocol->content_length);
  93 }
  94
  95 static void all_data_read(Protocol *protocol)
  96 {
  97     protocol->flags |= FLAG_ALL_DATA_READ;
  98
  99     report_data(protocol);
 100     report_result(protocol, S_OK);
 101 }
 102
 103 static void request_complete(Protocol *protocol, INTERNET_ASYNC_RESULT *ar)
 104 {
 105     PROTOCOLDATA data;
 106
 107     if(!ar->dwResult) {
 108         WARN("request failed: %d\n", ar->dwError);
 109         return;
 110     }
 111
 112     protocol->flags |= FLAG_REQUEST_COMPLETE;
 113
 114     if(!protocol->request) {
 115         TRACE("setting request handle %p\n", (HINTERNET)ar->dwResult);
 116         protocol->request = (HINTERNET)ar->dwResult;
 117     }
 118
 119     /* PROTOCOLDATA same as native */
 120     memset(&data, 0, sizeof(data));
 121     data.dwState = 0xf1000000;
 122     if(protocol->flags & FLAG_FIRST_CONTINUE_COMPLETE)
 123         data.pData = (LPVOID)BINDSTATUS_ENDDOWNLOADCOMPONENTS;
 124     else
 125         data.pData = (LPVOID)BINDSTATUS_DOWNLOADINGDATA;
 126
 127     if (protocol->bindf & BINDF_FROMURLMON)
 128         IInternetProtocolSink_Switch(protocol->protocol_sink, &data);
 129     else
 130         protocol_continue(protocol, &data);
 131 }
 132
 133 static void WINAPI internet_status_callback(HINTERNET internet, DWORD_PTR context,
 134         DWORD internet_status, LPVOID status_info, DWORD status_info_len)
 135 {
 136     Protocol *protocol = (Protocol*)context;
 137
 138     switch(internet_status) {
 139     case INTERNET_STATUS_RESOLVING_NAME:
 140         TRACE("%p INTERNET_STATUS_RESOLVING_NAME\n", protocol);
 141         report_progress(protocol, BINDSTATUS_FINDINGRESOURCE, (LPWSTR)status_info);
 142         break;
 143
 144     case INTERNET_STATUS_CONNECTING_TO_SERVER:
 145         TRACE("%p INTERNET_STATUS_CONNECTING_TO_SERVER\n", protocol);
 146         report_progress(protocol, BINDSTATUS_CONNECTING, (LPWSTR)status_info);
 147         break;
 148
 149     case INTERNET_STATUS_SENDING_REQUEST:
 150         TRACE("%p INTERNET_STATUS_SENDING_REQUEST\n", protocol);
 151         report_progress(protocol, BINDSTATUS_SENDINGREQUEST, (LPWSTR)status_info);
 152         break;
 153
 154     case INTERNET_STATUS_REQUEST_COMPLETE:
 155         request_complete(protocol, status_info);
 156         break;
 157
 158     case INTERNET_STATUS_HANDLE_CREATED:
 159         TRACE("%p INTERNET_STATUS_HANDLE_CREATED\n", protocol);
 160         IInternetProtocol_AddRef(protocol->protocol);
 161         break;
 162
 163     case INTERNET_STATUS_HANDLE_CLOSING:
 164         TRACE("%p INTERNET_STATUS_HANDLE_CLOSING\n", protocol);
 165
 166         if(*(HINTERNET *)status_info == protocol->request) {
 167             protocol->request = NULL;
 168             if(protocol->protocol_sink) {
 169                 IInternetProtocolSink_Release(protocol->protocol_sink);
 170                 protocol->protocol_sink = NULL;
 171             }
 172
 173             if(protocol->bind_info.cbSize) {
 174                 ReleaseBindInfo(&protocol->bind_info);
 175                 memset(&protocol->bind_info, 0, sizeof(protocol->bind_info));
 176             }
 177         }else if(*(HINTERNET *)status_info == protocol->connection) {
 178             protocol->connection = NULL;
 179         }
 180
 181         IInternetProtocol_Release(protocol->protocol);
 182         break;
 183
 184     default:
 185         WARN("Unhandled Internet status callback %d\n", internet_status);
 186     }
 187 }
 188
 189 static HINTERNET create_internet_session(IInternetBindInfo *bind_info)
 190 {
 191     LPWSTR global_user_agent = NULL;
 192     LPOLESTR user_agent = NULL;
 193     ULONG size = 0;
 194     HINTERNET ret;
 195     HRESULT hres;
 196
 197     hres = IInternetBindInfo_GetBindString(bind_info, BINDSTRING_USER_AGENT, &user_agent, 1, &size);
 198     if(hres != S_OK || !size)
 199         global_user_agent = get_useragent();
 200
 201     ret = InternetOpenW(user_agent ? user_agent : global_user_agent, 0, NULL, NULL, INTERNET_FLAG_ASYNC);
 202     heap_free(global_user_agent);
 203     CoTaskMemFree(user_agent);
 204     if(!ret) {
 205         WARN("InternetOpen failed: %d\n", GetLastError());
 206         return NULL;
 207     }
 208
 209     InternetSetStatusCallbackW(ret, internet_status_callback);
 210     return ret;
 211 }
 212
 213 static HINTERNET internet_session;
 214
 215 HINTERNET get_internet_session(IInternetBindInfo *bind_info)
 216 {
 217     HINTERNET new_session;
 218
 219     if(internet_session)
 220         return internet_session;
 221
 222     if(!bind_info)
 223         return NULL;
 224
 225     new_session = create_internet_session(bind_info);
 226     if(new_session && InterlockedCompareExchangePointer((void**)&internet_session, new_session, NULL))
 227         InternetCloseHandle(new_session);
 228
 229     return internet_session;
 230 }
 231
 232 HRESULT protocol_start(Protocol *protocol, IInternetProtocol *prot, LPCWSTR url,
 233         IInternetProtocolSink *protocol_sink, IInternetBindInfo *bind_info)
 234 {
 235     DWORD request_flags;
 236     HRESULT hres;
 237
 238     protocol->protocol = prot;
 239
 240     IInternetProtocolSink_AddRef(protocol_sink);
 241     protocol->protocol_sink = protocol_sink;
 242
 243     memset(&protocol->bind_info, 0, sizeof(protocol->bind_info));
 244     protocol->bind_info.cbSize = sizeof(BINDINFO);
 245     hres = IInternetBindInfo_GetBindInfo(bind_info, &protocol->bindf, &protocol->bind_info);
 246     if(hres != S_OK) {
 247         WARN("GetBindInfo failed: %08x\n", hres);
 248         return report_result(protocol, hres);
 249     }
 250
 251     if(!(protocol->bindf & BINDF_FROMURLMON))
 252         report_progress(protocol, BINDSTATUS_DIRECTBIND, NULL);
 253
 254     if(!get_internet_session(bind_info))
 255         return report_result(protocol, INET_E_NO_SESSION);
 256
 257     request_flags = INTERNET_FLAG_KEEP_CONNECTION;
 258     if(protocol->bindf & BINDF_NOWRITECACHE)
 259         request_flags |= INTERNET_FLAG_NO_CACHE_WRITE;
 260     if(protocol->bindf & BINDF_NEEDFILE)
 261         request_flags |= INTERNET_FLAG_NEED_FILE;
 262
 263     hres = protocol->vtbl->open_request(protocol, url, request_flags, internet_session, bind_info);
 264     if(FAILED(hres)) {
 265         protocol_close_connection(protocol);
 266         return report_result(protocol, hres);
 267     }
 268
 269     return S_OK;
 270 }
 271
 272 HRESULT protocol_continue(Protocol *protocol, PROTOCOLDATA *data)
 273 {
 274     HRESULT hres;
 275
 276     if (!data) {
 277         WARN("Expected pProtocolData to be non-NULL\n");
 278         return S_OK;
 279     }
 280
 281     if(!protocol->request) {
 282         WARN("Expected request to be non-NULL\n");
 283         return S_OK;
 284     }
 285
 286     if(!protocol->protocol_sink) {
 287         WARN("Expected IInternetProtocolSink pointer to be non-NULL\n");
 288         return S_OK;
 289     }
 290
 291     if(data->pData == (LPVOID)BINDSTATUS_DOWNLOADINGDATA) {
 292         hres = protocol->vtbl->start_downloading(protocol);
 293         if(FAILED(hres)) {
 294             protocol_close_connection(protocol);
 295             report_result(protocol, hres);
 296             return S_OK;
 297         }
 298
 299         if(protocol->bindf & BINDF_NEEDFILE) {
 300             WCHAR cache_file[MAX_PATH];
 301             DWORD buflen = sizeof(cache_file);
 302
 303             if(InternetQueryOptionW(protocol->request, INTERNET_OPTION_DATAFILE_NAME,
 304                     cache_file, &buflen)) {
 305                 report_progress(protocol, BINDSTATUS_CACHEFILENAMEAVAILABLE, cache_file);
 306             }else {
 307                 FIXME("Could not get cache file\n");
 308             }
 309         }
 310
 311         protocol->flags |= FLAG_FIRST_CONTINUE_COMPLETE;
 312     }
 313
 314     if(data->pData >= (LPVOID)BINDSTATUS_DOWNLOADINGDATA) {
 315         BOOL res;
 316
 317         /* InternetQueryDataAvailable may immediately fork and perform its asynchronous
 318          * read, so clear the flag _before_ calling so it does not incorrectly get cleared
 319          * after the status callback is called */
 320         protocol->flags &= ~FLAG_REQUEST_COMPLETE;
 321         res = InternetQueryDataAvailable(protocol->request, &protocol->available_bytes, 0, 0);
 322         if(res) {
 323             protocol->flags |= FLAG_REQUEST_COMPLETE;
 324             report_data(protocol);
 325         }else if(GetLastError() != ERROR_IO_PENDING) {
 326             protocol->flags |= FLAG_REQUEST_COMPLETE;
 327             WARN("InternetQueryDataAvailable failed: %d\n", GetLastError());
 328             report_result(protocol, INET_E_DATA_NOT_AVAILABLE);
 329         }
 330     }
 331
 332     return S_OK;
 333 }
 334
 335 HRESULT protocol_read(Protocol *protocol, void *buf, ULONG size, ULONG *read_ret)
 336 {
 337     ULONG read = 0;
 338     BOOL res;
 339     HRESULT hres = S_FALSE;
 340
 341     if(protocol->flags & FLAG_ALL_DATA_READ) {
 342         *read_ret = 0;
 343         return S_FALSE;
 344     }
 345
 346     if(!(protocol->flags & FLAG_REQUEST_COMPLETE)) {
 347         *read_ret = 0;
 348         return E_PENDING;
 349     }
 350
 351     while(read < size) {
 352         if(protocol->available_bytes) {
 353             ULONG len;
 354
 355             res = InternetReadFile(protocol->request, ((BYTE *)buf)+read,
 356                     protocol->available_bytes > size-read ? size-read : protocol->available_bytes, &len);
 357             if(!res) {
 358                 WARN("InternetReadFile failed: %d\n", GetLastError());
 359                 hres = INET_E_DOWNLOAD_FAILURE;
 360                 report_result(protocol, hres);
 361                 break;
 362             }
 363
 364             if(!len) {
 365                 all_data_read(protocol);
 366                 break;
 367             }
 368
 369             read += len;
 370             protocol->current_position += len;
 371             protocol->available_bytes -= len;
 372         }else {
 373             /* InternetQueryDataAvailable may immediately fork and perform its asynchronous
 374              * read, so clear the flag _before_ calling so it does not incorrectly get cleared
 375              * after the status callback is called */
 376             protocol->flags &= ~FLAG_REQUEST_COMPLETE;
 377             res = InternetQueryDataAvailable(protocol->request, &protocol->available_bytes, 0, 0);
 378             if(!res) {
 379                 if (GetLastError() == ERROR_IO_PENDING) {
 380                     hres = E_PENDING;
 381                 }else {
 382                     WARN("InternetQueryDataAvailable failed: %d\n", GetLastError());
 383                     hres = INET_E_DATA_NOT_AVAILABLE;
 384                     report_result(protocol, hres);
 385                 }
 386                 break;
 387             }
 388
 389             if(!protocol->available_bytes) {
 390                 all_data_read(protocol);
 391                 break;
 392             }
 393         }
 394     }
 395
 396     *read_ret = read;
 397
 398     if (hres != E_PENDING)
 399         protocol->flags |= FLAG_REQUEST_COMPLETE;
 400     if(FAILED(hres))
 401         return hres;
 402
 403     return read ? S_OK : S_FALSE;
 404 }
 405
 406 HRESULT protocol_lock_request(Protocol *protocol)
 407 {
 408     if (!InternetLockRequestFile(protocol->request, &protocol->lock))
 409         WARN("InternetLockRequest failed: %d\n", GetLastError());
 410
 411     return S_OK;
 412 }
 413
 414 HRESULT protocol_unlock_request(Protocol *protocol)
 415 {
 416     if(!protocol->lock)
 417         return S_OK;
 418
 419     if(!InternetUnlockRequestFile(protocol->lock))
 420         WARN("InternetUnlockRequest failed: %d\n", GetLastError());
 421     protocol->lock = 0;
 422
 423     return S_OK;
 424 }
 425
 426 void protocol_close_connection(Protocol *protocol)
 427 {
 428     protocol->vtbl->close_connection(protocol);
 429
 430     if(protocol->request)
 431         InternetCloseHandle(protocol->request);
 432
 433     if(protocol->connection)
 434         InternetCloseHandle(protocol->connection);
 435
 436     protocol->flags = 0;
 437 }