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