git.oblomov.eu Git - wine/blob - dlls/urlmon/uri.c

   1 /*
   2  * Copyright 2010 Jacek Caban for CodeWeavers
   3  * Copyright 2010 Thomas Mullaly
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include "urlmon_main.h"
  21 #include "wine/debug.h"
  22
  23 WINE_DEFAULT_DEBUG_CHANNEL(urlmon);
  24
  25 typedef struct {
  26     const IUriVtbl  *lpIUriVtbl;
  27     LONG ref;
  28 } Uri;
  29
  30 typedef struct {
  31     const IUriBuilderVtbl  *lpIUriBuilderVtbl;
  32     LONG ref;
  33 } UriBuilder;
  34
  35 #define URI(x)         ((IUri*)  &(x)->lpIUriVtbl)
  36 #define URIBUILDER(x)  ((IUriBuilder*)  &(x)->lpIUriBuilderVtbl)
  37
  38 #define URI_THIS(iface) DEFINE_THIS(Uri, IUri, iface)
  39
  40 static HRESULT WINAPI Uri_QueryInterface(IUri *iface, REFIID riid, void **ppv)
  41 {
  42     Uri *This = URI_THIS(iface);
  43
  44     if(IsEqualGUID(&IID_IUnknown, riid)) {
  45         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
  46         *ppv = URI(This);
  47     }else if(IsEqualGUID(&IID_IUri, riid)) {
  48         TRACE("(%p)->(IID_IUri %p)\n", This, ppv);
  49         *ppv = URI(This);
  50     }else {
  51         TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
  52         *ppv = NULL;
  53         return E_NOINTERFACE;
  54     }
  55
  56     IUnknown_AddRef((IUnknown*)*ppv);
  57     return S_OK;
  58 }
  59
  60 static ULONG WINAPI Uri_AddRef(IUri *iface)
  61 {
  62     Uri *This = URI_THIS(iface);
  63     LONG ref = InterlockedIncrement(&This->ref);
  64
  65     TRACE("(%p) ref=%d\n", This, ref);
  66
  67     return ref;
  68 }
  69
  70 static ULONG WINAPI Uri_Release(IUri *iface)
  71 {
  72     Uri *This = URI_THIS(iface);
  73     LONG ref = InterlockedDecrement(&This->ref);
  74
  75     TRACE("(%p) ref=%d\n", This, ref);
  76
  77     if(!ref)
  78         heap_free(This);
  79
  80     return ref;
  81 }
  82
  83 static HRESULT WINAPI Uri_GetPropertyBSTR(IUri *iface, Uri_PROPERTY uriProp, BSTR *pbstrProperty, DWORD dwFlags)
  84 {
  85     Uri *This = URI_THIS(iface);
  86     FIXME("(%p)->(%d %p %x)\n", This, uriProp, pbstrProperty, dwFlags);
  87     return E_NOTIMPL;
  88 }
  89
  90 static HRESULT WINAPI Uri_GetPropertyLength(IUri *iface, Uri_PROPERTY uriProp, DWORD *pcchProperty, DWORD dwFlags)
  91 {
  92     Uri *This = URI_THIS(iface);
  93     FIXME("(%p)->(%d %p %x)\n", This, uriProp, pcchProperty, dwFlags);
  94     return E_NOTIMPL;
  95 }
  96
  97 static HRESULT WINAPI Uri_GetPropertyDWORD(IUri *iface, Uri_PROPERTY uriProp, DWORD *pcchProperty, DWORD dwFlags)
  98 {
  99     Uri *This = URI_THIS(iface);
 100     FIXME("(%p)->(%d %p %x)\n", This, uriProp, pcchProperty, dwFlags);
 101
 102     if(!pcchProperty)
 103         return E_INVALIDARG;
 104
 105     /* Microsoft's implementation for the ZONE property of a URI seems to be lacking...
 106      * From what I can tell, instead of checking which URLZONE the URI belongs to it
 107      * simply assigns URLZONE_INVALID and returns E_NOTIMPL. This also applies the GetZone
 108      * function.
 109      */
 110     if(uriProp == Uri_PROPERTY_ZONE) {
 111         *pcchProperty = URLZONE_INVALID;
 112         return E_NOTIMPL;
 113     }
 114
 115     return E_NOTIMPL;
 116 }
 117
 118 static HRESULT WINAPI Uri_HasProperty(IUri *iface, Uri_PROPERTY uriProp, BOOL *pfHasProperty)
 119 {
 120     Uri *This = URI_THIS(iface);
 121     FIXME("(%p)->()\n", This);
 122     return E_NOTIMPL;
 123 }
 124
 125 static HRESULT WINAPI Uri_GetAbsoluteUri(IUri *iface, BSTR *pstrAbsoluteUri)
 126 {
 127     Uri *This = URI_THIS(iface);
 128     FIXME("(%p)->(%p)\n", This, pstrAbsoluteUri);
 129
 130     if(!pstrAbsoluteUri)
 131         return E_POINTER;
 132
 133     return E_NOTIMPL;
 134 }
 135
 136 static HRESULT WINAPI Uri_GetAuthority(IUri *iface, BSTR *pstrAuthority)
 137 {
 138     Uri *This = URI_THIS(iface);
 139     FIXME("(%p)->(%p)\n", This, pstrAuthority);
 140
 141     if(!pstrAuthority)
 142         return E_POINTER;
 143
 144     return E_NOTIMPL;
 145 }
 146
 147 static HRESULT WINAPI Uri_GetDisplayUri(IUri *iface, BSTR *pstrDisplayUri)
 148 {
 149     Uri *This = URI_THIS(iface);
 150     FIXME("(%p)->(%p)\n", This, pstrDisplayUri);
 151
 152     if(!pstrDisplayUri)
 153         return E_POINTER;
 154
 155     return E_NOTIMPL;
 156 }
 157
 158 static HRESULT WINAPI Uri_GetDomain(IUri *iface, BSTR *pstrDomain)
 159 {
 160     Uri *This = URI_THIS(iface);
 161     FIXME("(%p)->(%p)\n", This, pstrDomain);
 162
 163     if(!pstrDomain)
 164         return E_POINTER;
 165
 166     return E_NOTIMPL;
 167 }
 168
 169 static HRESULT WINAPI Uri_GetExtension(IUri *iface, BSTR *pstrExtension)
 170 {
 171     Uri *This = URI_THIS(iface);
 172     FIXME("(%p)->(%p)\n", This, pstrExtension);
 173
 174     if(!pstrExtension)
 175         return E_POINTER;
 176
 177     return E_NOTIMPL;
 178 }
 179
 180 static HRESULT WINAPI Uri_GetFragment(IUri *iface, BSTR *pstrFragment)
 181 {
 182     Uri *This = URI_THIS(iface);
 183     FIXME("(%p)->(%p)\n", This, pstrFragment);
 184
 185     if(!pstrFragment)
 186         return E_POINTER;
 187
 188     return E_NOTIMPL;
 189 }
 190
 191 static HRESULT WINAPI Uri_GetHost(IUri *iface, BSTR *pstrHost)
 192 {
 193     Uri *This = URI_THIS(iface);
 194     FIXME("(%p)->(%p)\n", This, pstrHost);
 195     return E_NOTIMPL;
 196 }
 197
 198 static HRESULT WINAPI Uri_GetPassword(IUri *iface, BSTR *pstrPassword)
 199 {
 200     Uri *This = URI_THIS(iface);
 201     FIXME("(%p)->(%p)\n", This, pstrPassword);
 202
 203     if(!pstrPassword)
 204         return E_POINTER;
 205
 206     return E_NOTIMPL;
 207 }
 208
 209 static HRESULT WINAPI Uri_GetPath(IUri *iface, BSTR *pstrPath)
 210 {
 211     Uri *This = URI_THIS(iface);
 212     FIXME("(%p)->(%p)\n", This, pstrPath);
 213     return E_NOTIMPL;
 214 }
 215
 216 static HRESULT WINAPI Uri_GetPathAndQuery(IUri *iface, BSTR *pstrPathAndQuery)
 217 {
 218     Uri *This = URI_THIS(iface);
 219     FIXME("(%p)->(%p)\n", This, pstrPathAndQuery);
 220     return E_NOTIMPL;
 221 }
 222
 223 static HRESULT WINAPI Uri_GetQuery(IUri *iface, BSTR *pstrQuery)
 224 {
 225     Uri *This = URI_THIS(iface);
 226     FIXME("(%p)->(%p)\n", This, pstrQuery);
 227     return E_NOTIMPL;
 228 }
 229
 230 static HRESULT WINAPI Uri_GetRawUri(IUri *iface, BSTR *pstrRawUri)
 231 {
 232     Uri *This = URI_THIS(iface);
 233     FIXME("(%p)->(%p)\n", This, pstrRawUri);
 234     return E_NOTIMPL;
 235 }
 236
 237 static HRESULT WINAPI Uri_GetSchemeName(IUri *iface, BSTR *pstrSchemeName)
 238 {
 239     Uri *This = URI_THIS(iface);
 240     FIXME("(%p)->(%p)\n", This, pstrSchemeName);
 241     return E_NOTIMPL;
 242 }
 243
 244 static HRESULT WINAPI Uri_GetUserInfo(IUri *iface, BSTR *pstrUserInfo)
 245 {
 246     Uri *This = URI_THIS(iface);
 247     FIXME("(%p)->(%p)\n", This, pstrUserInfo);
 248     return E_NOTIMPL;
 249 }
 250
 251 static HRESULT WINAPI Uri_GetUserName(IUri *iface, BSTR *pstrUserName)
 252 {
 253     Uri *This = URI_THIS(iface);
 254     FIXME("(%p)->(%p)\n", This, pstrUserName);
 255     return E_NOTIMPL;
 256 }
 257
 258 static HRESULT WINAPI Uri_GetHostType(IUri *iface, DWORD *pdwHostType)
 259 {
 260     Uri *This = URI_THIS(iface);
 261     FIXME("(%p)->(%p)\n", This, pdwHostType);
 262     return E_NOTIMPL;
 263 }
 264
 265 static HRESULT WINAPI Uri_GetPort(IUri *iface, DWORD *pdwPort)
 266 {
 267     Uri *This = URI_THIS(iface);
 268     FIXME("(%p)->(%p)\n", This, pdwPort);
 269     return E_NOTIMPL;
 270 }
 271
 272 static HRESULT WINAPI Uri_GetScheme(IUri *iface, DWORD *pdwScheme)
 273 {
 274     Uri *This = URI_THIS(iface);
 275     FIXME("(%p)->(%p)\n", This, pdwScheme);
 276     return E_NOTIMPL;
 277 }
 278
 279 static HRESULT WINAPI Uri_GetZone(IUri *iface, DWORD *pdwZone)
 280 {
 281     Uri *This = URI_THIS(iface);
 282     FIXME("(%p)->(%p)\n", This, pdwZone);
 283     return E_NOTIMPL;
 284 }
 285
 286 static HRESULT WINAPI Uri_GetProperties(IUri *iface, DWORD *pdwProperties)
 287 {
 288     Uri *This = URI_THIS(iface);
 289     FIXME("(%p)->(%p)\n", This, pdwProperties);
 290     return E_NOTIMPL;
 291 }
 292
 293 static HRESULT WINAPI Uri_IsEqual(IUri *iface, IUri *pUri, BOOL *pfEqual)
 294 {
 295     Uri *This = URI_THIS(iface);
 296     FIXME("(%p)->(%p %p)\n", This, pUri, pfEqual);
 297     return E_NOTIMPL;
 298 }
 299
 300 #undef URI_THIS
 301
 302 static const IUriVtbl UriVtbl = {
 303     Uri_QueryInterface,
 304     Uri_AddRef,
 305     Uri_Release,
 306     Uri_GetPropertyBSTR,
 307     Uri_GetPropertyLength,
 308     Uri_GetPropertyDWORD,
 309     Uri_HasProperty,
 310     Uri_GetAbsoluteUri,
 311     Uri_GetAuthority,
 312     Uri_GetDisplayUri,
 313     Uri_GetDomain,
 314     Uri_GetExtension,
 315     Uri_GetFragment,
 316     Uri_GetHost,
 317     Uri_GetPassword,
 318     Uri_GetPath,
 319     Uri_GetPathAndQuery,
 320     Uri_GetQuery,
 321     Uri_GetRawUri,
 322     Uri_GetSchemeName,
 323     Uri_GetUserInfo,
 324     Uri_GetUserName,
 325     Uri_GetHostType,
 326     Uri_GetPort,
 327     Uri_GetScheme,
 328     Uri_GetZone,
 329     Uri_GetProperties,
 330     Uri_IsEqual
 331 };
 332
 333 /***********************************************************************
 334  *           CreateUri (urlmon.@)
 335  */
 336 HRESULT WINAPI CreateUri(LPCWSTR pwzURI, DWORD dwFlags, DWORD_PTR dwReserved, IUri **ppURI)
 337 {
 338     Uri *ret;
 339
 340     TRACE("(%s %x %x %p)\n", debugstr_w(pwzURI), dwFlags, (DWORD)dwReserved, ppURI);
 341
 342     if(!ppURI)
 343         return E_INVALIDARG;
 344
 345     if(!pwzURI) {
 346         *ppURI = NULL;
 347         return E_INVALIDARG;
 348     }
 349
 350     ret = heap_alloc(sizeof(Uri));
 351     if(!ret)
 352         return E_OUTOFMEMORY;
 353
 354     ret->lpIUriVtbl = &UriVtbl;
 355     ret->ref = 1;
 356
 357     *ppURI = URI(ret);
 358     return S_OK;
 359 }
 360
 361 #define URIBUILDER_THIS(iface) DEFINE_THIS(UriBuilder, IUriBuilder, iface)
 362
 363 static HRESULT WINAPI UriBuilder_QueryInterface(IUriBuilder *iface, REFIID riid, void **ppv)
 364 {
 365     UriBuilder *This = URIBUILDER_THIS(iface);
 366
 367     if(IsEqualGUID(&IID_IUnknown, riid)) {
 368         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 369         *ppv = URIBUILDER(This);
 370     }else if(IsEqualGUID(&IID_IUriBuilder, riid)) {
 371         TRACE("(%p)->(IID_IUri %p)\n", This, ppv);
 372         *ppv = URIBUILDER(This);
 373     }else {
 374         TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 375         *ppv = NULL;
 376         return E_NOINTERFACE;
 377     }
 378
 379     IUnknown_AddRef((IUnknown*)*ppv);
 380     return S_OK;
 381 }
 382
 383 static ULONG WINAPI UriBuilder_AddRef(IUriBuilder *iface)
 384 {
 385     UriBuilder *This = URIBUILDER_THIS(iface);
 386     LONG ref = InterlockedIncrement(&This->ref);
 387
 388     TRACE("(%p) ref=%d\n", This, ref);
 389
 390     return ref;
 391 }
 392
 393 static ULONG WINAPI UriBuilder_Release(IUriBuilder *iface)
 394 {
 395     UriBuilder *This = URIBUILDER_THIS(iface);
 396     LONG ref = InterlockedDecrement(&This->ref);
 397
 398     TRACE("(%p) ref=%d\n", This, ref);
 399
 400     if(!ref)
 401         heap_free(This);
 402
 403     return ref;
 404 }
 405
 406 static HRESULT WINAPI UriBuilder_CreateUriSimple(IUriBuilder *iface,
 407                                                  DWORD        dwAllowEncodingPropertyMask,
 408                                                  DWORD_PTR    dwReserved,
 409                                                  IUri       **ppIUri)
 410 {
 411     UriBuilder *This = URIBUILDER_THIS(iface);
 412     FIXME("(%p)->(%d %d %p)\n", This, dwAllowEncodingPropertyMask, (DWORD)dwReserved, ppIUri);
 413     return E_NOTIMPL;
 414 }
 415
 416 static HRESULT WINAPI UriBuilder_CreateUri(IUriBuilder *iface,
 417                                            DWORD        dwCreateFlags,
 418                                            DWORD        dwAllowEncodingPropertyMask,
 419                                            DWORD_PTR    dwReserved,
 420                                            IUri       **ppIUri)
 421 {
 422     UriBuilder *This = URIBUILDER_THIS(iface);
 423     FIXME("(%p)->(0x%08x %d %d %p)\n", This, dwCreateFlags, dwAllowEncodingPropertyMask, (DWORD)dwReserved, ppIUri);
 424     return E_NOTIMPL;
 425 }
 426
 427 static HRESULT WINAPI UriBuilder_CreateUriWithFlags(IUriBuilder *iface,
 428                                          DWORD        dwCreateFlags,
 429                                          DWORD        dwUriBuilderFlags,
 430                                          DWORD        dwAllowEncodingPropertyMask,
 431                                          DWORD_PTR    dwReserved,
 432                                          IUri       **ppIUri)
 433 {
 434     UriBuilder *This = URIBUILDER_THIS(iface);
 435     FIXME("(%p)->(0x%08x 0x%08x %d %d %p)\n", This, dwCreateFlags, dwUriBuilderFlags,
 436         dwAllowEncodingPropertyMask, (DWORD)dwReserved, ppIUri);
 437     return E_NOTIMPL;
 438 }
 439
 440 static HRESULT WINAPI  UriBuilder_GetIUri(IUriBuilder *iface, IUri **ppIUri)
 441 {
 442     UriBuilder *This = URIBUILDER_THIS(iface);
 443     FIXME("(%p)->(%p)\n", This, ppIUri);
 444     return E_NOTIMPL;
 445 }
 446
 447 static HRESULT WINAPI UriBuilder_SetIUri(IUriBuilder *iface, IUri *pIUri)
 448 {
 449     UriBuilder *This = URIBUILDER_THIS(iface);
 450     FIXME("(%p)->(%p)\n", This, pIUri);
 451     return E_NOTIMPL;
 452 }
 453
 454 static HRESULT WINAPI UriBuilder_GetFragment(IUriBuilder *iface, DWORD *pcchFragment, LPCWSTR *ppwzFragment)
 455 {
 456     UriBuilder *This = URIBUILDER_THIS(iface);
 457     FIXME("(%p)->(%p %p)\n", This, pcchFragment, ppwzFragment);
 458     return E_NOTIMPL;
 459 }
 460
 461 static HRESULT WINAPI UriBuilder_GetHost(IUriBuilder *iface, DWORD *pcchHost, LPCWSTR *ppwzHost)
 462 {
 463     UriBuilder *This = URIBUILDER_THIS(iface);
 464     FIXME("(%p)->(%p %p)\n", This, pcchHost, ppwzHost);
 465     return E_NOTIMPL;
 466 }
 467
 468 static HRESULT WINAPI UriBuilder_GetPassword(IUriBuilder *iface, DWORD *pcchPassword, LPCWSTR *ppwzPassword)
 469 {
 470     UriBuilder *This = URIBUILDER_THIS(iface);
 471     FIXME("(%p)->(%p %p)\n", This, pcchPassword, ppwzPassword);
 472     return E_NOTIMPL;
 473 }
 474
 475 static HRESULT WINAPI UriBuilder_GetPath(IUriBuilder *iface, DWORD *pcchPath, LPCWSTR *ppwzPath)
 476 {
 477     UriBuilder *This = URIBUILDER_THIS(iface);
 478     FIXME("(%p)->(%p %p)\n", This, pcchPath, ppwzPath);
 479     return E_NOTIMPL;
 480 }
 481
 482 static HRESULT WINAPI UriBuilder_GetPort(IUriBuilder *iface, BOOL *pfHasPort, DWORD *pdwPort)
 483 {
 484     UriBuilder *This = URIBUILDER_THIS(iface);
 485     FIXME("(%p)->(%p %p)\n", This, pfHasPort, pdwPort);
 486     return E_NOTIMPL;
 487 }
 488
 489 static HRESULT WINAPI UriBuilder_GetQuery(IUriBuilder *iface, DWORD *pcchQuery, LPCWSTR *ppwzQuery)
 490 {
 491     UriBuilder *This = URIBUILDER_THIS(iface);
 492     FIXME("(%p)->(%p %p)\n", This, pcchQuery, ppwzQuery);
 493     return E_NOTIMPL;
 494 }
 495
 496 static HRESULT WINAPI UriBuilder_GetSchemeName(IUriBuilder *iface, DWORD *pcchSchemeName, LPCWSTR *ppwzSchemeName)
 497 {
 498     UriBuilder *This = URIBUILDER_THIS(iface);
 499     FIXME("(%p)->(%p %p)\n", This, pcchSchemeName, ppwzSchemeName);
 500     return E_NOTIMPL;
 501 }
 502
 503 static HRESULT WINAPI UriBuilder_GetUserName(IUriBuilder *iface, DWORD *pcchUserName, LPCWSTR *ppwzUserName)
 504 {
 505     UriBuilder *This = URIBUILDER_THIS(iface);
 506     FIXME("(%p)->(%p %p)\n", This, pcchUserName, ppwzUserName);
 507     return E_NOTIMPL;
 508 }
 509
 510 static HRESULT WINAPI UriBuilder_SetFragment(IUriBuilder *iface, LPCWSTR pwzNewValue)
 511 {
 512     UriBuilder *This = URIBUILDER_THIS(iface);
 513     FIXME("(%p)->(%s)\n", This, debugstr_w(pwzNewValue));
 514     return E_NOTIMPL;
 515 }
 516
 517 static HRESULT WINAPI UriBuilder_SetHost(IUriBuilder *iface, LPCWSTR pwzNewValue)
 518 {
 519     UriBuilder *This = URIBUILDER_THIS(iface);
 520     FIXME("(%p)->(%s)\n", This, debugstr_w(pwzNewValue));
 521     return E_NOTIMPL;
 522 }
 523
 524 static HRESULT WINAPI UriBuilder_SetPassword(IUriBuilder *iface, LPCWSTR pwzNewValue)
 525 {
 526     UriBuilder *This = URIBUILDER_THIS(iface);
 527     FIXME("(%p)->(%s)\n", This, debugstr_w(pwzNewValue));
 528     return E_NOTIMPL;
 529 }
 530
 531 static HRESULT WINAPI UriBuilder_SetPath(IUriBuilder *iface, LPCWSTR pwzNewValue)
 532 {
 533     UriBuilder *This = URIBUILDER_THIS(iface);
 534     FIXME("(%p)->(%s)\n", This, debugstr_w(pwzNewValue));
 535     return E_NOTIMPL;
 536 }
 537
 538 static HRESULT WINAPI UriBuilder_SetPort(IUriBuilder *iface, BOOL fHasPort, DWORD dwNewValue)
 539 {
 540     UriBuilder *This = URIBUILDER_THIS(iface);
 541     FIXME("(%p)->(%d %d)\n", This, fHasPort, dwNewValue);
 542     return E_NOTIMPL;
 543 }
 544
 545 static HRESULT WINAPI UriBuilder_SetQuery(IUriBuilder *iface, LPCWSTR pwzNewValue)
 546 {
 547     UriBuilder *This = URIBUILDER_THIS(iface);
 548     FIXME("(%p)->(%s)\n", This, debugstr_w(pwzNewValue));
 549     return E_NOTIMPL;
 550 }
 551
 552 static HRESULT WINAPI UriBuilder_SetSchemeName(IUriBuilder *iface, LPCWSTR pwzNewValue)
 553 {
 554     UriBuilder *This = URIBUILDER_THIS(iface);
 555     FIXME("(%p)->(%s)\n", This, debugstr_w(pwzNewValue));
 556     return E_NOTIMPL;
 557 }
 558
 559 static HRESULT WINAPI UriBuilder_SetUserName(IUriBuilder *iface, LPCWSTR pwzNewValue)
 560 {
 561     UriBuilder *This = URIBUILDER_THIS(iface);
 562     FIXME("(%p)->(%s)\n", This, debugstr_w(pwzNewValue));
 563     return E_NOTIMPL;
 564 }
 565
 566 static HRESULT WINAPI UriBuilder_RemoveProperties(IUriBuilder *iface, DWORD dwPropertyMask)
 567 {
 568     UriBuilder *This = URIBUILDER_THIS(iface);
 569     FIXME("(%p)->(0x%08x)\n", This, dwPropertyMask);
 570     return E_NOTIMPL;
 571 }
 572
 573 static HRESULT WINAPI UriBuilder_HasBeenModified(IUriBuilder *iface, BOOL *pfModified)
 574 {
 575     UriBuilder *This = URIBUILDER_THIS(iface);
 576     FIXME("(%p)->(%p)\n", This, pfModified);
 577     return E_NOTIMPL;
 578 }
 579
 580 #undef URIBUILDER_THIS
 581
 582 static const IUriBuilderVtbl UriBuilderVtbl = {
 583     UriBuilder_QueryInterface,
 584     UriBuilder_AddRef,
 585     UriBuilder_Release,
 586     UriBuilder_CreateUriSimple,
 587     UriBuilder_CreateUri,
 588     UriBuilder_CreateUriWithFlags,
 589     UriBuilder_GetIUri,
 590     UriBuilder_SetIUri,
 591     UriBuilder_GetFragment,
 592     UriBuilder_GetHost,
 593     UriBuilder_GetPassword,
 594     UriBuilder_GetPath,
 595     UriBuilder_GetPort,
 596     UriBuilder_GetQuery,
 597     UriBuilder_GetSchemeName,
 598     UriBuilder_GetUserName,
 599     UriBuilder_SetFragment,
 600     UriBuilder_SetHost,
 601     UriBuilder_SetPassword,
 602     UriBuilder_SetPath,
 603     UriBuilder_SetPort,
 604     UriBuilder_SetQuery,
 605     UriBuilder_SetSchemeName,
 606     UriBuilder_SetUserName,
 607     UriBuilder_RemoveProperties,
 608     UriBuilder_HasBeenModified,
 609 };
 610
 611 /***********************************************************************
 612  *           CreateIUriBuilder (urlmon.@)
 613  */
 614 HRESULT WINAPI CreateIUriBuilder(IUri *pIUri, DWORD dwFlags, DWORD_PTR dwReserved, IUriBuilder **ppIUriBuilder)
 615 {
 616     UriBuilder *ret;
 617
 618     TRACE("(%p %x %x %p)\n", pIUri, dwFlags, (DWORD)dwReserved, ppIUriBuilder);
 619
 620     ret = heap_alloc(sizeof(UriBuilder));
 621     if(!ret)
 622         return E_OUTOFMEMORY;
 623
 624     ret->lpIUriBuilderVtbl = &UriBuilderVtbl;
 625     ret->ref = 1;
 626
 627     *ppIUriBuilder = URIBUILDER(ret);
 628     return S_OK;
 629 }