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
  88     if(!pbstrProperty)
  89         return E_POINTER;
  90
  91     if(uriProp > Uri_PROPERTY_STRING_LAST) {
  92         /* Windows allocates an empty BSTR for invalid Uri_PROPERTY's. */
  93         *pbstrProperty = SysAllocStringLen(NULL, 0);
  94
  95         /* It only returns S_FALSE for the ZONE property... */
  96         if(uriProp == Uri_PROPERTY_ZONE)
  97             return S_FALSE;
  98         else
  99             return S_OK;
 100     }
 101
 102     return E_NOTIMPL;
 103 }
 104
 105 static HRESULT WINAPI Uri_GetPropertyLength(IUri *iface, Uri_PROPERTY uriProp, DWORD *pcchProperty, DWORD dwFlags)
 106 {
 107     Uri *This = URI_THIS(iface);
 108     FIXME("(%p)->(%d %p %x)\n", This, uriProp, pcchProperty, dwFlags);
 109
 110     if(!pcchProperty)
 111         return E_INVALIDARG;
 112
 113     /* Can only return a length for a property if it's a string. */
 114     if(uriProp > Uri_PROPERTY_STRING_LAST)
 115         return E_INVALIDARG;
 116
 117     return E_NOTIMPL;
 118 }
 119
 120 static HRESULT WINAPI Uri_GetPropertyDWORD(IUri *iface, Uri_PROPERTY uriProp, DWORD *pcchProperty, DWORD dwFlags)
 121 {
 122     Uri *This = URI_THIS(iface);
 123     FIXME("(%p)->(%d %p %x)\n", This, uriProp, pcchProperty, dwFlags);
 124
 125     if(!pcchProperty)
 126         return E_INVALIDARG;
 127
 128     /* Microsoft's implementation for the ZONE property of a URI seems to be lacking...
 129      * From what I can tell, instead of checking which URLZONE the URI belongs to it
 130      * simply assigns URLZONE_INVALID and returns E_NOTIMPL. This also applies to the GetZone
 131      * function.
 132      */
 133     if(uriProp == Uri_PROPERTY_ZONE) {
 134         *pcchProperty = URLZONE_INVALID;
 135         return E_NOTIMPL;
 136     }
 137
 138     if(uriProp < Uri_PROPERTY_DWORD_START) {
 139         *pcchProperty = 0;
 140         return E_INVALIDARG;
 141     }
 142
 143     return E_NOTIMPL;
 144 }
 145
 146 static HRESULT WINAPI Uri_HasProperty(IUri *iface, Uri_PROPERTY uriProp, BOOL *pfHasProperty)
 147 {
 148     Uri *This = URI_THIS(iface);
 149     FIXME("(%p)->(%d %p)\n", This, uriProp, pfHasProperty);
 150
 151     if(!pfHasProperty)
 152         return E_INVALIDARG;
 153
 154     return E_NOTIMPL;
 155 }
 156
 157 static HRESULT WINAPI Uri_GetAbsoluteUri(IUri *iface, BSTR *pstrAbsoluteUri)
 158 {
 159     Uri *This = URI_THIS(iface);
 160     FIXME("(%p)->(%p)\n", This, pstrAbsoluteUri);
 161
 162     if(!pstrAbsoluteUri)
 163         return E_POINTER;
 164
 165     return E_NOTIMPL;
 166 }
 167
 168 static HRESULT WINAPI Uri_GetAuthority(IUri *iface, BSTR *pstrAuthority)
 169 {
 170     Uri *This = URI_THIS(iface);
 171     FIXME("(%p)->(%p)\n", This, pstrAuthority);
 172
 173     if(!pstrAuthority)
 174         return E_POINTER;
 175
 176     return E_NOTIMPL;
 177 }
 178
 179 static HRESULT WINAPI Uri_GetDisplayUri(IUri *iface, BSTR *pstrDisplayUri)
 180 {
 181     Uri *This = URI_THIS(iface);
 182     FIXME("(%p)->(%p)\n", This, pstrDisplayUri);
 183
 184     if(!pstrDisplayUri)
 185         return E_POINTER;
 186
 187     return E_NOTIMPL;
 188 }
 189
 190 static HRESULT WINAPI Uri_GetDomain(IUri *iface, BSTR *pstrDomain)
 191 {
 192     Uri *This = URI_THIS(iface);
 193     FIXME("(%p)->(%p)\n", This, pstrDomain);
 194
 195     if(!pstrDomain)
 196         return E_POINTER;
 197
 198     return E_NOTIMPL;
 199 }
 200
 201 static HRESULT WINAPI Uri_GetExtension(IUri *iface, BSTR *pstrExtension)
 202 {
 203     Uri *This = URI_THIS(iface);
 204     FIXME("(%p)->(%p)\n", This, pstrExtension);
 205
 206     if(!pstrExtension)
 207         return E_POINTER;
 208
 209     return E_NOTIMPL;
 210 }
 211
 212 static HRESULT WINAPI Uri_GetFragment(IUri *iface, BSTR *pstrFragment)
 213 {
 214     Uri *This = URI_THIS(iface);
 215     FIXME("(%p)->(%p)\n", This, pstrFragment);
 216
 217     if(!pstrFragment)
 218         return E_POINTER;
 219
 220     return E_NOTIMPL;
 221 }
 222
 223 static HRESULT WINAPI Uri_GetHost(IUri *iface, BSTR *pstrHost)
 224 {
 225     Uri *This = URI_THIS(iface);
 226     FIXME("(%p)->(%p)\n", This, pstrHost);
 227     return E_NOTIMPL;
 228 }
 229
 230 static HRESULT WINAPI Uri_GetPassword(IUri *iface, BSTR *pstrPassword)
 231 {
 232     Uri *This = URI_THIS(iface);
 233     FIXME("(%p)->(%p)\n", This, pstrPassword);
 234
 235     if(!pstrPassword)
 236         return E_POINTER;
 237
 238     return E_NOTIMPL;
 239 }
 240
 241 static HRESULT WINAPI Uri_GetPath(IUri *iface, BSTR *pstrPath)
 242 {
 243     Uri *This = URI_THIS(iface);
 244     FIXME("(%p)->(%p)\n", This, pstrPath);
 245
 246     if(!pstrPath)
 247         return E_POINTER;
 248
 249     return E_NOTIMPL;
 250 }
 251
 252 static HRESULT WINAPI Uri_GetPathAndQuery(IUri *iface, BSTR *pstrPathAndQuery)
 253 {
 254     Uri *This = URI_THIS(iface);
 255     FIXME("(%p)->(%p)\n", This, pstrPathAndQuery);
 256
 257     if(!pstrPathAndQuery)
 258         return E_POINTER;
 259
 260     return E_NOTIMPL;
 261 }
 262
 263 static HRESULT WINAPI Uri_GetQuery(IUri *iface, BSTR *pstrQuery)
 264 {
 265     Uri *This = URI_THIS(iface);
 266     FIXME("(%p)->(%p)\n", This, pstrQuery);
 267
 268     if(!pstrQuery)
 269         return E_POINTER;
 270
 271     return E_NOTIMPL;
 272 }
 273
 274 static HRESULT WINAPI Uri_GetRawUri(IUri *iface, BSTR *pstrRawUri)
 275 {
 276     Uri *This = URI_THIS(iface);
 277     FIXME("(%p)->(%p)\n", This, pstrRawUri);
 278
 279     if(!pstrRawUri)
 280         return E_POINTER;
 281
 282     return E_NOTIMPL;
 283 }
 284
 285 static HRESULT WINAPI Uri_GetSchemeName(IUri *iface, BSTR *pstrSchemeName)
 286 {
 287     Uri *This = URI_THIS(iface);
 288     FIXME("(%p)->(%p)\n", This, pstrSchemeName);
 289
 290     if(!pstrSchemeName)
 291         return E_POINTER;
 292
 293     return E_NOTIMPL;
 294 }
 295
 296 static HRESULT WINAPI Uri_GetUserInfo(IUri *iface, BSTR *pstrUserInfo)
 297 {
 298     Uri *This = URI_THIS(iface);
 299     FIXME("(%p)->(%p)\n", This, pstrUserInfo);
 300
 301     if(!pstrUserInfo)
 302         return E_POINTER;
 303
 304     return E_NOTIMPL;
 305 }
 306
 307 static HRESULT WINAPI Uri_GetUserName(IUri *iface, BSTR *pstrUserName)
 308 {
 309     Uri *This = URI_THIS(iface);
 310     FIXME("(%p)->(%p)\n", This, pstrUserName);
 311
 312     if(!pstrUserName)
 313         return E_POINTER;
 314
 315     return E_NOTIMPL;
 316 }
 317
 318 static HRESULT WINAPI Uri_GetHostType(IUri *iface, DWORD *pdwHostType)
 319 {
 320     Uri *This = URI_THIS(iface);
 321     FIXME("(%p)->(%p)\n", This, pdwHostType);
 322
 323     if(!pdwHostType)
 324         return E_INVALIDARG;
 325
 326     return E_NOTIMPL;
 327 }
 328
 329 static HRESULT WINAPI Uri_GetPort(IUri *iface, DWORD *pdwPort)
 330 {
 331     Uri *This = URI_THIS(iface);
 332     FIXME("(%p)->(%p)\n", This, pdwPort);
 333
 334     if(!pdwPort)
 335         return E_INVALIDARG;
 336
 337     return E_NOTIMPL;
 338 }
 339
 340 static HRESULT WINAPI Uri_GetScheme(IUri *iface, DWORD *pdwScheme)
 341 {
 342     Uri *This = URI_THIS(iface);
 343     FIXME("(%p)->(%p)\n", This, pdwScheme);
 344
 345     if(!pdwScheme)
 346         return E_INVALIDARG;
 347
 348     return E_NOTIMPL;
 349 }
 350
 351 static HRESULT WINAPI Uri_GetZone(IUri *iface, DWORD *pdwZone)
 352 {
 353     Uri *This = URI_THIS(iface);
 354     FIXME("(%p)->(%p)\n", This, pdwZone);
 355
 356     if(!pdwZone)
 357         return E_INVALIDARG;
 358
 359     /* Microsoft doesn't seem to have this implemented yet... See
 360      * the comment in Uri_GetPropertyDWORD for more about this.
 361      */
 362     *pdwZone = URLZONE_INVALID;
 363     return E_NOTIMPL;
 364 }
 365
 366 static HRESULT WINAPI Uri_GetProperties(IUri *iface, DWORD *pdwProperties)
 367 {
 368     Uri *This = URI_THIS(iface);
 369     FIXME("(%p)->(%p)\n", This, pdwProperties);
 370
 371     if(!pdwProperties)
 372         return E_INVALIDARG;
 373
 374     return E_NOTIMPL;
 375 }
 376
 377 static HRESULT WINAPI Uri_IsEqual(IUri *iface, IUri *pUri, BOOL *pfEqual)
 378 {
 379     Uri *This = URI_THIS(iface);
 380     FIXME("(%p)->(%p %p)\n", This, pUri, pfEqual);
 381     return E_NOTIMPL;
 382 }
 383
 384 #undef URI_THIS
 385
 386 static const IUriVtbl UriVtbl = {
 387     Uri_QueryInterface,
 388     Uri_AddRef,
 389     Uri_Release,
 390     Uri_GetPropertyBSTR,
 391     Uri_GetPropertyLength,
 392     Uri_GetPropertyDWORD,
 393     Uri_HasProperty,
 394     Uri_GetAbsoluteUri,
 395     Uri_GetAuthority,
 396     Uri_GetDisplayUri,
 397     Uri_GetDomain,
 398     Uri_GetExtension,
 399     Uri_GetFragment,
 400     Uri_GetHost,
 401     Uri_GetPassword,
 402     Uri_GetPath,
 403     Uri_GetPathAndQuery,
 404     Uri_GetQuery,
 405     Uri_GetRawUri,
 406     Uri_GetSchemeName,
 407     Uri_GetUserInfo,
 408     Uri_GetUserName,
 409     Uri_GetHostType,
 410     Uri_GetPort,
 411     Uri_GetScheme,
 412     Uri_GetZone,
 413     Uri_GetProperties,
 414     Uri_IsEqual
 415 };
 416
 417 /***********************************************************************
 418  *           CreateUri (urlmon.@)
 419  */
 420 HRESULT WINAPI CreateUri(LPCWSTR pwzURI, DWORD dwFlags, DWORD_PTR dwReserved, IUri **ppURI)
 421 {
 422     Uri *ret;
 423
 424     TRACE("(%s %x %x %p)\n", debugstr_w(pwzURI), dwFlags, (DWORD)dwReserved, ppURI);
 425
 426     if(!ppURI)
 427         return E_INVALIDARG;
 428
 429     if(!pwzURI) {
 430         *ppURI = NULL;
 431         return E_INVALIDARG;
 432     }
 433
 434     ret = heap_alloc(sizeof(Uri));
 435     if(!ret)
 436         return E_OUTOFMEMORY;
 437
 438     ret->lpIUriVtbl = &UriVtbl;
 439     ret->ref = 1;
 440
 441     *ppURI = URI(ret);
 442     return S_OK;
 443 }
 444
 445 #define URIBUILDER_THIS(iface) DEFINE_THIS(UriBuilder, IUriBuilder, iface)
 446
 447 static HRESULT WINAPI UriBuilder_QueryInterface(IUriBuilder *iface, REFIID riid, void **ppv)
 448 {
 449     UriBuilder *This = URIBUILDER_THIS(iface);
 450
 451     if(IsEqualGUID(&IID_IUnknown, riid)) {
 452         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 453         *ppv = URIBUILDER(This);
 454     }else if(IsEqualGUID(&IID_IUriBuilder, riid)) {
 455         TRACE("(%p)->(IID_IUri %p)\n", This, ppv);
 456         *ppv = URIBUILDER(This);
 457     }else {
 458         TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 459         *ppv = NULL;
 460         return E_NOINTERFACE;
 461     }
 462
 463     IUnknown_AddRef((IUnknown*)*ppv);
 464     return S_OK;
 465 }
 466
 467 static ULONG WINAPI UriBuilder_AddRef(IUriBuilder *iface)
 468 {
 469     UriBuilder *This = URIBUILDER_THIS(iface);
 470     LONG ref = InterlockedIncrement(&This->ref);
 471
 472     TRACE("(%p) ref=%d\n", This, ref);
 473
 474     return ref;
 475 }
 476
 477 static ULONG WINAPI UriBuilder_Release(IUriBuilder *iface)
 478 {
 479     UriBuilder *This = URIBUILDER_THIS(iface);
 480     LONG ref = InterlockedDecrement(&This->ref);
 481
 482     TRACE("(%p) ref=%d\n", This, ref);
 483
 484     if(!ref)
 485         heap_free(This);
 486
 487     return ref;
 488 }
 489
 490 static HRESULT WINAPI UriBuilder_CreateUriSimple(IUriBuilder *iface,
 491                                                  DWORD        dwAllowEncodingPropertyMask,
 492                                                  DWORD_PTR    dwReserved,
 493                                                  IUri       **ppIUri)
 494 {
 495     UriBuilder *This = URIBUILDER_THIS(iface);
 496     FIXME("(%p)->(%d %d %p)\n", This, dwAllowEncodingPropertyMask, (DWORD)dwReserved, ppIUri);
 497     return E_NOTIMPL;
 498 }
 499
 500 static HRESULT WINAPI UriBuilder_CreateUri(IUriBuilder *iface,
 501                                            DWORD        dwCreateFlags,
 502                                            DWORD        dwAllowEncodingPropertyMask,
 503                                            DWORD_PTR    dwReserved,
 504                                            IUri       **ppIUri)
 505 {
 506     UriBuilder *This = URIBUILDER_THIS(iface);
 507     FIXME("(%p)->(0x%08x %d %d %p)\n", This, dwCreateFlags, dwAllowEncodingPropertyMask, (DWORD)dwReserved, ppIUri);
 508     return E_NOTIMPL;
 509 }
 510
 511 static HRESULT WINAPI UriBuilder_CreateUriWithFlags(IUriBuilder *iface,
 512                                          DWORD        dwCreateFlags,
 513                                          DWORD        dwUriBuilderFlags,
 514                                          DWORD        dwAllowEncodingPropertyMask,
 515                                          DWORD_PTR    dwReserved,
 516                                          IUri       **ppIUri)
 517 {
 518     UriBuilder *This = URIBUILDER_THIS(iface);
 519     FIXME("(%p)->(0x%08x 0x%08x %d %d %p)\n", This, dwCreateFlags, dwUriBuilderFlags,
 520         dwAllowEncodingPropertyMask, (DWORD)dwReserved, ppIUri);
 521     return E_NOTIMPL;
 522 }
 523
 524 static HRESULT WINAPI  UriBuilder_GetIUri(IUriBuilder *iface, IUri **ppIUri)
 525 {
 526     UriBuilder *This = URIBUILDER_THIS(iface);
 527     FIXME("(%p)->(%p)\n", This, ppIUri);
 528     return E_NOTIMPL;
 529 }
 530
 531 static HRESULT WINAPI UriBuilder_SetIUri(IUriBuilder *iface, IUri *pIUri)
 532 {
 533     UriBuilder *This = URIBUILDER_THIS(iface);
 534     FIXME("(%p)->(%p)\n", This, pIUri);
 535     return E_NOTIMPL;
 536 }
 537
 538 static HRESULT WINAPI UriBuilder_GetFragment(IUriBuilder *iface, DWORD *pcchFragment, LPCWSTR *ppwzFragment)
 539 {
 540     UriBuilder *This = URIBUILDER_THIS(iface);
 541     FIXME("(%p)->(%p %p)\n", This, pcchFragment, ppwzFragment);
 542     return E_NOTIMPL;
 543 }
 544
 545 static HRESULT WINAPI UriBuilder_GetHost(IUriBuilder *iface, DWORD *pcchHost, LPCWSTR *ppwzHost)
 546 {
 547     UriBuilder *This = URIBUILDER_THIS(iface);
 548     FIXME("(%p)->(%p %p)\n", This, pcchHost, ppwzHost);
 549     return E_NOTIMPL;
 550 }
 551
 552 static HRESULT WINAPI UriBuilder_GetPassword(IUriBuilder *iface, DWORD *pcchPassword, LPCWSTR *ppwzPassword)
 553 {
 554     UriBuilder *This = URIBUILDER_THIS(iface);
 555     FIXME("(%p)->(%p %p)\n", This, pcchPassword, ppwzPassword);
 556     return E_NOTIMPL;
 557 }
 558
 559 static HRESULT WINAPI UriBuilder_GetPath(IUriBuilder *iface, DWORD *pcchPath, LPCWSTR *ppwzPath)
 560 {
 561     UriBuilder *This = URIBUILDER_THIS(iface);
 562     FIXME("(%p)->(%p %p)\n", This, pcchPath, ppwzPath);
 563     return E_NOTIMPL;
 564 }
 565
 566 static HRESULT WINAPI UriBuilder_GetPort(IUriBuilder *iface, BOOL *pfHasPort, DWORD *pdwPort)
 567 {
 568     UriBuilder *This = URIBUILDER_THIS(iface);
 569     FIXME("(%p)->(%p %p)\n", This, pfHasPort, pdwPort);
 570     return E_NOTIMPL;
 571 }
 572
 573 static HRESULT WINAPI UriBuilder_GetQuery(IUriBuilder *iface, DWORD *pcchQuery, LPCWSTR *ppwzQuery)
 574 {
 575     UriBuilder *This = URIBUILDER_THIS(iface);
 576     FIXME("(%p)->(%p %p)\n", This, pcchQuery, ppwzQuery);
 577     return E_NOTIMPL;
 578 }
 579
 580 static HRESULT WINAPI UriBuilder_GetSchemeName(IUriBuilder *iface, DWORD *pcchSchemeName, LPCWSTR *ppwzSchemeName)
 581 {
 582     UriBuilder *This = URIBUILDER_THIS(iface);
 583     FIXME("(%p)->(%p %p)\n", This, pcchSchemeName, ppwzSchemeName);
 584     return E_NOTIMPL;
 585 }
 586
 587 static HRESULT WINAPI UriBuilder_GetUserName(IUriBuilder *iface, DWORD *pcchUserName, LPCWSTR *ppwzUserName)
 588 {
 589     UriBuilder *This = URIBUILDER_THIS(iface);
 590     FIXME("(%p)->(%p %p)\n", This, pcchUserName, ppwzUserName);
 591     return E_NOTIMPL;
 592 }
 593
 594 static HRESULT WINAPI UriBuilder_SetFragment(IUriBuilder *iface, LPCWSTR pwzNewValue)
 595 {
 596     UriBuilder *This = URIBUILDER_THIS(iface);
 597     FIXME("(%p)->(%s)\n", This, debugstr_w(pwzNewValue));
 598     return E_NOTIMPL;
 599 }
 600
 601 static HRESULT WINAPI UriBuilder_SetHost(IUriBuilder *iface, LPCWSTR pwzNewValue)
 602 {
 603     UriBuilder *This = URIBUILDER_THIS(iface);
 604     FIXME("(%p)->(%s)\n", This, debugstr_w(pwzNewValue));
 605     return E_NOTIMPL;
 606 }
 607
 608 static HRESULT WINAPI UriBuilder_SetPassword(IUriBuilder *iface, LPCWSTR pwzNewValue)
 609 {
 610     UriBuilder *This = URIBUILDER_THIS(iface);
 611     FIXME("(%p)->(%s)\n", This, debugstr_w(pwzNewValue));
 612     return E_NOTIMPL;
 613 }
 614
 615 static HRESULT WINAPI UriBuilder_SetPath(IUriBuilder *iface, LPCWSTR pwzNewValue)
 616 {
 617     UriBuilder *This = URIBUILDER_THIS(iface);
 618     FIXME("(%p)->(%s)\n", This, debugstr_w(pwzNewValue));
 619     return E_NOTIMPL;
 620 }
 621
 622 static HRESULT WINAPI UriBuilder_SetPort(IUriBuilder *iface, BOOL fHasPort, DWORD dwNewValue)
 623 {
 624     UriBuilder *This = URIBUILDER_THIS(iface);
 625     FIXME("(%p)->(%d %d)\n", This, fHasPort, dwNewValue);
 626     return E_NOTIMPL;
 627 }
 628
 629 static HRESULT WINAPI UriBuilder_SetQuery(IUriBuilder *iface, LPCWSTR pwzNewValue)
 630 {
 631     UriBuilder *This = URIBUILDER_THIS(iface);
 632     FIXME("(%p)->(%s)\n", This, debugstr_w(pwzNewValue));
 633     return E_NOTIMPL;
 634 }
 635
 636 static HRESULT WINAPI UriBuilder_SetSchemeName(IUriBuilder *iface, LPCWSTR pwzNewValue)
 637 {
 638     UriBuilder *This = URIBUILDER_THIS(iface);
 639     FIXME("(%p)->(%s)\n", This, debugstr_w(pwzNewValue));
 640     return E_NOTIMPL;
 641 }
 642
 643 static HRESULT WINAPI UriBuilder_SetUserName(IUriBuilder *iface, LPCWSTR pwzNewValue)
 644 {
 645     UriBuilder *This = URIBUILDER_THIS(iface);
 646     FIXME("(%p)->(%s)\n", This, debugstr_w(pwzNewValue));
 647     return E_NOTIMPL;
 648 }
 649
 650 static HRESULT WINAPI UriBuilder_RemoveProperties(IUriBuilder *iface, DWORD dwPropertyMask)
 651 {
 652     UriBuilder *This = URIBUILDER_THIS(iface);
 653     FIXME("(%p)->(0x%08x)\n", This, dwPropertyMask);
 654     return E_NOTIMPL;
 655 }
 656
 657 static HRESULT WINAPI UriBuilder_HasBeenModified(IUriBuilder *iface, BOOL *pfModified)
 658 {
 659     UriBuilder *This = URIBUILDER_THIS(iface);
 660     FIXME("(%p)->(%p)\n", This, pfModified);
 661     return E_NOTIMPL;
 662 }
 663
 664 #undef URIBUILDER_THIS
 665
 666 static const IUriBuilderVtbl UriBuilderVtbl = {
 667     UriBuilder_QueryInterface,
 668     UriBuilder_AddRef,
 669     UriBuilder_Release,
 670     UriBuilder_CreateUriSimple,
 671     UriBuilder_CreateUri,
 672     UriBuilder_CreateUriWithFlags,
 673     UriBuilder_GetIUri,
 674     UriBuilder_SetIUri,
 675     UriBuilder_GetFragment,
 676     UriBuilder_GetHost,
 677     UriBuilder_GetPassword,
 678     UriBuilder_GetPath,
 679     UriBuilder_GetPort,
 680     UriBuilder_GetQuery,
 681     UriBuilder_GetSchemeName,
 682     UriBuilder_GetUserName,
 683     UriBuilder_SetFragment,
 684     UriBuilder_SetHost,
 685     UriBuilder_SetPassword,
 686     UriBuilder_SetPath,
 687     UriBuilder_SetPort,
 688     UriBuilder_SetQuery,
 689     UriBuilder_SetSchemeName,
 690     UriBuilder_SetUserName,
 691     UriBuilder_RemoveProperties,
 692     UriBuilder_HasBeenModified,
 693 };
 694
 695 /***********************************************************************
 696  *           CreateIUriBuilder (urlmon.@)
 697  */
 698 HRESULT WINAPI CreateIUriBuilder(IUri *pIUri, DWORD dwFlags, DWORD_PTR dwReserved, IUriBuilder **ppIUriBuilder)
 699 {
 700     UriBuilder *ret;
 701
 702     TRACE("(%p %x %x %p)\n", pIUri, dwFlags, (DWORD)dwReserved, ppIUriBuilder);
 703
 704     ret = heap_alloc(sizeof(UriBuilder));
 705     if(!ret)
 706         return E_OUTOFMEMORY;
 707
 708     ret->lpIUriBuilderVtbl = &UriBuilderVtbl;
 709     ret->ref = 1;
 710
 711     *ppIUriBuilder = URIBUILDER(ret);
 712     return S_OK;
 713 }