reactos/dll/win32/ieframe/navigate.c

   1 /*
   2  * Copyright 2006-2007 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "ieframe.h"
  20
  21 #include <wininet.h>
  22
  23 static const WCHAR emptyW[] = {0};
  24
  25 typedef struct {
  26     IBindStatusCallback  IBindStatusCallback_iface;
  27     IHttpNegotiate       IHttpNegotiate_iface;
  28     IHttpSecurity        IHttpSecurity_iface;
  29
  30     LONG ref;
  31
  32     DocHost *doc_host;
  33     IBinding *binding;
  34
  35     BSTR url;
  36     HGLOBAL post_data;
  37     BSTR headers;
  38     ULONG post_data_len;
  39 } BindStatusCallback;
  40
  41 static void dump_BINDINFO(BINDINFO *bi)
  42 {
  43     static const char * const BINDINFOF_str[] = {
  44         "#0",
  45         "BINDINFOF_URLENCODESTGMEDDATA",
  46         "BINDINFOF_URLENCODEDEXTRAINFO"
  47     };
  48
  49     static const char * const BINDVERB_str[] = {
  50         "BINDVERB_GET",
  51         "BINDVERB_POST",
  52         "BINDVERB_PUT",
  53         "BINDVERB_CUSTOM"
  54     };
  55
  56     TRACE("\n"
  57             "BINDINFO = {\n"
  58             "    %d, %s,\n"
  59             "    {%d, %p, %p},\n"
  60             "    %s,\n"
  61             "    %s,\n"
  62             "    %s,\n"
  63             "    %d, %08x, %d, %d\n"
  64             "    {%d %p %x},\n"
  65             "    %s\n"
  66             "    %p, %d\n"
  67             "}\n",
  68
  69             bi->cbSize, debugstr_w(bi->szExtraInfo),
  70             bi->stgmedData.tymed, bi->stgmedData.u.hGlobal, bi->stgmedData.pUnkForRelease,
  71             bi->grfBindInfoF > BINDINFOF_URLENCODEDEXTRAINFO
  72                 ? "unknown" : BINDINFOF_str[bi->grfBindInfoF],
  73             bi->dwBindVerb > BINDVERB_CUSTOM
  74                 ? "unknown" : BINDVERB_str[bi->dwBindVerb],
  75             debugstr_w(bi->szCustomVerb),
  76             bi->cbstgmedData, bi->dwOptions, bi->dwOptionsFlags, bi->dwCodePage,
  77             bi->securityAttributes.nLength,
  78             bi->securityAttributes.lpSecurityDescriptor,
  79             bi->securityAttributes.bInheritHandle,
  80             debugstr_guid(&bi->iid),
  81             bi->pUnk, bi->dwReserved
  82             );
  83 }
  84
  85 static void set_status_text(BindStatusCallback *This, ULONG statuscode, LPCWSTR str)
  86 {
  87     VARIANTARG arg;
  88     DISPPARAMS dispparams = {&arg, NULL, 1, 0};
  89     WCHAR fmt[IDS_STATUSFMT_MAXLEN];
  90     WCHAR buffer[IDS_STATUSFMT_MAXLEN + INTERNET_MAX_URL_LENGTH];
  91
  92     if(!This->doc_host)
  93         return;
  94
  95     TRACE("(%p, %d, %s)\n", This, statuscode, debugstr_w(str));
  96     buffer[0] = 0;
  97     if (statuscode && str && *str) {
  98         fmt[0] = 0;
  99         /* the format string must have one "%s" for the str */
 100         LoadStringW(ieframe_instance, IDS_STATUSFMT_FIRST + statuscode, fmt, IDS_STATUSFMT_MAXLEN);
 101         snprintfW(buffer, sizeof(buffer)/sizeof(WCHAR), fmt, str);
 102     }
 103
 104     V_VT(&arg) = VT_BSTR;
 105     V_BSTR(&arg) = str ? SysAllocString(buffer) : SysAllocString(emptyW);
 106     TRACE("=> %s\n", debugstr_w(V_BSTR(&arg)));
 107
 108     call_sink(This->doc_host->cps.wbe2, DISPID_STATUSTEXTCHANGE, &dispparams);
 109
 110     if(This->doc_host->frame)
 111         IOleInPlaceFrame_SetStatusText(This->doc_host->frame, buffer);
 112
 113     VariantClear(&arg);
 114
 115 }
 116
 117 HRESULT set_dochost_url(DocHost *This, const WCHAR *url)
 118 {
 119     WCHAR *new_url;
 120
 121     if(url) {
 122         new_url = heap_strdupW(url);
 123         if(!new_url)
 124             return E_OUTOFMEMORY;
 125     }else {
 126         new_url = NULL;
 127     }
 128
 129     heap_free(This->url);
 130     This->url = new_url;
 131
 132     This->container_vtbl->set_url(This, This->url);
 133     return S_OK;
 134 }
 135
 136 void notify_download_state(DocHost *dochost, BOOL is_downloading)
 137 {
 138     DISPPARAMS dwl_dp = {NULL};
 139     TRACE("(%x)\n", is_downloading);
 140     call_sink(dochost->cps.wbe2, is_downloading ? DISPID_DOWNLOADBEGIN : DISPID_DOWNLOADCOMPLETE, &dwl_dp);
 141 }
 142
 143 static inline BindStatusCallback *impl_from_IBindStatusCallback(IBindStatusCallback *iface)
 144 {
 145     return CONTAINING_RECORD(iface, BindStatusCallback, IBindStatusCallback_iface);
 146 }
 147
 148 static HRESULT WINAPI BindStatusCallback_QueryInterface(IBindStatusCallback *iface,
 149                                                         REFIID riid, void **ppv)
 150 {
 151     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 152
 153     if(IsEqualGUID(&IID_IUnknown, riid)) {
 154         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 155         *ppv = &This->IBindStatusCallback_iface;
 156     }else if(IsEqualGUID(&IID_IBindStatusCallback, riid)) {
 157         TRACE("(%p)->(IID_IBindStatusCallback %p)\n", This, ppv);
 158         *ppv = &This->IBindStatusCallback_iface;
 159     }else if(IsEqualGUID(&IID_IHttpNegotiate, riid)) {
 160         TRACE("(%p)->(IID_IHttpNegotiate %p)\n", This, ppv);
 161         *ppv = &This->IHttpNegotiate_iface;
 162     }else if(IsEqualGUID(&IID_IWindowForBindingUI, riid)) {
 163         TRACE("(%p)->(IID_IWindowForBindingUI %p)\n", This, ppv);
 164         *ppv = &This->IHttpSecurity_iface;
 165     }else if(IsEqualGUID(&IID_IHttpSecurity, riid)) {
 166         TRACE("(%p)->(IID_IHttpSecurity %p)\n", This, ppv);
 167         *ppv = &This->IHttpSecurity_iface;
 168     }else {
 169         *ppv = NULL;
 170         WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 171         return E_NOINTERFACE;
 172     }
 173
 174     IUnknown_AddRef((IUnknown*)*ppv);
 175     return S_OK;
 176 }
 177
 178 static ULONG WINAPI BindStatusCallback_AddRef(IBindStatusCallback *iface)
 179 {
 180     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 181     LONG ref = InterlockedIncrement(&This->ref);
 182
 183     TRACE("(%p) ref=%d\n", This, ref);
 184
 185     return ref;
 186 }
 187
 188 static ULONG WINAPI BindStatusCallback_Release(IBindStatusCallback *iface)
 189 {
 190     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 191     LONG ref = InterlockedDecrement(&This->ref);
 192
 193     TRACE("(%p) ref=%d\n", This, ref);
 194
 195     if(!ref) {
 196         if(This->doc_host)
 197             IOleClientSite_Release(&This->doc_host->IOleClientSite_iface);
 198         if(This->binding)
 199             IBinding_Release(This->binding);
 200         if(This->post_data)
 201             GlobalFree(This->post_data);
 202         SysFreeString(This->headers);
 203         SysFreeString(This->url);
 204         heap_free(This);
 205     }
 206
 207     return ref;
 208 }
 209
 210 static HRESULT WINAPI BindStatusCallback_OnStartBinding(IBindStatusCallback *iface,
 211        DWORD dwReserved, IBinding *pbind)
 212 {
 213     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 214
 215     TRACE("(%p)->(%d %p)\n", This, dwReserved, pbind);
 216
 217     This->binding = pbind;
 218     IBinding_AddRef(This->binding);
 219
 220     return S_OK;
 221 }
 222
 223 static HRESULT WINAPI BindStatusCallback_GetPriority(IBindStatusCallback *iface,
 224        LONG *pnPriority)
 225 {
 226     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 227     FIXME("(%p)->(%p)\n", This, pnPriority);
 228     return E_NOTIMPL;
 229 }
 230
 231 static HRESULT WINAPI BindStatusCallback_OnLowResource(IBindStatusCallback *iface,
 232        DWORD reserved)
 233 {
 234     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 235     FIXME("(%p)->(%d)\n", This, reserved);
 236     return E_NOTIMPL;
 237 }
 238
 239 static DWORD get_http_status_code(IBinding *binding)
 240 {
 241     IWinInetHttpInfo *http_info;
 242     DWORD status, size = sizeof(DWORD);
 243     HRESULT hres;
 244
 245     hres = IBinding_QueryInterface(binding, &IID_IWinInetHttpInfo, (void**)&http_info);
 246     if(FAILED(hres))
 247         return HTTP_STATUS_OK;
 248
 249     hres = IWinInetHttpInfo_QueryInfo(http_info, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER,
 250             &status, &size, NULL, NULL);
 251     IWinInetHttpInfo_Release(http_info);
 252
 253     if(FAILED(hres))
 254         return HTTP_STATUS_OK;
 255     return status;
 256 }
 257
 258 static HRESULT WINAPI BindStatusCallback_OnProgress(IBindStatusCallback *iface,
 259         ULONG ulProgress, ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText)
 260 {
 261     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 262     DWORD status_code;
 263
 264     TRACE("(%p)->(%d %d %d %s)\n", This, ulProgress, ulProgressMax, ulStatusCode,
 265           debugstr_w(szStatusText));
 266
 267     switch(ulStatusCode) {
 268     case BINDSTATUS_REDIRECTING:
 269         return set_dochost_url(This->doc_host, szStatusText);
 270     case BINDSTATUS_BEGINDOWNLOADDATA:
 271         set_status_text(This, ulStatusCode, szStatusText);
 272         status_code = get_http_status_code(This->binding);
 273         if(status_code != HTTP_STATUS_OK)
 274             handle_navigation_error(This->doc_host, status_code, This->url, NULL);
 275         return S_OK;
 276
 277     case BINDSTATUS_FINDINGRESOURCE:
 278     case BINDSTATUS_ENDDOWNLOADDATA:
 279     case BINDSTATUS_SENDINGREQUEST:
 280         set_status_text(This, ulStatusCode, szStatusText);
 281         return S_OK;
 282
 283     case BINDSTATUS_CONNECTING:
 284     case BINDSTATUS_CACHEFILENAMEAVAILABLE:
 285     case BINDSTATUS_CLASSIDAVAILABLE:
 286     case BINDSTATUS_MIMETYPEAVAILABLE:
 287     case BINDSTATUS_BEGINSYNCOPERATION:
 288     case BINDSTATUS_ENDSYNCOPERATION:
 289         return S_OK;
 290     default:
 291         FIXME("status code %u\n", ulStatusCode);
 292     }
 293
 294     return S_OK;
 295 }
 296
 297 void handle_navigation_error(DocHost* doc_host, HRESULT hres, BSTR url, IHTMLWindow2 *win2)
 298 {
 299     VARIANT var_status_code, var_frame_name, var_url;
 300     DISPPARAMS dispparams;
 301     VARIANTARG params[5];
 302     VARIANT_BOOL cancel = VARIANT_FALSE;
 303
 304     dispparams.cArgs = 5;
 305     dispparams.cNamedArgs = 0;
 306     dispparams.rgdispidNamedArgs = NULL;
 307     dispparams.rgvarg = params;
 308
 309     V_VT(params) = VT_BOOL|VT_BYREF;
 310     V_BOOLREF(params) = &cancel;
 311
 312     V_VT(params+1) = VT_VARIANT|VT_BYREF;
 313     V_VARIANTREF(params+1) = &var_status_code;
 314     V_VT(&var_status_code) = VT_I4;
 315     V_I4(&var_status_code) = hres;
 316
 317     V_VT(params+2) = VT_VARIANT|VT_BYREF;
 318     V_VARIANTREF(params+2) = &var_frame_name;
 319     V_VT(&var_frame_name) = VT_BSTR;
 320     if(win2) {
 321         hres = IHTMLWindow2_get_name(win2, &V_BSTR(&var_frame_name));
 322         if(FAILED(hres))
 323             V_BSTR(&var_frame_name) = NULL;
 324     } else
 325         V_BSTR(&var_frame_name) = NULL;
 326
 327     V_VT(params+3) = VT_VARIANT|VT_BYREF;
 328     V_VARIANTREF(params+3) = &var_url;
 329     V_VT(&var_url) = VT_BSTR;
 330     V_BSTR(&var_url) = url;
 331
 332     V_VT(params+4) = VT_DISPATCH;
 333     V_DISPATCH(params+4) = (IDispatch*)doc_host->wb;
 334
 335     call_sink(doc_host->cps.wbe2, DISPID_NAVIGATEERROR, &dispparams);
 336     SysFreeString(V_BSTR(&var_frame_name));
 337
 338     if(!cancel)
 339         FIXME("Navigate to error page\n");
 340 }
 341
 342 static HRESULT WINAPI BindStatusCallback_OnStopBinding(IBindStatusCallback *iface,
 343         HRESULT hresult, LPCWSTR szError)
 344 {
 345     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 346
 347     TRACE("(%p)->(%08x %s)\n", This, hresult, debugstr_w(szError));
 348
 349     set_status_text(This, 0, emptyW);
 350
 351     if(!This->doc_host)
 352         return S_OK;
 353
 354     if(!This->doc_host->olecmd)
 355         notify_download_state(This->doc_host, FALSE);
 356     if(FAILED(hresult))
 357         handle_navigation_error(This->doc_host, hresult, This->url, NULL);
 358
 359     IOleClientSite_Release(&This->doc_host->IOleClientSite_iface);
 360     This->doc_host = NULL;
 361
 362     IBinding_Release(This->binding);
 363     This->binding = NULL;
 364
 365     return S_OK;
 366 }
 367
 368 static HRESULT WINAPI BindStatusCallback_GetBindInfo(IBindStatusCallback *iface,
 369         DWORD *grfBINDF, BINDINFO *pbindinfo)
 370 {
 371     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 372
 373     TRACE("(%p)->(%p %p)\n", This, grfBINDF, pbindinfo);
 374
 375     *grfBINDF = BINDF_ASYNCHRONOUS;
 376
 377     if(This->post_data) {
 378         pbindinfo->dwBindVerb = BINDVERB_POST;
 379
 380         pbindinfo->stgmedData.tymed = TYMED_HGLOBAL;
 381         pbindinfo->stgmedData.u.hGlobal = This->post_data;
 382         pbindinfo->cbstgmedData = This->post_data_len;
 383         pbindinfo->stgmedData.pUnkForRelease = (IUnknown*)&This->IBindStatusCallback_iface;
 384         IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface);
 385     }
 386
 387     return S_OK;
 388 }
 389
 390 static HRESULT WINAPI BindStatusCallback_OnDataAvailable(IBindStatusCallback *iface,
 391         DWORD grfBSCF, DWORD dwSize, FORMATETC *pformatetc, STGMEDIUM *pstgmed)
 392 {
 393     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 394     FIXME("(%p)->(%08x %d %p %p)\n", This, grfBSCF, dwSize, pformatetc, pstgmed);
 395     return E_NOTIMPL;
 396 }
 397
 398 static HRESULT WINAPI BindStatusCallback_OnObjectAvailable(IBindStatusCallback *iface,
 399         REFIID riid, IUnknown *punk)
 400 {
 401     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 402
 403     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), punk);
 404
 405     return dochost_object_available(This->doc_host, punk);
 406 }
 407
 408 static const IBindStatusCallbackVtbl BindStatusCallbackVtbl = {
 409     BindStatusCallback_QueryInterface,
 410     BindStatusCallback_AddRef,
 411     BindStatusCallback_Release,
 412     BindStatusCallback_OnStartBinding,
 413     BindStatusCallback_GetPriority,
 414     BindStatusCallback_OnLowResource,
 415     BindStatusCallback_OnProgress,
 416     BindStatusCallback_OnStopBinding,
 417     BindStatusCallback_GetBindInfo,
 418     BindStatusCallback_OnDataAvailable,
 419     BindStatusCallback_OnObjectAvailable
 420 };
 421
 422 static inline BindStatusCallback *impl_from_IHttpNegotiate(IHttpNegotiate *iface)
 423 {
 424     return CONTAINING_RECORD(iface, BindStatusCallback, IHttpNegotiate_iface);
 425 }
 426
 427 static HRESULT WINAPI HttpNegotiate_QueryInterface(IHttpNegotiate *iface,
 428                                                    REFIID riid, void **ppv)
 429 {
 430     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 431     return IBindStatusCallback_QueryInterface(&This->IBindStatusCallback_iface, riid, ppv);
 432 }
 433
 434 static ULONG WINAPI HttpNegotiate_AddRef(IHttpNegotiate *iface)
 435 {
 436     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 437     return IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface);
 438 }
 439
 440 static ULONG WINAPI HttpNegotiate_Release(IHttpNegotiate *iface)
 441 {
 442     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 443     return IBindStatusCallback_Release(&This->IBindStatusCallback_iface);
 444 }
 445
 446 static HRESULT WINAPI HttpNegotiate_BeginningTransaction(IHttpNegotiate *iface,
 447         LPCWSTR szURL, LPCWSTR szHeaders, DWORD dwReserved, LPWSTR *pszAdditionalHeaders)
 448 {
 449     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 450
 451     TRACE("(%p)->(%s %s %d %p)\n", This, debugstr_w(szURL), debugstr_w(szHeaders),
 452           dwReserved, pszAdditionalHeaders);
 453
 454     if(This->headers) {
 455         int size = (strlenW(This->headers)+1)*sizeof(WCHAR);
 456         *pszAdditionalHeaders = CoTaskMemAlloc(size);
 457         memcpy(*pszAdditionalHeaders, This->headers, size);
 458     }
 459
 460     return S_OK;
 461 }
 462
 463 static HRESULT WINAPI HttpNegotiate_OnResponse(IHttpNegotiate *iface,
 464         DWORD dwResponseCode, LPCWSTR szResponseHeaders, LPCWSTR szRequestHeaders,
 465         LPWSTR *pszAdditionalRequestHeaders)
 466 {
 467     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 468     TRACE("(%p)->(%d %s %s %p)\n", This, dwResponseCode, debugstr_w(szResponseHeaders),
 469           debugstr_w(szRequestHeaders), pszAdditionalRequestHeaders);
 470     return S_OK;
 471 }
 472
 473 static const IHttpNegotiateVtbl HttpNegotiateVtbl = {
 474     HttpNegotiate_QueryInterface,
 475     HttpNegotiate_AddRef,
 476     HttpNegotiate_Release,
 477     HttpNegotiate_BeginningTransaction,
 478     HttpNegotiate_OnResponse
 479 };
 480
 481 static inline BindStatusCallback *impl_from_IHttpSecurity(IHttpSecurity *iface)
 482 {
 483     return CONTAINING_RECORD(iface, BindStatusCallback, IHttpSecurity_iface);
 484 }
 485
 486 static HRESULT WINAPI HttpSecurity_QueryInterface(IHttpSecurity *iface, REFIID riid, void **ppv)
 487 {
 488     BindStatusCallback *This = impl_from_IHttpSecurity(iface);
 489     return IBindStatusCallback_QueryInterface(&This->IBindStatusCallback_iface, riid, ppv);
 490 }
 491
 492 static ULONG WINAPI HttpSecurity_AddRef(IHttpSecurity *iface)
 493 {
 494     BindStatusCallback *This = impl_from_IHttpSecurity(iface);
 495     return IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface);
 496 }
 497
 498 static ULONG WINAPI HttpSecurity_Release(IHttpSecurity *iface)
 499 {
 500     BindStatusCallback *This = impl_from_IHttpSecurity(iface);
 501     return IBindStatusCallback_Release(&This->IBindStatusCallback_iface);
 502 }
 503
 504 static HRESULT WINAPI HttpSecurity_GetWindow(IHttpSecurity *iface, REFGUID rguidReason, HWND *phwnd)
 505 {
 506     BindStatusCallback *This = impl_from_IHttpSecurity(iface);
 507
 508     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(rguidReason), phwnd);
 509
 510     if(!This->doc_host)
 511         return E_FAIL;
 512
 513     *phwnd = This->doc_host->frame_hwnd;
 514     return S_OK;
 515 }
 516
 517 static HRESULT WINAPI HttpSecurity_OnSecurityProblem(IHttpSecurity *iface, DWORD dwProblem)
 518 {
 519     BindStatusCallback *This = impl_from_IHttpSecurity(iface);
 520     FIXME("(%p)->(%u)\n", This, dwProblem);
 521     return S_FALSE;
 522 }
 523
 524 static const IHttpSecurityVtbl HttpSecurityVtbl = {
 525     HttpSecurity_QueryInterface,
 526     HttpSecurity_AddRef,
 527     HttpSecurity_Release,
 528     HttpSecurity_GetWindow,
 529     HttpSecurity_OnSecurityProblem
 530 };
 531
 532 static BindStatusCallback *create_callback(DocHost *doc_host, LPCWSTR url, PBYTE post_data,
 533         ULONG post_data_len, LPCWSTR headers)
 534 {
 535     BindStatusCallback *ret = heap_alloc(sizeof(BindStatusCallback));
 536
 537     ret->IBindStatusCallback_iface.lpVtbl = &BindStatusCallbackVtbl;
 538     ret->IHttpNegotiate_iface.lpVtbl      = &HttpNegotiateVtbl;
 539     ret->IHttpSecurity_iface.lpVtbl       = &HttpSecurityVtbl;
 540
 541     ret->ref = 1;
 542     ret->url = SysAllocString(url);
 543     ret->post_data = NULL;
 544     ret->post_data_len = post_data_len;
 545     ret->headers = headers ? SysAllocString(headers) : NULL;
 546
 547     ret->doc_host = doc_host;
 548     IOleClientSite_AddRef(&doc_host->IOleClientSite_iface);
 549
 550     ret->binding = NULL;
 551
 552     if(post_data) {
 553         ret->post_data = GlobalAlloc(0, post_data_len);
 554         memcpy(ret->post_data, post_data, post_data_len);
 555     }
 556
 557     return ret;
 558 }
 559
 560 static void on_before_navigate2(DocHost *This, LPCWSTR url, SAFEARRAY *post_data, LPWSTR headers, VARIANT_BOOL *cancel)
 561 {
 562     VARIANT var_url, var_flags, var_frame_name, var_post_data, var_post_data2, var_headers;
 563     DISPPARAMS dispparams;
 564     VARIANTARG params[7];
 565     WCHAR file_path[MAX_PATH];
 566     DWORD file_path_len = sizeof(file_path) / sizeof(*file_path);
 567
 568     dispparams.cArgs = 7;
 569     dispparams.cNamedArgs = 0;
 570     dispparams.rgdispidNamedArgs = NULL;
 571     dispparams.rgvarg = params;
 572
 573     This->busy = VARIANT_TRUE;
 574
 575     V_VT(params) = VT_BOOL|VT_BYREF;
 576     V_BOOLREF(params) = cancel;
 577
 578     V_VT(params+1) = (VT_BYREF|VT_VARIANT);
 579     V_VARIANTREF(params+1) = &var_headers;
 580     V_VT(&var_headers) = VT_BSTR;
 581     V_BSTR(&var_headers) = headers;
 582
 583     V_VT(params+2) = (VT_BYREF|VT_VARIANT);
 584     V_VARIANTREF(params+2) = &var_post_data2;
 585     V_VT(&var_post_data2) = (VT_BYREF|VT_VARIANT);
 586     V_VARIANTREF(&var_post_data2) = &var_post_data;
 587
 588     if(post_data) {
 589         V_VT(&var_post_data) = VT_UI1|VT_ARRAY;
 590         V_ARRAY(&var_post_data) = post_data;
 591     }else {
 592         V_VT(&var_post_data) = VT_EMPTY;
 593     }
 594
 595     V_VT(params+3) = (VT_BYREF|VT_VARIANT);
 596     V_VARIANTREF(params+3) = &var_frame_name;
 597     V_VT(&var_frame_name) = VT_BSTR;
 598     V_BSTR(&var_frame_name) = NULL;
 599
 600     V_VT(params+4) = (VT_BYREF|VT_VARIANT);
 601     V_VARIANTREF(params+4) = &var_flags;
 602     V_VT(&var_flags) = VT_I4;
 603     V_I4(&var_flags) = 0;
 604
 605     V_VT(params+5) = (VT_BYREF|VT_VARIANT);
 606     V_VARIANTREF(params+5) = &var_url;
 607     V_VT(&var_url) = VT_BSTR;
 608     if(PathCreateFromUrlW(url, file_path, &file_path_len, 0) == S_OK)
 609         V_BSTR(&var_url) = SysAllocString(file_path);
 610     else
 611         V_BSTR(&var_url) = SysAllocString(url);
 612
 613     V_VT(params+6) = (VT_DISPATCH);
 614     V_DISPATCH(params+6) = (IDispatch*)This->wb;
 615
 616     call_sink(This->cps.wbe2, DISPID_BEFORENAVIGATE2, &dispparams);
 617
 618     SysFreeString(V_BSTR(&var_url));
 619 }
 620
 621 /* FIXME: urlmon should handle it */
 622 static BOOL try_application_url(LPCWSTR url)
 623 {
 624     SHELLEXECUTEINFOW exec_info;
 625     WCHAR app[64];
 626     HKEY hkey;
 627     DWORD res, type;
 628     HRESULT hres;
 629
 630     static const WCHAR wszURLProtocol[] = {'U','R','L',' ','P','r','o','t','o','c','o','l',0};
 631
 632     hres = CoInternetParseUrl(url, PARSE_SCHEMA, 0, app, sizeof(app)/sizeof(WCHAR), NULL, 0);
 633     if(FAILED(hres))
 634         return FALSE;
 635
 636     res = RegOpenKeyW(HKEY_CLASSES_ROOT, app, &hkey);
 637     if(res != ERROR_SUCCESS)
 638         return FALSE;
 639
 640     res = RegQueryValueExW(hkey, wszURLProtocol, NULL, &type, NULL, NULL);
 641     RegCloseKey(hkey);
 642     if(res != ERROR_SUCCESS || type != REG_SZ)
 643         return FALSE;
 644
 645     TRACE("opening application %s\n", debugstr_w(app));
 646
 647     memset(&exec_info, 0, sizeof(exec_info));
 648     exec_info.cbSize = sizeof(exec_info);
 649     exec_info.lpFile = url;
 650     exec_info.nShow = SW_SHOW;
 651
 652     return ShellExecuteExW(&exec_info);
 653 }
 654
 655 static HRESULT create_moniker(LPCWSTR url, IMoniker **mon)
 656 {
 657     WCHAR new_url[INTERNET_MAX_URL_LENGTH];
 658     DWORD size;
 659     HRESULT hres;
 660
 661     if(PathIsURLW(url))
 662         return CreateURLMoniker(NULL, url, mon);
 663
 664     size = sizeof(new_url)/sizeof(WCHAR);
 665     hres = UrlApplySchemeW(url, new_url, &size, URL_APPLY_GUESSSCHEME | URL_APPLY_GUESSFILE | URL_APPLY_DEFAULT);
 666     TRACE("was %s got %s\n", debugstr_w(url), debugstr_w(new_url));
 667     if(FAILED(hres)) {
 668         WARN("UrlApplyScheme failed: %08x\n", hres);
 669         return hres;
 670     }
 671
 672     return CreateURLMoniker(NULL, new_url, mon);
 673 }
 674
 675 static HRESULT bind_to_object(DocHost *This, IMoniker *mon, LPCWSTR url, IBindCtx *bindctx,
 676                               IBindStatusCallback *callback)
 677 {
 678     IUnknown *unk = NULL;
 679     WCHAR *display_name;
 680     HRESULT hres;
 681
 682     if(mon) {
 683         IMoniker_AddRef(mon);
 684     }else {
 685         hres = create_moniker(url, &mon);
 686         if(FAILED(hres))
 687             return hres;
 688     }
 689
 690     hres = IMoniker_GetDisplayName(mon, 0, NULL, &display_name);
 691     if(FAILED(hres)) {
 692         FIXME("GetDisplayName failed: %08x\n", hres);
 693         return hres;
 694     }
 695
 696     hres = set_dochost_url(This, display_name);
 697     CoTaskMemFree(display_name);
 698     if(FAILED(hres))
 699         return hres;
 700
 701     IBindCtx_RegisterObjectParam(bindctx, (LPOLESTR)SZ_HTML_CLIENTSITE_OBJECTPARAM,
 702                                  (IUnknown*)&This->IOleClientSite_iface);
 703
 704     hres = IMoniker_BindToObject(mon, bindctx, NULL, &IID_IUnknown, (void**)&unk);
 705     if(SUCCEEDED(hres)) {
 706         hres = S_OK;
 707         if(unk)
 708             IUnknown_Release(unk);
 709     }else if(try_application_url(url)) {
 710         hres = S_OK;
 711     }else {
 712         FIXME("BindToObject failed: %08x\n", hres);
 713     }
 714
 715     IMoniker_Release(mon);
 716     return S_OK;
 717 }
 718
 719 static void html_window_navigate(DocHost *This, IHTMLPrivateWindow *window, BSTR url, BSTR headers, SAFEARRAY *post_data)
 720 {
 721     VARIANT headers_var, post_data_var;
 722     BSTR empty_str;
 723     HRESULT hres;
 724
 725     hres = set_dochost_url(This, url);
 726     if(FAILED(hres))
 727         return;
 728
 729     empty_str = SysAllocStringLen(NULL, 0);
 730
 731     if(headers) {
 732         V_VT(&headers_var) = VT_BSTR;
 733         V_BSTR(&headers_var) = headers;
 734     }else {
 735         V_VT(&headers_var) = VT_EMPTY;
 736     }
 737
 738     if(post_data) {
 739         V_VT(&post_data_var) = VT_UI1|VT_ARRAY;
 740         V_ARRAY(&post_data_var) = post_data;
 741     }else {
 742         V_VT(&post_data_var) = VT_EMPTY;
 743     }
 744
 745     set_doc_state(This, READYSTATE_LOADING);
 746     hres = IHTMLPrivateWindow_SuperNavigate(window, url, empty_str, NULL, NULL, &post_data_var, &headers_var, 0);
 747     SysFreeString(empty_str);
 748     if(FAILED(hres))
 749         WARN("SuprtNavigate failed: %08x\n", hres);
 750 }
 751
 752 typedef struct {
 753     task_header_t header;
 754     BSTR url;
 755     BSTR headers;
 756     SAFEARRAY *post_data;
 757     BOOL async_notif;
 758 } task_doc_navigate_t;
 759
 760 static void doc_navigate_task_destr(task_header_t *t)
 761 {
 762     task_doc_navigate_t *task = (task_doc_navigate_t*)t;
 763
 764     SysFreeString(task->url);
 765     SysFreeString(task->headers);
 766     if(task->post_data)
 767         SafeArrayDestroy(task->post_data);
 768     heap_free(task);
 769 }
 770
 771 static void doc_navigate_proc(DocHost *This, task_header_t *t)
 772 {
 773     task_doc_navigate_t *task = (task_doc_navigate_t*)t;
 774     IHTMLPrivateWindow *priv_window;
 775     HRESULT hres;
 776
 777     if(!This->doc_navigate) {
 778         ERR("Skip nav\n");
 779         return;
 780     }
 781
 782     if(task->async_notif) {
 783         VARIANT_BOOL cancel = VARIANT_FALSE;
 784         on_before_navigate2(This, task->url, task->post_data, task->headers, &cancel);
 785         if(cancel) {
 786             TRACE("Navigation canceled\n");
 787             return;
 788         }
 789     }
 790
 791     hres = IUnknown_QueryInterface(This->doc_navigate, &IID_IHTMLPrivateWindow, (void**)&priv_window);
 792     if(SUCCEEDED(hres)) {
 793         html_window_navigate(This, priv_window, task->url, task->headers, task->post_data);
 794         IHTMLPrivateWindow_Release(priv_window);
 795     }else {
 796         WARN("Could not get IHTMLPrivateWindow iface: %08x\n", hres);
 797     }
 798 }
 799
 800 static HRESULT async_doc_navigate(DocHost *This, LPCWSTR url, LPCWSTR headers, PBYTE post_data, ULONG post_data_size,
 801         BOOL async_notif)
 802 {
 803     task_doc_navigate_t *task;
 804
 805     TRACE("%s\n", debugstr_w(url));
 806
 807     task = heap_alloc_zero(sizeof(*task));
 808     if(!task)
 809         return E_OUTOFMEMORY;
 810
 811     task->url = SysAllocString(url);
 812     if(!task->url) {
 813         doc_navigate_task_destr(&task->header);
 814         return E_OUTOFMEMORY;
 815     }
 816
 817     if(headers) {
 818         task->headers = SysAllocString(headers);
 819         if(!task->headers) {
 820             doc_navigate_task_destr(&task->header);
 821             return E_OUTOFMEMORY;
 822         }
 823     }
 824
 825     if(post_data) {
 826         task->post_data = SafeArrayCreateVector(VT_UI1, 0, post_data_size);
 827         if(!task->post_data) {
 828             doc_navigate_task_destr(&task->header);
 829             return E_OUTOFMEMORY;
 830         }
 831
 832         memcpy(task->post_data->pvData, post_data, post_data_size);
 833     }
 834
 835     if(!async_notif) {
 836         VARIANT_BOOL cancel = VARIANT_FALSE;
 837
 838         on_before_navigate2(This, task->url, task->post_data, task->headers, &cancel);
 839         if(cancel) {
 840             TRACE("Navigation canceled\n");
 841             doc_navigate_task_destr(&task->header);
 842             return S_OK;
 843         }
 844     }
 845
 846     task->async_notif = async_notif;
 847     abort_dochost_tasks(This, doc_navigate_proc);
 848     push_dochost_task(This, &task->header, doc_navigate_proc, doc_navigate_task_destr, FALSE);
 849     return S_OK;
 850 }
 851
 852 static HRESULT navigate_bsc(DocHost *This, BindStatusCallback *bsc, IMoniker *mon)
 853 {
 854     VARIANT_BOOL cancel = VARIANT_FALSE;
 855     SAFEARRAY *post_data = NULL;
 856     IBindCtx *bindctx;
 857     HRESULT hres;
 858
 859     set_doc_state(This, READYSTATE_LOADING);
 860
 861     if(bsc->post_data) {
 862         post_data = SafeArrayCreateVector(VT_UI1, 0, bsc->post_data_len);
 863         memcpy(post_data->pvData, post_data, bsc->post_data_len);
 864     }
 865
 866     on_before_navigate2(This, bsc->url, post_data, bsc->headers, &cancel);
 867     if(post_data)
 868         SafeArrayDestroy(post_data);
 869     if(cancel) {
 870         FIXME("Navigation canceled\n");
 871         return S_OK;
 872     }
 873
 874     notify_download_state(This, TRUE);
 875     on_commandstate_change(This, CSC_NAVIGATEBACK, FALSE);
 876     on_commandstate_change(This, CSC_NAVIGATEFORWARD, FALSE);
 877
 878     if(This->document)
 879         deactivate_document(This);
 880
 881     CreateAsyncBindCtx(0, &bsc->IBindStatusCallback_iface, 0, &bindctx);
 882
 883     if(This->frame)
 884         IOleInPlaceFrame_EnableModeless(This->frame, FALSE);
 885
 886     hres = bind_to_object(This, mon, bsc->url, bindctx, &bsc->IBindStatusCallback_iface);
 887
 888     if(This->frame)
 889         IOleInPlaceFrame_EnableModeless(This->frame, TRUE);
 890
 891     IBindCtx_Release(bindctx);
 892
 893     return hres;
 894 }
 895
 896 typedef struct {
 897     task_header_t header;
 898     BindStatusCallback *bsc;
 899 } task_navigate_bsc_t;
 900
 901 static void navigate_bsc_task_destr(task_header_t *t)
 902 {
 903     task_navigate_bsc_t *task = (task_navigate_bsc_t*)t;
 904
 905     IBindStatusCallback_Release(&task->bsc->IBindStatusCallback_iface);
 906     heap_free(task);
 907 }
 908
 909 static void navigate_bsc_proc(DocHost *This, task_header_t *t)
 910 {
 911     task_navigate_bsc_t *task = (task_navigate_bsc_t*)t;
 912
 913     if(!This->hwnd)
 914         create_doc_view_hwnd(This);
 915
 916     navigate_bsc(This, task->bsc, NULL);
 917 }
 918
 919
 920 HRESULT navigate_url(DocHost *This, LPCWSTR url, const VARIANT *Flags,
 921                      const VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers)
 922 {
 923     SAFEARRAY *post_array = NULL;
 924     PBYTE post_data = NULL;
 925     ULONG post_data_len = 0;
 926     LPWSTR headers = NULL;
 927     HRESULT hres = S_OK;
 928
 929     TRACE("navigating to %s\n", debugstr_w(url));
 930
 931     if((Flags && V_VT(Flags) != VT_EMPTY && V_VT(Flags) != VT_ERROR)
 932        || (TargetFrameName && V_VT(TargetFrameName) != VT_EMPTY && V_VT(TargetFrameName) != VT_ERROR))
 933         FIXME("Unsupported args (Flags %s; TargetFrameName %s)\n", debugstr_variant(Flags), debugstr_variant(TargetFrameName));
 934
 935     if(PostData) {
 936         if(V_VT(PostData) & VT_ARRAY)
 937             post_array = V_ISBYREF(PostData) ? *V_ARRAYREF(PostData) : V_ARRAY(PostData);
 938         else
 939             WARN("Invalid post data %s\n", debugstr_variant(PostData));
 940     }
 941
 942     if(post_array) {
 943         LONG elem_max;
 944         SafeArrayAccessData(post_array, (void**)&post_data);
 945         SafeArrayGetUBound(post_array, 1, &elem_max);
 946         post_data_len = (elem_max+1) * SafeArrayGetElemsize(post_array);
 947     }
 948
 949     if(Headers && V_VT(Headers) == VT_BSTR) {
 950         headers = V_BSTR(Headers);
 951         TRACE("Headers: %s\n", debugstr_w(headers));
 952     }
 953
 954     set_doc_state(This, READYSTATE_LOADING);
 955     This->ready_state = READYSTATE_LOADING;
 956
 957     if(This->doc_navigate) {
 958         WCHAR new_url[INTERNET_MAX_URL_LENGTH];
 959
 960         if(PathIsURLW(url)) {
 961             new_url[0] = 0;
 962         }else {
 963             DWORD size;
 964
 965             size = sizeof(new_url)/sizeof(WCHAR);
 966             hres = UrlApplySchemeW(url, new_url, &size,
 967                     URL_APPLY_GUESSSCHEME | URL_APPLY_GUESSFILE | URL_APPLY_DEFAULT);
 968             if(FAILED(hres)) {
 969                 WARN("UrlApplyScheme failed: %08x\n", hres);
 970                 new_url[0] = 0;
 971             }
 972         }
 973
 974         hres = async_doc_navigate(This, *new_url ? new_url : url, headers, post_data,
 975                 post_data_len, TRUE);
 976     }else {
 977         task_navigate_bsc_t *task;
 978
 979         task = heap_alloc(sizeof(*task));
 980         task->bsc = create_callback(This, url, post_data, post_data_len, headers);
 981         push_dochost_task(This, &task->header, navigate_bsc_proc, navigate_bsc_task_destr, This->url == NULL);
 982     }
 983
 984     if(post_data)
 985         SafeArrayUnaccessData(post_array);
 986
 987     return hres;
 988 }
 989
 990 static HRESULT navigate_hlink(DocHost *This, IMoniker *mon, IBindCtx *bindctx,
 991                               IBindStatusCallback *callback)
 992 {
 993     IHttpNegotiate *http_negotiate;
 994     BindStatusCallback *bsc;
 995     PBYTE post_data = NULL;
 996     ULONG post_data_len = 0;
 997     LPWSTR headers = NULL, url;
 998     BINDINFO bindinfo;
 999     DWORD bindf = 0;
1000     HRESULT hres;
1001
1002     TRACE("\n");
1003
1004     hres = IMoniker_GetDisplayName(mon, 0, NULL, &url);
1005     if(FAILED(hres))
1006         FIXME("GetDisplayName failed: %08x\n", hres);
1007
1008     hres = IBindStatusCallback_QueryInterface(callback, &IID_IHttpNegotiate,
1009                                               (void**)&http_negotiate);
1010     if(SUCCEEDED(hres)) {
1011         static const WCHAR null_string[] = {0};
1012
1013         IHttpNegotiate_BeginningTransaction(http_negotiate, null_string, null_string, 0,
1014                                             &headers);
1015         IHttpNegotiate_Release(http_negotiate);
1016     }
1017
1018     memset(&bindinfo, 0, sizeof(bindinfo));
1019     bindinfo.cbSize = sizeof(bindinfo);
1020
1021     hres = IBindStatusCallback_GetBindInfo(callback, &bindf, &bindinfo);
1022     dump_BINDINFO(&bindinfo);
1023     if(bindinfo.dwBindVerb == BINDVERB_POST) {
1024         post_data_len = bindinfo.cbstgmedData;
1025         if(post_data_len)
1026             post_data = bindinfo.stgmedData.u.hGlobal;
1027     }
1028
1029     if(This->doc_navigate) {
1030         hres = async_doc_navigate(This, url, headers, post_data, post_data_len, FALSE);
1031     }else {
1032         bsc = create_callback(This, url, post_data, post_data_len, headers);
1033         hres = navigate_bsc(This, bsc, mon);
1034         IBindStatusCallback_Release(&bsc->IBindStatusCallback_iface);
1035     }
1036
1037     CoTaskMemFree(url);
1038     CoTaskMemFree(headers);
1039     ReleaseBindInfo(&bindinfo);
1040
1041     return hres;
1042 }
1043
1044 HRESULT go_home(DocHost *This)
1045 {
1046     HKEY hkey;
1047     DWORD res, type, size;
1048     WCHAR wszPageName[MAX_PATH];
1049     static const WCHAR wszAboutBlank[] = {'a','b','o','u','t',':','b','l','a','n','k',0};
1050     static const WCHAR wszStartPage[] = {'S','t','a','r','t',' ','P','a','g','e',0};
1051     static const WCHAR wszSubKey[] = {'S','o','f','t','w','a','r','e','\\',
1052                                       'M','i','c','r','o','s','o','f','t','\\',
1053                                       'I','n','t','e','r','n','e','t',' ','E','x','p','l','o','r','e','r','\\',
1054                                       'M','a','i','n',0};
1055
1056     res = RegOpenKeyW(HKEY_CURRENT_USER, wszSubKey, &hkey);
1057     if (res != ERROR_SUCCESS)
1058         return navigate_url(This, wszAboutBlank, NULL, NULL, NULL, NULL);
1059
1060     size = sizeof(wszPageName);
1061     res = RegQueryValueExW(hkey, wszStartPage, NULL, &type, (LPBYTE)wszPageName, &size);
1062     RegCloseKey(hkey);
1063     if (res != ERROR_SUCCESS || type != REG_SZ)
1064         return navigate_url(This, wszAboutBlank, NULL, NULL, NULL, NULL);
1065
1066     return navigate_url(This, wszPageName, NULL, NULL, NULL, NULL);
1067 }
1068
1069 static HRESULT navigate_history(DocHost *This, unsigned travellog_pos)
1070 {
1071     IPersistHistory *persist_history;
1072     travellog_entry_t *entry;
1073     LARGE_INTEGER li;
1074     HRESULT hres;
1075
1076     if(!This->doc_navigate) {
1077         FIXME("unsupported doc_navigate FALSE\n");
1078         return E_NOTIMPL;
1079     }
1080
1081     This->travellog.loading_pos = travellog_pos;
1082     entry = This->travellog.log + This->travellog.loading_pos;
1083
1084     update_navigation_commands(This);
1085
1086     if(!entry->stream)
1087         return async_doc_navigate(This, entry->url, NULL, NULL, 0, FALSE);
1088
1089     hres = IUnknown_QueryInterface(This->document, &IID_IPersistHistory, (void**)&persist_history);
1090     if(FAILED(hres))
1091         return hres;
1092
1093     li.QuadPart = 0;
1094     IStream_Seek(entry->stream, li, STREAM_SEEK_SET, NULL);
1095
1096     hres = IPersistHistory_LoadHistory(persist_history, entry->stream, NULL);
1097     IPersistHistory_Release(persist_history);
1098     return hres;
1099 }
1100
1101 HRESULT go_back(DocHost *This)
1102 {
1103     if(!This->travellog.position) {
1104         WARN("No history available\n");
1105         return E_FAIL;
1106     }
1107
1108     return navigate_history(This, This->travellog.position-1);
1109 }
1110
1111 HRESULT go_forward(DocHost *This)
1112 {
1113     if(This->travellog.position >= This->travellog.length) {
1114         WARN("No history available\n");
1115         return E_FAIL;
1116     }
1117
1118     return navigate_history(This, This->travellog.position+1);
1119 }
1120
1121 HRESULT get_location_url(DocHost *This, BSTR *ret)
1122 {
1123     FIXME("semi-stub\n");
1124
1125     *ret = This->url ? SysAllocString(This->url) : SysAllocStringLen(NULL, 0);
1126     if(!*ret)
1127         return E_OUTOFMEMORY;
1128
1129     return This->url ? S_OK : S_FALSE;
1130 }
1131
1132 static inline HlinkFrame *impl_from_IHlinkFrame(IHlinkFrame *iface)
1133 {
1134     return CONTAINING_RECORD(iface, HlinkFrame, IHlinkFrame_iface);
1135 }
1136
1137 static HRESULT WINAPI HlinkFrame_QueryInterface(IHlinkFrame *iface, REFIID riid, void **ppv)
1138 {
1139     HlinkFrame *This = impl_from_IHlinkFrame(iface);
1140     return IUnknown_QueryInterface(This->outer, riid, ppv);
1141 }
1142
1143 static ULONG WINAPI HlinkFrame_AddRef(IHlinkFrame *iface)
1144 {
1145     HlinkFrame *This = impl_from_IHlinkFrame(iface);
1146     return IUnknown_AddRef(This->outer);
1147 }
1148
1149 static ULONG WINAPI HlinkFrame_Release(IHlinkFrame *iface)
1150 {
1151     HlinkFrame *This = impl_from_IHlinkFrame(iface);
1152     return IUnknown_Release(This->outer);
1153 }
1154
1155 static HRESULT WINAPI HlinkFrame_SetBrowseContext(IHlinkFrame *iface,
1156                                                   IHlinkBrowseContext *pihlbc)
1157 {
1158     HlinkFrame *This = impl_from_IHlinkFrame(iface);
1159     FIXME("(%p)->(%p)\n", This, pihlbc);
1160     return E_NOTIMPL;
1161 }
1162
1163 static HRESULT WINAPI HlinkFrame_GetBrowseContext(IHlinkFrame *iface,
1164                                                   IHlinkBrowseContext **ppihlbc)
1165 {
1166     HlinkFrame *This = impl_from_IHlinkFrame(iface);
1167     FIXME("(%p)->(%p)\n", This, ppihlbc);
1168     return E_NOTIMPL;
1169 }
1170
1171 static HRESULT WINAPI HlinkFrame_Navigate(IHlinkFrame *iface, DWORD grfHLNF, LPBC pbc,
1172                                           IBindStatusCallback *pibsc, IHlink *pihlNavigate)
1173 {
1174     HlinkFrame *This = impl_from_IHlinkFrame(iface);
1175     IMoniker *mon;
1176     LPWSTR location = NULL;
1177
1178     TRACE("(%p)->(%08x %p %p %p)\n", This, grfHLNF, pbc, pibsc, pihlNavigate);
1179
1180     if(grfHLNF)
1181         FIXME("unsupported grfHLNF=%08x\n", grfHLNF);
1182
1183     /* Windows calls GetTargetFrameName here. */
1184
1185     IHlink_GetMonikerReference(pihlNavigate, 1, &mon, &location);
1186
1187     if(location) {
1188         FIXME("location = %s\n", debugstr_w(location));
1189         CoTaskMemFree(location);
1190     }
1191
1192     /* Windows calls GetHlinkSite here */
1193
1194     if(grfHLNF & HLNF_OPENINNEWWINDOW) {
1195         FIXME("Not supported HLNF_OPENINNEWWINDOW\n");
1196         return E_NOTIMPL;
1197     }
1198
1199     return navigate_hlink(This->doc_host, mon, pbc, pibsc);
1200 }
1201
1202 static HRESULT WINAPI HlinkFrame_OnNavigate(IHlinkFrame *iface, DWORD grfHLNF,
1203         IMoniker *pimkTarget, LPCWSTR pwzLocation, LPCWSTR pwzFriendlyName, DWORD dwreserved)
1204 {
1205     HlinkFrame *This = impl_from_IHlinkFrame(iface);
1206     FIXME("(%p)->(%08x %p %s %s %d)\n", This, grfHLNF, pimkTarget, debugstr_w(pwzLocation),
1207           debugstr_w(pwzFriendlyName), dwreserved);
1208     return E_NOTIMPL;
1209 }
1210
1211 static HRESULT WINAPI HlinkFrame_UpdateHlink(IHlinkFrame *iface, ULONG uHLID,
1212         IMoniker *pimkTarget, LPCWSTR pwzLocation, LPCWSTR pwzFriendlyName)
1213 {
1214     HlinkFrame *This = impl_from_IHlinkFrame(iface);
1215     FIXME("(%p)->(%u %p %s %s)\n", This, uHLID, pimkTarget, debugstr_w(pwzLocation),
1216           debugstr_w(pwzFriendlyName));
1217     return E_NOTIMPL;
1218 }
1219
1220 static const IHlinkFrameVtbl HlinkFrameVtbl = {
1221     HlinkFrame_QueryInterface,
1222     HlinkFrame_AddRef,
1223     HlinkFrame_Release,
1224     HlinkFrame_SetBrowseContext,
1225     HlinkFrame_GetBrowseContext,
1226     HlinkFrame_Navigate,
1227     HlinkFrame_OnNavigate,
1228     HlinkFrame_UpdateHlink
1229 };
1230
1231 static inline HlinkFrame *impl_from_ITargetFrame2(ITargetFrame2 *iface)
1232 {
1233     return CONTAINING_RECORD(iface, HlinkFrame, IHlinkFrame_iface);
1234 }
1235
1236 static HRESULT WINAPI TargetFrame2_QueryInterface(ITargetFrame2 *iface, REFIID riid, void **ppv)
1237 {
1238     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1239     return IUnknown_QueryInterface(This->outer, riid, ppv);
1240 }
1241
1242 static ULONG WINAPI TargetFrame2_AddRef(ITargetFrame2 *iface)
1243 {
1244     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1245     return IUnknown_AddRef(This->outer);
1246 }
1247
1248 static ULONG WINAPI TargetFrame2_Release(ITargetFrame2 *iface)
1249 {
1250     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1251     return IUnknown_Release(This->outer);
1252 }
1253
1254 static HRESULT WINAPI TargetFrame2_SetFrameName(ITargetFrame2 *iface, LPCWSTR pszFrameName)
1255 {
1256     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1257     FIXME("(%p)->(%s)\n", This, debugstr_w(pszFrameName));
1258     return E_NOTIMPL;
1259 }
1260
1261 static HRESULT WINAPI TargetFrame2_GetFrameName(ITargetFrame2 *iface, LPWSTR *ppszFrameName)
1262 {
1263     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1264     FIXME("(%p)->(%p)\n", This, ppszFrameName);
1265     return E_NOTIMPL;
1266 }
1267
1268 static HRESULT WINAPI TargetFrame2_GetParentFrame(ITargetFrame2 *iface, IUnknown **ppunkParent)
1269 {
1270     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1271     FIXME("(%p)->(%p)\n", This, ppunkParent);
1272     return E_NOTIMPL;
1273 }
1274
1275 static HRESULT WINAPI TargetFrame2_SetFrameSrc(ITargetFrame2 *iface, LPCWSTR pszFrameSrc)
1276 {
1277     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1278     FIXME("(%p)->(%s)\n", This, debugstr_w(pszFrameSrc));
1279     return E_NOTIMPL;
1280 }
1281
1282 static HRESULT WINAPI TargetFrame2_GetFrameSrc(ITargetFrame2 *iface, LPWSTR *ppszFrameSrc)
1283 {
1284     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1285     FIXME("(%p)->()\n", This);
1286     return E_NOTIMPL;
1287 }
1288
1289 static HRESULT WINAPI TargetFrame2_GetFramesContainer(ITargetFrame2 *iface, IOleContainer **ppContainer)
1290 {
1291     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1292     FIXME("(%p)->(%p)\n", This, ppContainer);
1293     return E_NOTIMPL;
1294 }
1295
1296 static HRESULT WINAPI TargetFrame2_SetFrameOptions(ITargetFrame2 *iface, DWORD dwFlags)
1297 {
1298     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1299     FIXME("(%p)->(%x)\n", This, dwFlags);
1300     return E_NOTIMPL;
1301 }
1302
1303 static HRESULT WINAPI TargetFrame2_GetFrameOptions(ITargetFrame2 *iface, DWORD *pdwFlags)
1304 {
1305     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1306     FIXME("(%p)->(%p)\n", This, pdwFlags);
1307     return E_NOTIMPL;
1308 }
1309
1310 static HRESULT WINAPI TargetFrame2_SetFrameMargins(ITargetFrame2 *iface, DWORD dwWidth, DWORD dwHeight)
1311 {
1312     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1313     FIXME("(%p)->(%d %d)\n", This, dwWidth, dwHeight);
1314     return E_NOTIMPL;
1315 }
1316
1317 static HRESULT WINAPI TargetFrame2_GetFrameMargins(ITargetFrame2 *iface, DWORD *pdwWidth, DWORD *pdwHeight)
1318 {
1319     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1320     FIXME("(%p)->(%p %p)\n", This, pdwWidth, pdwHeight);
1321     return E_NOTIMPL;
1322 }
1323
1324 static HRESULT WINAPI TargetFrame2_FindFrame(ITargetFrame2 *iface, LPCWSTR pszTargetName, DWORD dwFlags, IUnknown **ppunkTargetFrame)
1325 {
1326     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1327     FIXME("(%p)->(%s %x %p)\n", This, debugstr_w(pszTargetName), dwFlags, ppunkTargetFrame);
1328     return E_NOTIMPL;
1329 }
1330
1331 static HRESULT WINAPI TargetFrame2_GetTargetAlias(ITargetFrame2 *iface, LPCWSTR pszTargetName, LPWSTR *ppszTargetAlias)
1332 {
1333     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1334     FIXME("(%p)->(%s %p)\n", This, debugstr_w(pszTargetName), ppszTargetAlias);
1335     return E_NOTIMPL;
1336 }
1337
1338 static const ITargetFrame2Vtbl TargetFrame2Vtbl = {
1339     TargetFrame2_QueryInterface,
1340     TargetFrame2_AddRef,
1341     TargetFrame2_Release,
1342     TargetFrame2_SetFrameName,
1343     TargetFrame2_GetFrameName,
1344     TargetFrame2_GetParentFrame,
1345     TargetFrame2_SetFrameSrc,
1346     TargetFrame2_GetFrameSrc,
1347     TargetFrame2_GetFramesContainer,
1348     TargetFrame2_SetFrameOptions,
1349     TargetFrame2_GetFrameOptions,
1350     TargetFrame2_SetFrameMargins,
1351     TargetFrame2_GetFrameMargins,
1352     TargetFrame2_FindFrame,
1353     TargetFrame2_GetTargetAlias
1354 };
1355
1356 static inline HlinkFrame *impl_from_ITargetFramePriv2(ITargetFramePriv2 *iface)
1357 {
1358     return CONTAINING_RECORD(iface, HlinkFrame, ITargetFramePriv2_iface);
1359 }
1360
1361 static HRESULT WINAPI TargetFramePriv2_QueryInterface(ITargetFramePriv2 *iface, REFIID riid, void **ppv)
1362 {
1363     HlinkFrame *This = impl_from_ITargetFramePriv2(iface);
1364     return IUnknown_QueryInterface(This->outer, riid, ppv);
1365 }
1366
1367 static ULONG WINAPI TargetFramePriv2_AddRef(ITargetFramePriv2 *iface)
1368 {
1369     HlinkFrame *This = impl_from_ITargetFramePriv2(iface);
1370     return IUnknown_AddRef(This->outer);
1371 }
1372
1373 static ULONG WINAPI TargetFramePriv2_Release(ITargetFramePriv2 *iface)
1374 {
1375     HlinkFrame *This = impl_from_ITargetFramePriv2(iface);
1376     return IUnknown_Release(This->outer);
1377 }
1378
1379 static HRESULT WINAPI TargetFramePriv2_FindFrameDownwards(ITargetFramePriv2 *iface,
1380         LPCWSTR pszTargetName, DWORD dwFlags, IUnknown **ppunkTargetFrame)
1381 {
1382     HlinkFrame *This = impl_from_ITargetFramePriv2(iface);
1383     FIXME("(%p)->(%s %x %p)\n", This, debugstr_w(pszTargetName), dwFlags, ppunkTargetFrame);
1384     return E_NOTIMPL;
1385 }
1386
1387 static HRESULT WINAPI TargetFramePriv2_FindFrameInContext(ITargetFramePriv2 *iface,
1388         LPCWSTR pszTargetName, IUnknown *punkContextFrame, DWORD dwFlags, IUnknown **ppunkTargetFrame)
1389 {
1390     HlinkFrame *This = impl_from_ITargetFramePriv2(iface);
1391     FIXME("(%p)->(%s %p %x %p)\n", This, debugstr_w(pszTargetName), punkContextFrame, dwFlags, ppunkTargetFrame);
1392     return E_NOTIMPL;
1393 }
1394
1395 static HRESULT WINAPI TargetFramePriv2_OnChildFrameActivate(ITargetFramePriv2 *iface, IUnknown *pUnkChildFrame)
1396 {
1397     HlinkFrame *This = impl_from_ITargetFramePriv2(iface);
1398     FIXME("(%p)->(%p)\n", This, pUnkChildFrame);
1399     return E_NOTIMPL;
1400 }
1401
1402 static HRESULT WINAPI TargetFramePriv2_OnChildFrameDeactivate(ITargetFramePriv2 *iface, IUnknown *pUnkChildFrame)
1403 {
1404     HlinkFrame *This = impl_from_ITargetFramePriv2(iface);
1405     FIXME("(%p)->(%p)\n", This, pUnkChildFrame);
1406     return E_NOTIMPL;
1407 }
1408
1409 static HRESULT WINAPI TargetFramePriv2_NavigateHack(ITargetFramePriv2 *iface, DWORD grfHLNF, LPBC pbc,
1410         IBindStatusCallback *pibsc, LPCWSTR pszTargetName, LPCWSTR pszUrl, LPCWSTR pszLocation)
1411 {
1412     HlinkFrame *This = impl_from_ITargetFramePriv2(iface);
1413     FIXME("(%p)->(%x %p %p %s %s %s)\n", This, grfHLNF, pbc, pibsc, debugstr_w(pszTargetName),
1414           debugstr_w(pszUrl), debugstr_w(pszLocation));
1415     return E_NOTIMPL;
1416 }
1417
1418 static HRESULT WINAPI TargetFramePriv2_FindBrowserByIndex(ITargetFramePriv2 *iface, DWORD dwID, IUnknown **ppunkBrowser)
1419 {
1420     HlinkFrame *This = impl_from_ITargetFramePriv2(iface);
1421     FIXME("(%p)->(%d %p)\n", This, dwID, ppunkBrowser);
1422     return E_NOTIMPL;
1423 }
1424
1425 static HRESULT WINAPI TargetFramePriv2_AggregatedNavigation2(ITargetFramePriv2 *iface, DWORD grfHLNF, LPBC pbc,
1426         IBindStatusCallback *pibsc, LPCWSTR pszTargetName, IUri *pUri, LPCWSTR pszLocation)
1427 {
1428     HlinkFrame *This = impl_from_ITargetFramePriv2(iface);
1429     IMoniker *mon;
1430     HRESULT hres;
1431
1432     TRACE("(%p)->(%x %p %p %s %p %s)\n", This, grfHLNF, pbc, pibsc, debugstr_w(pszTargetName),
1433           pUri, debugstr_w(pszLocation));
1434
1435     /*
1436      * NOTE: This is an undocumented function. It seems to be working the way it's implemented,
1437      * but I couldn't get its tests working. It's used by mshtml to load content in a new
1438      * instance of browser.
1439      */
1440
1441     hres = CreateURLMonikerEx2(NULL, pUri, &mon, 0);
1442     if(FAILED(hres))
1443         return hres;
1444
1445     hres = navigate_hlink(This->doc_host, mon, pbc, pibsc);
1446     IMoniker_Release(mon);
1447     return hres;
1448 }
1449
1450 static const ITargetFramePriv2Vtbl TargetFramePriv2Vtbl = {
1451     TargetFramePriv2_QueryInterface,
1452     TargetFramePriv2_AddRef,
1453     TargetFramePriv2_Release,
1454     TargetFramePriv2_FindFrameDownwards,
1455     TargetFramePriv2_FindFrameInContext,
1456     TargetFramePriv2_OnChildFrameActivate,
1457     TargetFramePriv2_OnChildFrameDeactivate,
1458     TargetFramePriv2_NavigateHack,
1459     TargetFramePriv2_FindBrowserByIndex,
1460     TargetFramePriv2_AggregatedNavigation2
1461 };
1462
1463 static inline HlinkFrame *impl_from_IWebBrowserPriv2IE9(IWebBrowserPriv2IE9 *iface)
1464 {
1465     return CONTAINING_RECORD(iface, HlinkFrame, IWebBrowserPriv2IE9_iface);
1466 }
1467
1468 static HRESULT WINAPI WebBrowserPriv2IE9_QueryInterface(IWebBrowserPriv2IE9 *iface, REFIID riid, void **ppv)
1469 {
1470     HlinkFrame *This = impl_from_IWebBrowserPriv2IE9(iface);
1471     return IUnknown_QueryInterface(This->outer, riid, ppv);
1472 }
1473
1474 static ULONG WINAPI WebBrowserPriv2IE9_AddRef(IWebBrowserPriv2IE9 *iface)
1475 {
1476     HlinkFrame *This = impl_from_IWebBrowserPriv2IE9(iface);
1477     return IUnknown_AddRef(This->outer);
1478 }
1479
1480 static ULONG WINAPI WebBrowserPriv2IE9_Release(IWebBrowserPriv2IE9 *iface)
1481 {
1482     HlinkFrame *This = impl_from_IWebBrowserPriv2IE9(iface);
1483     return IUnknown_Release(This->outer);
1484 }
1485
1486 static HRESULT WINAPI WebBrowserPriv2IE9_NavigateWithBindCtx2(IWebBrowserPriv2IE9 *iface, IUri *uri, VARIANT *flags,
1487         VARIANT *target_frame, VARIANT *post_data, VARIANT *headers, IBindCtx *bind_ctx, LPOLESTR url_fragment, DWORD unused)
1488 {
1489     HlinkFrame *This = impl_from_IWebBrowserPriv2IE9(iface);
1490     FIXME("(%p)->(%p %s %s %s %s %p %s)\n", This, uri, debugstr_variant(flags), debugstr_variant(target_frame),
1491           debugstr_variant(post_data), debugstr_variant(headers), bind_ctx, debugstr_w(url_fragment));
1492     return E_NOTIMPL;
1493 }
1494
1495 static const IWebBrowserPriv2IE9Vtbl WebBrowserPriv2IE9Vtbl = {
1496     WebBrowserPriv2IE9_QueryInterface,
1497     WebBrowserPriv2IE9_AddRef,
1498     WebBrowserPriv2IE9_Release,
1499     WebBrowserPriv2IE9_NavigateWithBindCtx2
1500 };
1501
1502 BOOL HlinkFrame_QI(HlinkFrame *This, REFIID riid, void **ppv)
1503 {
1504     if(IsEqualGUID(&IID_IHlinkFrame, riid)) {
1505         TRACE("(%p)->(IID_IHlinkFrame %p)\n", This, ppv);
1506         *ppv = &This->IHlinkFrame_iface;
1507     }else if(IsEqualGUID(&IID_ITargetFrame2, riid)) {
1508         TRACE("(%p)->(IID_ITargetFrame2 %p)\n", This, ppv);
1509         *ppv = &This->ITargetFrame2_iface;
1510     }else if(IsEqualGUID(&IID_ITargetFramePriv, riid)) {
1511         TRACE("(%p)->(IID_ITargetFramePriv %p)\n", This, ppv);
1512         *ppv = &This->ITargetFramePriv2_iface;
1513     }else if(IsEqualGUID(&IID_ITargetFramePriv2, riid)) {
1514         TRACE("(%p)->(IID_ITargetFramePriv2 %p)\n", This, ppv);
1515         *ppv = &This->ITargetFramePriv2_iface;
1516     }else if(IsEqualGUID(&IID_IWebBrowserPriv2IE9, riid)) {
1517         TRACE("(%p)->(IID_IWebBrowserPriv2IE9 %p)\n", This, ppv);
1518         *ppv = &This->IWebBrowserPriv2IE9_iface;
1519     }else {
1520         return FALSE;
1521     }
1522
1523     IUnknown_AddRef((IUnknown*)*ppv);
1524     return TRUE;
1525 }
1526
1527 void HlinkFrame_Init(HlinkFrame *This, IUnknown *outer, DocHost *doc_host)
1528 {
1529     This->IHlinkFrame_iface.lpVtbl   = &HlinkFrameVtbl;
1530     This->ITargetFrame2_iface.lpVtbl = &TargetFrame2Vtbl;
1531     This->ITargetFramePriv2_iface.lpVtbl = &TargetFramePriv2Vtbl;
1532     This->IWebBrowserPriv2IE9_iface.lpVtbl = &WebBrowserPriv2IE9Vtbl;
1533
1534     This->outer = outer;
1535     This->doc_host = doc_host;
1536 }