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 to 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
 214     if(!pstrPath)
 215         return E_POINTER;
 216
 217     return E_NOTIMPL;
 218 }
 219
 220 static HRESULT WINAPI Uri_GetPathAndQuery(IUri *iface, BSTR *pstrPathAndQuery)
 221 {
 222     Uri *This = URI_THIS(iface);
 223     FIXME("(%p)->(%p)\n", This, pstrPathAndQuery);
 224
 225     if(!pstrPathAndQuery)
 226         return E_POINTER;
 227
 228     return E_NOTIMPL;
 229 }
 230
 231 static HRESULT WINAPI Uri_GetQuery(IUri *iface, BSTR *pstrQuery)
 232 {
 233     Uri *This = URI_THIS(iface);
 234     FIXME("(%p)->(%p)\n", This, pstrQuery);
 235
 236     if(!pstrQuery)
 237         return E_POINTER;
 238
 239     return E_NOTIMPL;
 240 }
 241
 242 static HRESULT WINAPI Uri_GetRawUri(IUri *iface, BSTR *pstrRawUri)
 243 {
 244     Uri *This = URI_THIS(iface);
 245     FIXME("(%p)->(%p)\n", This, pstrRawUri);
 246
 247     if(!pstrRawUri)
 248         return E_POINTER;
 249
 250     return E_NOTIMPL;
 251 }
 252
 253 static HRESULT WINAPI Uri_GetSchemeName(IUri *iface, BSTR *pstrSchemeName)
 254 {
 255     Uri *This = URI_THIS(iface);
 256     FIXME("(%p)->(%p)\n", This, pstrSchemeName);
 257
 258     if(!pstrSchemeName)
 259         return E_POINTER;
 260
 261     return E_NOTIMPL;
 262 }
 263
 264 static HRESULT WINAPI Uri_GetUserInfo(IUri *iface, BSTR *pstrUserInfo)
 265 {
 266     Uri *This = URI_THIS(iface);
 267     FIXME("(%p)->(%p)\n", This, pstrUserInfo);
 268
 269     if(!pstrUserInfo)
 270         return E_POINTER;
 271
 272     return E_NOTIMPL;
 273 }
 274
 275 static HRESULT WINAPI Uri_GetUserName(IUri *iface, BSTR *pstrUserName)
 276 {
 277     Uri *This = URI_THIS(iface);
 278     FIXME("(%p)->(%p)\n", This, pstrUserName);
 279
 280     if(!pstrUserName)
 281         return E_POINTER;
 282
 283     return E_NOTIMPL;
 284 }
 285
 286 static HRESULT WINAPI Uri_GetHostType(IUri *iface, DWORD *pdwHostType)
 287 {
 288     Uri *This = URI_THIS(iface);
 289     FIXME("(%p)->(%p)\n", This, pdwHostType);
 290
 291     if(!pdwHostType)
 292         return E_INVALIDARG;
 293
 294     return E_NOTIMPL;
 295 }
 296
 297 static HRESULT WINAPI Uri_GetPort(IUri *iface, DWORD *pdwPort)
 298 {
 299     Uri *This = URI_THIS(iface);
 300     FIXME("(%p)->(%p)\n", This, pdwPort);
 301
 302     if(!pdwPort)
 303         return E_INVALIDARG;
 304
 305     return E_NOTIMPL;
 306 }
 307
 308 static HRESULT WINAPI Uri_GetScheme(IUri *iface, DWORD *pdwScheme)
 309 {
 310     Uri *This = URI_THIS(iface);
 311     FIXME("(%p)->(%p)\n", This, pdwScheme);
 312
 313     if(!pdwScheme)
 314         return E_INVALIDARG;
 315
 316     return E_NOTIMPL;
 317 }
 318
 319 static HRESULT WINAPI Uri_GetZone(IUri *iface, DWORD *pdwZone)
 320 {
 321     Uri *This = URI_THIS(iface);
 322     FIXME("(%p)->(%p)\n", This, pdwZone);
 323
 324     if(!pdwZone)
 325         return E_INVALIDARG;
 326
 327     /* Microsoft doesn't seem to have this implemented yet... See
 328      * the comment in Uri_GetPropertyDWORD for more about this.
 329      */
 330     *pdwZone = URLZONE_INVALID;
 331     return E_NOTIMPL;
 332 }
 333
 334 static HRESULT WINAPI Uri_GetProperties(IUri *iface, DWORD *pdwProperties)
 335 {
 336     Uri *This = URI_THIS(iface);
 337     FIXME("(%p)->(%p)\n", This, pdwProperties);
 338     return E_NOTIMPL;
 339 }
 340
 341 static HRESULT WINAPI Uri_IsEqual(IUri *iface, IUri *pUri, BOOL *pfEqual)
 342 {
 343     Uri *This = URI_THIS(iface);
 344     FIXME("(%p)->(%p %p)\n", This, pUri, pfEqual);
 345     return E_NOTIMPL;
 346 }
 347
 348 #undef URI_THIS
 349
 350 static const IUriVtbl UriVtbl = {
 351     Uri_QueryInterface,
 352     Uri_AddRef,
 353     Uri_Release,
 354     Uri_GetPropertyBSTR,
 355     Uri_GetPropertyLength,
 356     Uri_GetPropertyDWORD,
 357     Uri_HasProperty,
 358     Uri_GetAbsoluteUri,
 359     Uri_GetAuthority,
 360     Uri_GetDisplayUri,
 361     Uri_GetDomain,
 362     Uri_GetExtension,
 363     Uri_GetFragment,
 364     Uri_GetHost,
 365     Uri_GetPassword,
 366     Uri_GetPath,
 367     Uri_GetPathAndQuery,
 368     Uri_GetQuery,
 369     Uri_GetRawUri,
 370     Uri_GetSchemeName,
 371     Uri_GetUserInfo,
 372     Uri_GetUserName,
 373     Uri_GetHostType,
 374     Uri_GetPort,
 375     Uri_GetScheme,
 376     Uri_GetZone,
 377     Uri_GetProperties,
 378     Uri_IsEqual
 379 };
 380
 381 /***********************************************************************
 382  *           CreateUri (urlmon.@)
 383  */
 384 HRESULT WINAPI CreateUri(LPCWSTR pwzURI, DWORD dwFlags, DWORD_PTR dwReserved, IUri **ppURI)
 385 {
 386     Uri *ret;
 387
 388     TRACE("(%s %x %x %p)\n", debugstr_w(pwzURI), dwFlags, (DWORD)dwReserved, ppURI);
 389
 390     if(!ppURI)
 391         return E_INVALIDARG;
 392
 393     if(!pwzURI) {
 394         *ppURI = NULL;
 395         return E_INVALIDARG;
 396     }
 397
 398     ret = heap_alloc(sizeof(Uri));
 399     if(!ret)
 400         return E_OUTOFMEMORY;
 401
 402     ret->lpIUriVtbl = &UriVtbl;
 403     ret->ref = 1;
 404
 405     *ppURI = URI(ret);
 406     return S_OK;
 407 }
 408
 409 #define URIBUILDER_THIS(iface) DEFINE_THIS(UriBuilder, IUriBuilder, iface)
 410
 411 static HRESULT WINAPI UriBuilder_QueryInterface(IUriBuilder *iface, REFIID riid, void **ppv)
 412 {
 413     UriBuilder *This = URIBUILDER_THIS(iface);
 414
 415     if(IsEqualGUID(&IID_IUnknown, riid)) {
 416         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 417         *ppv = URIBUILDER(This);
 418     }else if(IsEqualGUID(&IID_IUriBuilder, riid)) {
 419         TRACE("(%p)->(IID_IUri %p)\n", This, ppv);
 420         *ppv = URIBUILDER(This);
 421     }else {
 422         TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 423         *ppv = NULL;
 424         return E_NOINTERFACE;
 425     }
 426
 427     IUnknown_AddRef((IUnknown*)*ppv);
 428     return S_OK;
 429 }
 430
 431 static ULONG WINAPI UriBuilder_AddRef(IUriBuilder *iface)
 432 {
 433     UriBuilder *This = URIBUILDER_THIS(iface);
 434     LONG ref = InterlockedIncrement(&This->ref);
 435
 436     TRACE("(%p) ref=%d\n", This, ref);
 437
 438     return ref;
 439 }
 440
 441 static ULONG WINAPI UriBuilder_Release(IUriBuilder *iface)
 442 {
 443     UriBuilder *This = URIBUILDER_THIS(iface);
 444     LONG ref = InterlockedDecrement(&This->ref);
 445
 446     TRACE("(%p) ref=%d\n", This, ref);
 447
 448     if(!ref)
 449         heap_free(This);
 450
 451     return ref;
 452 }
 453
 454 static HRESULT WINAPI UriBuilder_CreateUriSimple(IUriBuilder *iface,
 455                                                  DWORD        dwAllowEncodingPropertyMask,
 456                                                  DWORD_PTR    dwReserved,
 457                                                  IUri       **ppIUri)
 458 {
 459     UriBuilder *This = URIBUILDER_THIS(iface);
 460     FIXME("(%p)->(%d %d %p)\n", This, dwAllowEncodingPropertyMask, (DWORD)dwReserved, ppIUri);
 461     return E_NOTIMPL;
 462 }
 463
 464 static HRESULT WINAPI UriBuilder_CreateUri(IUriBuilder *iface,
 465                                            DWORD        dwCreateFlags,
 466                                            DWORD        dwAllowEncodingPropertyMask,
 467                                            DWORD_PTR    dwReserved,
 468                                            IUri       **ppIUri)
 469 {
 470     UriBuilder *This = URIBUILDER_THIS(iface);
 471     FIXME("(%p)->(0x%08x %d %d %p)\n", This, dwCreateFlags, dwAllowEncodingPropertyMask, (DWORD)dwReserved, ppIUri);
 472     return E_NOTIMPL;
 473 }
 474
 475 static HRESULT WINAPI UriBuilder_CreateUriWithFlags(IUriBuilder *iface,
 476                                          DWORD        dwCreateFlags,
 477                                          DWORD        dwUriBuilderFlags,
 478                                          DWORD        dwAllowEncodingPropertyMask,
 479                                          DWORD_PTR    dwReserved,
 480                                          IUri       **ppIUri)
 481 {
 482     UriBuilder *This = URIBUILDER_THIS(iface);
 483     FIXME("(%p)->(0x%08x 0x%08x %d %d %p)\n", This, dwCreateFlags, dwUriBuilderFlags,
 484         dwAllowEncodingPropertyMask, (DWORD)dwReserved, ppIUri);
 485     return E_NOTIMPL;
 486 }
 487
 488 static HRESULT WINAPI  UriBuilder_GetIUri(IUriBuilder *iface, IUri **ppIUri)
 489 {
 490     UriBuilder *This = URIBUILDER_THIS(iface);
 491     FIXME("(%p)->(%p)\n", This, ppIUri);
 492     return E_NOTIMPL;
 493 }
 494
 495 static HRESULT WINAPI UriBuilder_SetIUri(IUriBuilder *iface, IUri *pIUri)
 496 {
 497     UriBuilder *This = URIBUILDER_THIS(iface);
 498     FIXME("(%p)->(%p)\n", This, pIUri);
 499     return E_NOTIMPL;
 500 }
 501
 502 static HRESULT WINAPI UriBuilder_GetFragment(IUriBuilder *iface, DWORD *pcchFragment, LPCWSTR *ppwzFragment)
 503 {
 504     UriBuilder *This = URIBUILDER_THIS(iface);
 505     FIXME("(%p)->(%p %p)\n", This, pcchFragment, ppwzFragment);
 506     return E_NOTIMPL;
 507 }
 508
 509 static HRESULT WINAPI UriBuilder_GetHost(IUriBuilder *iface, DWORD *pcchHost, LPCWSTR *ppwzHost)
 510 {
 511     UriBuilder *This = URIBUILDER_THIS(iface);
 512     FIXME("(%p)->(%p %p)\n", This, pcchHost, ppwzHost);
 513     return E_NOTIMPL;
 514 }
 515
 516 static HRESULT WINAPI UriBuilder_GetPassword(IUriBuilder *iface, DWORD *pcchPassword, LPCWSTR *ppwzPassword)
 517 {
 518     UriBuilder *This = URIBUILDER_THIS(iface);
 519     FIXME("(%p)->(%p %p)\n", This, pcchPassword, ppwzPassword);
 520     return E_NOTIMPL;
 521 }
 522
 523 static HRESULT WINAPI UriBuilder_GetPath(IUriBuilder *iface, DWORD *pcchPath, LPCWSTR *ppwzPath)
 524 {
 525     UriBuilder *This = URIBUILDER_THIS(iface);
 526     FIXME("(%p)->(%p %p)\n", This, pcchPath, ppwzPath);
 527     return E_NOTIMPL;
 528 }
 529
 530 static HRESULT WINAPI UriBuilder_GetPort(IUriBuilder *iface, BOOL *pfHasPort, DWORD *pdwPort)
 531 {
 532     UriBuilder *This = URIBUILDER_THIS(iface);
 533     FIXME("(%p)->(%p %p)\n", This, pfHasPort, pdwPort);
 534     return E_NOTIMPL;
 535 }
 536
 537 static HRESULT WINAPI UriBuilder_GetQuery(IUriBuilder *iface, DWORD *pcchQuery, LPCWSTR *ppwzQuery)
 538 {
 539     UriBuilder *This = URIBUILDER_THIS(iface);
 540     FIXME("(%p)->(%p %p)\n", This, pcchQuery, ppwzQuery);
 541     return E_NOTIMPL;
 542 }
 543
 544 static HRESULT WINAPI UriBuilder_GetSchemeName(IUriBuilder *iface, DWORD *pcchSchemeName, LPCWSTR *ppwzSchemeName)
 545 {
 546     UriBuilder *This = URIBUILDER_THIS(iface);
 547     FIXME("(%p)->(%p %p)\n", This, pcchSchemeName, ppwzSchemeName);
 548     return E_NOTIMPL;
 549 }
 550
 551 static HRESULT WINAPI UriBuilder_GetUserName(IUriBuilder *iface, DWORD *pcchUserName, LPCWSTR *ppwzUserName)
 552 {
 553     UriBuilder *This = URIBUILDER_THIS(iface);
 554     FIXME("(%p)->(%p %p)\n", This, pcchUserName, ppwzUserName);
 555     return E_NOTIMPL;
 556 }
 557
 558 static HRESULT WINAPI UriBuilder_SetFragment(IUriBuilder *iface, LPCWSTR pwzNewValue)
 559 {
 560     UriBuilder *This = URIBUILDER_THIS(iface);
 561     FIXME("(%p)->(%s)\n", This, debugstr_w(pwzNewValue));
 562     return E_NOTIMPL;
 563 }
 564
 565 static HRESULT WINAPI UriBuilder_SetHost(IUriBuilder *iface, LPCWSTR pwzNewValue)
 566 {
 567     UriBuilder *This = URIBUILDER_THIS(iface);
 568     FIXME("(%p)->(%s)\n", This, debugstr_w(pwzNewValue));
 569     return E_NOTIMPL;
 570 }
 571
 572 static HRESULT WINAPI UriBuilder_SetPassword(IUriBuilder *iface, LPCWSTR pwzNewValue)
 573 {
 574     UriBuilder *This = URIBUILDER_THIS(iface);
 575     FIXME("(%p)->(%s)\n", This, debugstr_w(pwzNewValue));
 576     return E_NOTIMPL;
 577 }
 578
 579 static HRESULT WINAPI UriBuilder_SetPath(IUriBuilder *iface, LPCWSTR pwzNewValue)
 580 {
 581     UriBuilder *This = URIBUILDER_THIS(iface);
 582     FIXME("(%p)->(%s)\n", This, debugstr_w(pwzNewValue));
 583     return E_NOTIMPL;
 584 }
 585
 586 static HRESULT WINAPI UriBuilder_SetPort(IUriBuilder *iface, BOOL fHasPort, DWORD dwNewValue)
 587 {
 588     UriBuilder *This = URIBUILDER_THIS(iface);
 589     FIXME("(%p)->(%d %d)\n", This, fHasPort, dwNewValue);
 590     return E_NOTIMPL;
 591 }
 592
 593 static HRESULT WINAPI UriBuilder_SetQuery(IUriBuilder *iface, LPCWSTR pwzNewValue)
 594 {
 595     UriBuilder *This = URIBUILDER_THIS(iface);
 596     FIXME("(%p)->(%s)\n", This, debugstr_w(pwzNewValue));
 597     return E_NOTIMPL;
 598 }
 599
 600 static HRESULT WINAPI UriBuilder_SetSchemeName(IUriBuilder *iface, LPCWSTR pwzNewValue)
 601 {
 602     UriBuilder *This = URIBUILDER_THIS(iface);
 603     FIXME("(%p)->(%s)\n", This, debugstr_w(pwzNewValue));
 604     return E_NOTIMPL;
 605 }
 606
 607 static HRESULT WINAPI UriBuilder_SetUserName(IUriBuilder *iface, LPCWSTR pwzNewValue)
 608 {
 609     UriBuilder *This = URIBUILDER_THIS(iface);
 610     FIXME("(%p)->(%s)\n", This, debugstr_w(pwzNewValue));
 611     return E_NOTIMPL;
 612 }
 613
 614 static HRESULT WINAPI UriBuilder_RemoveProperties(IUriBuilder *iface, DWORD dwPropertyMask)
 615 {
 616     UriBuilder *This = URIBUILDER_THIS(iface);
 617     FIXME("(%p)->(0x%08x)\n", This, dwPropertyMask);
 618     return E_NOTIMPL;
 619 }
 620
 621 static HRESULT WINAPI UriBuilder_HasBeenModified(IUriBuilder *iface, BOOL *pfModified)
 622 {
 623     UriBuilder *This = URIBUILDER_THIS(iface);
 624     FIXME("(%p)->(%p)\n", This, pfModified);
 625     return E_NOTIMPL;
 626 }
 627
 628 #undef URIBUILDER_THIS
 629
 630 static const IUriBuilderVtbl UriBuilderVtbl = {
 631     UriBuilder_QueryInterface,
 632     UriBuilder_AddRef,
 633     UriBuilder_Release,
 634     UriBuilder_CreateUriSimple,
 635     UriBuilder_CreateUri,
 636     UriBuilder_CreateUriWithFlags,
 637     UriBuilder_GetIUri,
 638     UriBuilder_SetIUri,
 639     UriBuilder_GetFragment,
 640     UriBuilder_GetHost,
 641     UriBuilder_GetPassword,
 642     UriBuilder_GetPath,
 643     UriBuilder_GetPort,
 644     UriBuilder_GetQuery,
 645     UriBuilder_GetSchemeName,
 646     UriBuilder_GetUserName,
 647     UriBuilder_SetFragment,
 648     UriBuilder_SetHost,
 649     UriBuilder_SetPassword,
 650     UriBuilder_SetPath,
 651     UriBuilder_SetPort,
 652     UriBuilder_SetQuery,
 653     UriBuilder_SetSchemeName,
 654     UriBuilder_SetUserName,
 655     UriBuilder_RemoveProperties,
 656     UriBuilder_HasBeenModified,
 657 };
 658
 659 /***********************************************************************
 660  *           CreateIUriBuilder (urlmon.@)
 661  */
 662 HRESULT WINAPI CreateIUriBuilder(IUri *pIUri, DWORD dwFlags, DWORD_PTR dwReserved, IUriBuilder **ppIUriBuilder)
 663 {
 664     UriBuilder *ret;
 665
 666     TRACE("(%p %x %x %p)\n", pIUri, dwFlags, (DWORD)dwReserved, ppIUriBuilder);
 667
 668     ret = heap_alloc(sizeof(UriBuilder));
 669     if(!ret)
 670         return E_OUTOFMEMORY;
 671
 672     ret->lpIUriBuilderVtbl = &UriBuilderVtbl;
 673     ret->ref = 1;
 674
 675     *ppIUriBuilder = URIBUILDER(ret);
 676     return S_OK;
 677 }