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