?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
advapi32: Don't shadow keychain_item in mac_write_credential.
[wine/multimedia.git] / dlls / scrrun / filesystem.c
blobbfb201cfa572082ab45742ba5dc37bafd4a3b1fc
1 /*
2 * Copyright 2012 Alistair Leslie-Hughes
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 COBJMACROS
20
21 #include "config.h"
22 #include <stdarg.h>
23 #include <limits.h>
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "ole2.h"
28 #include "olectl.h"
29 #include "dispex.h"
30 #include "ntsecapi.h"
31 #include "scrrun.h"
32 #include "scrrun_private.h"
33
34 #include "wine/debug.h"
35 #include "wine/unicode.h"
36
37 WINE_DEFAULT_DEBUG_CHANNEL(scrrun);
38
39 static const WCHAR bsW[] = {'\\',0};
40
41 struct foldercollection {
42 IFolderCollection IFolderCollection_iface;
43 LONG ref;
44 BSTR path;
45 };
46
47 struct filecollection {
48 IFileCollection IFileCollection_iface;
49 LONG ref;
50 BSTR path;
51 };
52
53 struct enumdata {
54 union
55 {
56 struct
57 {
58 struct foldercollection *coll;
59 HANDLE find;
60 } foldercoll;
61 struct
62 {
63 struct filecollection *coll;
64 HANDLE find;
65 } filecoll;
66 } u;
67 };
68
69 struct enumvariant {
70 IEnumVARIANT IEnumVARIANT_iface;
71 LONG ref;
72
73 struct enumdata data;
74 };
75
76 struct folder {
77 IFolder IFolder_iface;
78 LONG ref;
79 BSTR path;
80 };
81
82 struct file {
83 IFile IFile_iface;
84 LONG ref;
85
86 WCHAR *path;
87 };
88
89 struct textstream {
90 ITextStream ITextStream_iface;
91 LONG ref;
92
93 IOMode mode;
94 };
95
96 enum iotype {
97 IORead,
98 IOWrite
99 };
100
101 static inline struct folder *impl_from_IFolder(IFolder *iface)
102 {
103 return CONTAINING_RECORD(iface, struct folder, IFolder_iface);
104 }
105
106 static inline struct file *impl_from_IFile(IFile *iface)
107 {
108 return CONTAINING_RECORD(iface, struct file, IFile_iface);
109 }
110
111 static inline struct textstream *impl_from_ITextStream(ITextStream *iface)
112 {
113 return CONTAINING_RECORD(iface, struct textstream, ITextStream_iface);
114 }
115
116 static inline struct foldercollection *impl_from_IFolderCollection(IFolderCollection *iface)
117 {
118 return CONTAINING_RECORD(iface, struct foldercollection, IFolderCollection_iface);
119 }
120
121 static inline struct filecollection *impl_from_IFileCollection(IFileCollection *iface)
122 {
123 return CONTAINING_RECORD(iface, struct filecollection, IFileCollection_iface);
124 }
125
126 static inline struct enumvariant *impl_from_IEnumVARIANT(IEnumVARIANT *iface)
127 {
128 return CONTAINING_RECORD(iface, struct enumvariant, IEnumVARIANT_iface);
129 }
130
131 static inline HRESULT create_error(DWORD err)
132 {
133 switch(err) {
134 case ERROR_FILE_NOT_FOUND: return CTL_E_FILENOTFOUND;
135 case ERROR_PATH_NOT_FOUND: return CTL_E_PATHNOTFOUND;
136 case ERROR_ACCESS_DENIED: return CTL_E_PERMISSIONDENIED;
137 case ERROR_FILE_EXISTS: return CTL_E_FILEALREADYEXISTS;
138 case ERROR_ALREADY_EXISTS: return CTL_E_FILEALREADYEXISTS;
139 default:
140 FIXME("Unsupported error code: %d\n", err);
141 return E_FAIL;
142 }
143 }
144
145 static HRESULT create_folder(const WCHAR*, IFolder**);
146 static HRESULT create_file(BSTR, IFile**);
147 static HRESULT create_foldercoll_enum(struct foldercollection*, IUnknown**);
148 static HRESULT create_filecoll_enum(struct filecollection*, IUnknown**);
149
150 static inline BOOL is_dir_data(const WIN32_FIND_DATAW *data)
151 {
152 static const WCHAR dotdotW[] = {'.','.',0};
153 static const WCHAR dotW[] = {'.',0};
154
155 return (data->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
156 strcmpW(data->cFileName, dotdotW) &&
157 strcmpW(data->cFileName, dotW);
158 }
159
160 static inline BOOL is_file_data(const WIN32_FIND_DATAW *data)
161 {
162 return !(data->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
163 }
164
165 static BSTR get_full_path(BSTR path, const WIN32_FIND_DATAW *data)
166 {
167 int len = SysStringLen(path);
168 WCHAR buffW[MAX_PATH];
169
170 strcpyW(buffW, path);
171 if (path[len-1] != '\\')
172 strcatW(buffW, bsW);
173 strcatW(buffW, data->cFileName);
174
175 return SysAllocString(buffW);
176 }
177
178 static BOOL textstream_check_iomode(struct textstream *This, enum iotype type)
179 {
180 if (type == IORead)
181 return This->mode == ForWriting || This->mode == ForAppending;
182 else
183 return TRUE;
184 }
185
186 static HRESULT WINAPI textstream_QueryInterface(ITextStream *iface, REFIID riid, void **obj)
187 {
188 struct textstream *This = impl_from_ITextStream(iface);
189
190 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
191
192 if (IsEqualIID(riid, &IID_ITextStream) ||
193 IsEqualIID(riid, &IID_IDispatch) ||
194 IsEqualIID(riid, &IID_IUnknown))
195 {
196 *obj = iface;
197 ITextStream_AddRef(iface);
198 return S_OK;
199 }
200
201 *obj = NULL;
202 return E_NOINTERFACE;
203 }
204
205 static ULONG WINAPI textstream_AddRef(ITextStream *iface)
206 {
207 struct textstream *This = impl_from_ITextStream(iface);
208 ULONG ref = InterlockedIncrement(&This->ref);
209 TRACE("(%p)->(%d)\n", This, ref);
210 return ref;
211 }
212
213 static ULONG WINAPI textstream_Release(ITextStream *iface)
214 {
215 struct textstream *This = impl_from_ITextStream(iface);
216 ULONG ref = InterlockedDecrement(&This->ref);
217 TRACE("(%p)->(%d)\n", This, ref);
218
219 if (!ref)
220 heap_free(This);
221
222 return ref;
223 }
224
225 static HRESULT WINAPI textstream_GetTypeInfoCount(ITextStream *iface, UINT *pctinfo)
226 {
227 struct textstream *This = impl_from_ITextStream(iface);
228 TRACE("(%p)->(%p)\n", This, pctinfo);
229 *pctinfo = 1;
230 return S_OK;
231 }
232
233 static HRESULT WINAPI textstream_GetTypeInfo(ITextStream *iface, UINT iTInfo,
234 LCID lcid, ITypeInfo **ppTInfo)
235 {
236 struct textstream *This = impl_from_ITextStream(iface);
237 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
238 return get_typeinfo(ITextStream_tid, ppTInfo);
239 }
240
241 static HRESULT WINAPI textstream_GetIDsOfNames(ITextStream *iface, REFIID riid,
242 LPOLESTR *rgszNames, UINT cNames,
243 LCID lcid, DISPID *rgDispId)
244 {
245 struct textstream *This = impl_from_ITextStream(iface);
246 ITypeInfo *typeinfo;
247 HRESULT hr;
248
249 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
250
251 hr = get_typeinfo(ITextStream_tid, &typeinfo);
252 if(SUCCEEDED(hr))
253 {
254 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
255 ITypeInfo_Release(typeinfo);
256 }
257
258 return hr;
259 }
260
261 static HRESULT WINAPI textstream_Invoke(ITextStream *iface, DISPID dispIdMember,
262 REFIID riid, LCID lcid, WORD wFlags,
263 DISPPARAMS *pDispParams, VARIANT *pVarResult,
264 EXCEPINFO *pExcepInfo, UINT *puArgErr)
265 {
266 struct textstream *This = impl_from_ITextStream(iface);
267 ITypeInfo *typeinfo;
268 HRESULT hr;
269
270 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
271 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
272
273 hr = get_typeinfo(ITextStream_tid, &typeinfo);
274 if(SUCCEEDED(hr))
275 {
276 hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
277 pDispParams, pVarResult, pExcepInfo, puArgErr);
278 ITypeInfo_Release(typeinfo);
279 }
280
281 return hr;
282 }
283
284 static HRESULT WINAPI textstream_get_Line(ITextStream *iface, LONG *line)
285 {
286 struct textstream *This = impl_from_ITextStream(iface);
287 FIXME("(%p)->(%p): stub\n", This, line);
288 return E_NOTIMPL;
289 }
290
291 static HRESULT WINAPI textstream_get_Column(ITextStream *iface, LONG *column)
292 {
293 struct textstream *This = impl_from_ITextStream(iface);
294 FIXME("(%p)->(%p): stub\n", This, column);
295 return E_NOTIMPL;
296 }
297
298 static HRESULT WINAPI textstream_get_AtEndOfStream(ITextStream *iface, VARIANT_BOOL *eos)
299 {
300 struct textstream *This = impl_from_ITextStream(iface);
301 FIXME("(%p)->(%p): stub\n", This, eos);
302 return E_NOTIMPL;
303 }
304
305 static HRESULT WINAPI textstream_get_AtEndOfLine(ITextStream *iface, VARIANT_BOOL *eol)
306 {
307 struct textstream *This = impl_from_ITextStream(iface);
308 FIXME("(%p)->(%p): stub\n", This, eol);
309 return E_NOTIMPL;
310 }
311
312 static HRESULT WINAPI textstream_Read(ITextStream *iface, LONG len, BSTR *text)
313 {
314 struct textstream *This = impl_from_ITextStream(iface);
315 FIXME("(%p)->(%p): stub\n", This, text);
316
317 if (textstream_check_iomode(This, IORead))
318 return CTL_E_BADFILEMODE;
319
320 return E_NOTIMPL;
321 }
322
323 static HRESULT WINAPI textstream_ReadLine(ITextStream *iface, BSTR *text)
324 {
325 struct textstream *This = impl_from_ITextStream(iface);
326 FIXME("(%p)->(%p): stub\n", This, text);
327
328 if (textstream_check_iomode(This, IORead))
329 return CTL_E_BADFILEMODE;
330
331 return E_NOTIMPL;
332 }
333
334 static HRESULT WINAPI textstream_ReadAll(ITextStream *iface, BSTR *text)
335 {
336 struct textstream *This = impl_from_ITextStream(iface);
337 FIXME("(%p)->(%p): stub\n", This, text);
338
339 if (textstream_check_iomode(This, IORead))
340 return CTL_E_BADFILEMODE;
341
342 return E_NOTIMPL;
343 }
344
345 static HRESULT WINAPI textstream_Write(ITextStream *iface, BSTR text)
346 {
347 struct textstream *This = impl_from_ITextStream(iface);
348 FIXME("(%p)->(%s): stub\n", This, debugstr_w(text));
349 return E_NOTIMPL;
350 }
351
352 static HRESULT WINAPI textstream_WriteLine(ITextStream *iface, BSTR text)
353 {
354 struct textstream *This = impl_from_ITextStream(iface);
355 FIXME("(%p)->(%s): stub\n", This, debugstr_w(text));
356 return E_NOTIMPL;
357 }
358
359 static HRESULT WINAPI textstream_WriteBlankLines(ITextStream *iface, LONG lines)
360 {
361 struct textstream *This = impl_from_ITextStream(iface);
362 FIXME("(%p)->(%d): stub\n", This, lines);
363 return E_NOTIMPL;
364 }
365
366 static HRESULT WINAPI textstream_Skip(ITextStream *iface, LONG count)
367 {
368 struct textstream *This = impl_from_ITextStream(iface);
369 FIXME("(%p)->(%d): stub\n", This, count);
370 return E_NOTIMPL;
371 }
372
373 static HRESULT WINAPI textstream_SkipLine(ITextStream *iface)
374 {
375 struct textstream *This = impl_from_ITextStream(iface);
376 FIXME("(%p): stub\n", This);
377 return E_NOTIMPL;
378 }
379
380 static HRESULT WINAPI textstream_Close(ITextStream *iface)
381 {
382 struct textstream *This = impl_from_ITextStream(iface);
383 FIXME("(%p): stub\n", This);
384 return E_NOTIMPL;
385 }
386
387 static const ITextStreamVtbl textstreamvtbl = {
388 textstream_QueryInterface,
389 textstream_AddRef,
390 textstream_Release,
391 textstream_GetTypeInfoCount,
392 textstream_GetTypeInfo,
393 textstream_GetIDsOfNames,
394 textstream_Invoke,
395 textstream_get_Line,
396 textstream_get_Column,
397 textstream_get_AtEndOfStream,
398 textstream_get_AtEndOfLine,
399 textstream_Read,
400 textstream_ReadLine,
401 textstream_ReadAll,
402 textstream_Write,
403 textstream_WriteLine,
404 textstream_WriteBlankLines,
405 textstream_Skip,
406 textstream_SkipLine,
407 textstream_Close
408 };
409
410 static HRESULT create_textstream(IOMode mode, ITextStream **ret)
411 {
412 struct textstream *stream;
413
414 stream = heap_alloc(sizeof(struct textstream));
415 if (!stream) return E_OUTOFMEMORY;
416
417 stream->ITextStream_iface.lpVtbl = &textstreamvtbl;
418 stream->ref = 1;
419 stream->mode = mode;
420
421 *ret = &stream->ITextStream_iface;
422 return S_OK;
423 }
424
425 static HRESULT WINAPI enumvariant_QueryInterface(IEnumVARIANT *iface, REFIID riid, void **obj)
426 {
427 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
428
429 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
430
431 *obj = NULL;
432
433 if (IsEqualIID( riid, &IID_IEnumVARIANT ) ||
434 IsEqualIID( riid, &IID_IUnknown ))
435 {
436 *obj = iface;
437 IEnumVARIANT_AddRef(iface);
438 }
439 else
440 return E_NOINTERFACE;
441
442 return S_OK;
443 }
444
445 static ULONG WINAPI enumvariant_AddRef(IEnumVARIANT *iface)
446 {
447 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
448 ULONG ref = InterlockedIncrement(&This->ref);
449 TRACE("(%p)->(%d)\n", This, ref);
450 return ref;
451 }
452
453 static ULONG WINAPI foldercoll_enumvariant_Release(IEnumVARIANT *iface)
454 {
455 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
456 ULONG ref = InterlockedDecrement(&This->ref);
457
458 TRACE("(%p)->(%d)\n", This, ref);
459
460 if (!ref)
461 {
462 IFolderCollection_Release(&This->data.u.foldercoll.coll->IFolderCollection_iface);
463 FindClose(This->data.u.foldercoll.find);
464 heap_free(This);
465 }
466
467 return ref;
468 }
469
470 static HRESULT WINAPI foldercoll_enumvariant_Next(IEnumVARIANT *iface, ULONG celt, VARIANT *var, ULONG *fetched)
471 {
472 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
473 HANDLE handle = This->data.u.foldercoll.find;
474 WIN32_FIND_DATAW data;
475 ULONG count = 0;
476
477 TRACE("(%p)->(%d %p %p)\n", This, celt, var, fetched);
478
479 if (fetched)
480 *fetched = 0;
481
482 if (!handle)
483 {
484 static const WCHAR allW[] = {'*',0};
485 WCHAR pathW[MAX_PATH];
486 BSTR parent = This->data.u.foldercoll.coll->path;
487 int len;
488
489 strcpyW(pathW, parent);
490 len = SysStringLen(parent);
491 if (parent[len-1] != '\\')
492 strcatW(pathW, bsW);
493 strcatW(pathW, allW);
494 handle = FindFirstFileW(pathW, &data);
495 if (handle == INVALID_HANDLE_VALUE)
496 return S_FALSE;
497
498 /* find first dir */
499 while (1)
500 {
501 if (is_dir_data(&data))
502 break;
503 else
504 if (!FindNextFileW(handle, &data))
505 {
506 FindClose(handle);
507 return S_FALSE;
508 }
509 }
510
511 This->data.u.foldercoll.find = handle;
512 }
513 else if (celt)
514 FindNextFileW(handle, &data);
515
516 do
517 {
518 if (count >= celt) break;
519
520 if (is_dir_data(&data))
521 {
522 IFolder *folder;
523 HRESULT hr;
524 BSTR str;
525
526 str = get_full_path(This->data.u.foldercoll.coll->path, &data);
527 hr = create_folder(str, &folder);
528 SysFreeString(str);
529 if (FAILED(hr)) return hr;
530
531 V_VT(&var[count]) = VT_DISPATCH;
532 V_DISPATCH(&var[count]) = (IDispatch*)folder;
533 count++;
534 }
535 } while (FindNextFileW(handle, &data));
536
537 if (count < celt)
538 return S_FALSE;
539
540 if (fetched)
541 *fetched = count;
542
543 return S_OK;
544 }
545
546 static HRESULT WINAPI foldercoll_enumvariant_Skip(IEnumVARIANT *iface, ULONG celt)
547 {
548 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
549 HANDLE handle = This->data.u.foldercoll.find;
550 WIN32_FIND_DATAW data;
551
552 TRACE("(%p)->(%d)\n", This, celt);
553
554 while (FindNextFileW(handle, &data) && celt)
555 if (is_dir_data(&data))
556 --celt;
557
558 return celt ? S_FALSE : S_OK;
559 }
560
561 static HRESULT WINAPI foldercoll_enumvariant_Reset(IEnumVARIANT *iface)
562 {
563 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
564
565 TRACE("(%p)\n", This);
566
567 FindClose(This->data.u.foldercoll.find);
568 This->data.u.foldercoll.find = NULL;
569
570 return S_OK;
571 }
572
573 static HRESULT WINAPI foldercoll_enumvariant_Clone(IEnumVARIANT *iface, IEnumVARIANT **pclone)
574 {
575 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
576 TRACE("(%p)->(%p)\n", This, pclone);
577 return create_foldercoll_enum(This->data.u.foldercoll.coll, (IUnknown**)pclone);
578 }
579
580 static const IEnumVARIANTVtbl foldercollenumvariantvtbl = {
581 enumvariant_QueryInterface,
582 enumvariant_AddRef,
583 foldercoll_enumvariant_Release,
584 foldercoll_enumvariant_Next,
585 foldercoll_enumvariant_Skip,
586 foldercoll_enumvariant_Reset,
587 foldercoll_enumvariant_Clone
588 };
589
590 HRESULT create_foldercoll_enum(struct foldercollection *collection, IUnknown **newenum)
591 {
592 struct enumvariant *This;
593
594 *newenum = NULL;
595
596 This = heap_alloc(sizeof(*This));
597 if (!This) return E_OUTOFMEMORY;
598
599 This->IEnumVARIANT_iface.lpVtbl = &foldercollenumvariantvtbl;
600 This->ref = 1;
601 This->data.u.foldercoll.find = NULL;
602 This->data.u.foldercoll.coll = collection;
603 IFolderCollection_AddRef(&collection->IFolderCollection_iface);
604
605 *newenum = (IUnknown*)&This->IEnumVARIANT_iface;
606
607 return S_OK;
608 }
609
610 static ULONG WINAPI filecoll_enumvariant_Release(IEnumVARIANT *iface)
611 {
612 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
613 ULONG ref = InterlockedDecrement(&This->ref);
614
615 TRACE("(%p)->(%d)\n", This, ref);
616
617 if (!ref)
618 {
619 IFileCollection_Release(&This->data.u.filecoll.coll->IFileCollection_iface);
620 heap_free(This);
621 }
622
623 return ref;
624 }
625
626 static HRESULT WINAPI filecoll_enumvariant_Next(IEnumVARIANT *iface, ULONG celt, VARIANT *var, ULONG *fetched)
627 {
628 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
629 HANDLE handle = This->data.u.filecoll.find;
630 WIN32_FIND_DATAW data;
631 ULONG count = 0;
632
633 TRACE("(%p)->(%d %p %p)\n", This, celt, var, fetched);
634
635 if (fetched)
636 *fetched = 0;
637
638 if (!handle)
639 {
640 static const WCHAR allW[] = {'*',0};
641 WCHAR pathW[MAX_PATH];
642 BSTR parent = This->data.u.filecoll.coll->path;
643 int len;
644
645 strcpyW(pathW, parent);
646 len = SysStringLen(parent);
647 if (parent[len-1] != '\\')
648 strcatW(pathW, bsW);
649 strcatW(pathW, allW);
650 handle = FindFirstFileW(pathW, &data);
651 if (handle == INVALID_HANDLE_VALUE)
652 return S_FALSE;
653
654 while (1)
655 {
656 if (is_file_data(&data))
657 break;
658 else
659 if (!FindNextFileW(handle, &data))
660 {
661 FindClose(handle);
662 return S_FALSE;
663 }
664 }
665
666 This->data.u.filecoll.find = handle;
667 }
668 else if (celt)
669 FindNextFileW(handle, &data);
670
671 do
672 {
673 if (count >= celt) break;
674
675 if (is_file_data(&data))
676 {
677 IFile *file;
678 HRESULT hr;
679 BSTR str;
680
681 str = get_full_path(This->data.u.filecoll.coll->path, &data);
682 hr = create_file(str, &file);
683 SysFreeString(str);
684 if (FAILED(hr)) return hr;
685
686 V_VT(&var[count]) = VT_DISPATCH;
687 V_DISPATCH(&var[count]) = (IDispatch*)file;
688 count++;
689 }
690 } while (FindNextFileW(handle, &data));
691
692 if (count < celt)
693 return S_FALSE;
694
695 if (fetched)
696 *fetched = count;
697
698 return S_OK;
699 }
700
701 static HRESULT WINAPI filecoll_enumvariant_Skip(IEnumVARIANT *iface, ULONG celt)
702 {
703 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
704 HANDLE handle = This->data.u.filecoll.find;
705 WIN32_FIND_DATAW data;
706
707 TRACE("(%p)->(%d)\n", This, celt);
708
709 while (FindNextFileW(handle, &data) && celt)
710 if (is_file_data(&data))
711 --celt;
712
713 return celt ? S_FALSE : S_OK;
714 }
715
716 static HRESULT WINAPI filecoll_enumvariant_Reset(IEnumVARIANT *iface)
717 {
718 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
719
720 TRACE("(%p)\n", This);
721
722 FindClose(This->data.u.filecoll.find);
723 This->data.u.filecoll.find = NULL;
724
725 return S_OK;
726 }
727
728 static HRESULT WINAPI filecoll_enumvariant_Clone(IEnumVARIANT *iface, IEnumVARIANT **pclone)
729 {
730 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
731 TRACE("(%p)->(%p)\n", This, pclone);
732 return create_filecoll_enum(This->data.u.filecoll.coll, (IUnknown**)pclone);
733 }
734
735 static const IEnumVARIANTVtbl filecollenumvariantvtbl = {
736 enumvariant_QueryInterface,
737 enumvariant_AddRef,
738 filecoll_enumvariant_Release,
739 filecoll_enumvariant_Next,
740 filecoll_enumvariant_Skip,
741 filecoll_enumvariant_Reset,
742 filecoll_enumvariant_Clone
743 };
744
745 HRESULT create_filecoll_enum(struct filecollection *collection, IUnknown **newenum)
746 {
747 struct enumvariant *This;
748
749 *newenum = NULL;
750
751 This = heap_alloc(sizeof(*This));
752 if (!This) return E_OUTOFMEMORY;
753
754 This->IEnumVARIANT_iface.lpVtbl = &filecollenumvariantvtbl;
755 This->ref = 1;
756 This->data.u.filecoll.coll = collection;
757 IFileCollection_AddRef(&collection->IFileCollection_iface);
758
759 *newenum = (IUnknown*)&This->IEnumVARIANT_iface;
760
761 return S_OK;
762 }
763
764 static HRESULT WINAPI foldercoll_QueryInterface(IFolderCollection *iface, REFIID riid, void **obj)
765 {
766 struct foldercollection *This = impl_from_IFolderCollection(iface);
767
768 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
769
770 *obj = NULL;
771
772 if (IsEqualIID( riid, &IID_IFolderCollection ) ||
773 IsEqualIID( riid, &IID_IDispatch ) ||
774 IsEqualIID( riid, &IID_IUnknown ))
775 {
776 *obj = iface;
777 IFolderCollection_AddRef(iface);
778 }
779 else
780 return E_NOINTERFACE;
781
782 return S_OK;
783 }
784
785 static ULONG WINAPI foldercoll_AddRef(IFolderCollection *iface)
786 {
787 struct foldercollection *This = impl_from_IFolderCollection(iface);
788 ULONG ref = InterlockedIncrement(&This->ref);
789 TRACE("(%p)->(%d)\n", This, ref);
790 return ref;
791 }
792
793 static ULONG WINAPI foldercoll_Release(IFolderCollection *iface)
794 {
795 struct foldercollection *This = impl_from_IFolderCollection(iface);
796 ULONG ref = InterlockedDecrement(&This->ref);
797 TRACE("(%p)->(%d)\n", This, ref);
798
799 if (!ref)
800 {
801 SysFreeString(This->path);
802 heap_free(This);
803 }
804
805 return ref;
806 }
807
808 static HRESULT WINAPI foldercoll_GetTypeInfoCount(IFolderCollection *iface, UINT *pctinfo)
809 {
810 struct foldercollection *This = impl_from_IFolderCollection(iface);
811 TRACE("(%p)->(%p)\n", This, pctinfo);
812 *pctinfo = 1;
813 return S_OK;
814 }
815
816 static HRESULT WINAPI foldercoll_GetTypeInfo(IFolderCollection *iface, UINT iTInfo,
817 LCID lcid, ITypeInfo **ppTInfo)
818 {
819 struct foldercollection *This = impl_from_IFolderCollection(iface);
820 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
821 return get_typeinfo(IFolderCollection_tid, ppTInfo);
822 }
823
824 static HRESULT WINAPI foldercoll_GetIDsOfNames(IFolderCollection *iface, REFIID riid,
825 LPOLESTR *rgszNames, UINT cNames,
826 LCID lcid, DISPID *rgDispId)
827 {
828 struct foldercollection *This = impl_from_IFolderCollection(iface);
829 ITypeInfo *typeinfo;
830 HRESULT hr;
831
832 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
833
834 hr = get_typeinfo(IFolderCollection_tid, &typeinfo);
835 if(SUCCEEDED(hr))
836 {
837 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
838 ITypeInfo_Release(typeinfo);
839 }
840
841 return hr;
842 }
843
844 static HRESULT WINAPI foldercoll_Invoke(IFolderCollection *iface, DISPID dispIdMember,
845 REFIID riid, LCID lcid, WORD wFlags,
846 DISPPARAMS *pDispParams, VARIANT *pVarResult,
847 EXCEPINFO *pExcepInfo, UINT *puArgErr)
848 {
849 struct foldercollection *This = impl_from_IFolderCollection(iface);
850 ITypeInfo *typeinfo;
851 HRESULT hr;
852
853 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
854 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
855
856 hr = get_typeinfo(IFolderCollection_tid, &typeinfo);
857 if(SUCCEEDED(hr))
858 {
859 hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
860 pDispParams, pVarResult, pExcepInfo, puArgErr);
861 ITypeInfo_Release(typeinfo);
862 }
863
864 return hr;
865 }
866
867 static HRESULT WINAPI foldercoll_Add(IFolderCollection *iface, BSTR name, IFolder **folder)
868 {
869 struct foldercollection *This = impl_from_IFolderCollection(iface);
870 FIXME("(%p)->(%s %p): stub\n", This, debugstr_w(name), folder);
871 return E_NOTIMPL;
872 }
873
874 static HRESULT WINAPI foldercoll_get_Item(IFolderCollection *iface, VARIANT key, IFolder **folder)
875 {
876 struct foldercollection *This = impl_from_IFolderCollection(iface);
877 FIXME("(%p)->(%p): stub\n", This, folder);
878 return E_NOTIMPL;
879 }
880
881 static HRESULT WINAPI foldercoll_get__NewEnum(IFolderCollection *iface, IUnknown **newenum)
882 {
883 struct foldercollection *This = impl_from_IFolderCollection(iface);
884
885 TRACE("(%p)->(%p)\n", This, newenum);
886
887 if(!newenum)
888 return E_POINTER;
889
890 return create_foldercoll_enum(This, newenum);
891 }
892
893 static HRESULT WINAPI foldercoll_get_Count(IFolderCollection *iface, LONG *count)
894 {
895 struct foldercollection *This = impl_from_IFolderCollection(iface);
896 static const WCHAR allW[] = {'\\','*',0};
897 WIN32_FIND_DATAW data;
898 WCHAR pathW[MAX_PATH];
899 HANDLE handle;
900
901 TRACE("(%p)->(%p)\n", This, count);
902
903 if(!count)
904 return E_POINTER;
905
906 *count = 0;
907
908 strcpyW(pathW, This->path);
909 strcatW(pathW, allW);
910 handle = FindFirstFileW(pathW, &data);
911 if (handle == INVALID_HANDLE_VALUE)
912 return HRESULT_FROM_WIN32(GetLastError());
913
914 do
915 {
916 if (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
917 *count += 1;
918 } while (FindNextFileW(handle, &data));
919 FindClose(handle);
920
921 return S_OK;
922 }
923
924 static const IFolderCollectionVtbl foldercollvtbl = {
925 foldercoll_QueryInterface,
926 foldercoll_AddRef,
927 foldercoll_Release,
928 foldercoll_GetTypeInfoCount,
929 foldercoll_GetTypeInfo,
930 foldercoll_GetIDsOfNames,
931 foldercoll_Invoke,
932 foldercoll_Add,
933 foldercoll_get_Item,
934 foldercoll_get__NewEnum,
935 foldercoll_get_Count
936 };
937
938 static HRESULT create_foldercoll(BSTR path, IFolderCollection **folders)
939 {
940 struct foldercollection *This;
941
942 *folders = NULL;
943
944 This = heap_alloc(sizeof(struct foldercollection));
945 if (!This) return E_OUTOFMEMORY;
946
947 This->IFolderCollection_iface.lpVtbl = &foldercollvtbl;
948 This->ref = 1;
949 This->path = SysAllocString(path);
950 if (!This->path)
951 {
952 heap_free(This);
953 return E_OUTOFMEMORY;
954 }
955
956 *folders = &This->IFolderCollection_iface;
957
958 return S_OK;
959 }
960
961 static HRESULT WINAPI filecoll_QueryInterface(IFileCollection *iface, REFIID riid, void **obj)
962 {
963 struct filecollection *This = impl_from_IFileCollection(iface);
964
965 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
966
967 *obj = NULL;
968
969 if (IsEqualIID( riid, &IID_IFileCollection ) ||
970 IsEqualIID( riid, &IID_IDispatch ) ||
971 IsEqualIID( riid, &IID_IUnknown ))
972 {
973 *obj = iface;
974 IFileCollection_AddRef(iface);
975 }
976 else
977 return E_NOINTERFACE;
978
979 return S_OK;
980 }
981
982 static ULONG WINAPI filecoll_AddRef(IFileCollection *iface)
983 {
984 struct filecollection *This = impl_from_IFileCollection(iface);
985 ULONG ref = InterlockedIncrement(&This->ref);
986 TRACE("(%p)->(%d)\n", This, ref);
987 return ref;
988 }
989
990 static ULONG WINAPI filecoll_Release(IFileCollection *iface)
991 {
992 struct filecollection *This = impl_from_IFileCollection(iface);
993 ULONG ref = InterlockedDecrement(&This->ref);
994 TRACE("(%p)->(%d)\n", This, ref);
995
996 if (!ref)
997 {
998 SysFreeString(This->path);
999 heap_free(This);
1000 }
1001
1002 return ref;
1003 }
1004
1005 static HRESULT WINAPI filecoll_GetTypeInfoCount(IFileCollection *iface, UINT *pctinfo)
1006 {
1007 struct filecollection *This = impl_from_IFileCollection(iface);
1008 TRACE("(%p)->(%p)\n", This, pctinfo);
1009 *pctinfo = 1;
1010 return S_OK;
1011 }
1012
1013 static HRESULT WINAPI filecoll_GetTypeInfo(IFileCollection *iface, UINT iTInfo,
1014 LCID lcid, ITypeInfo **ppTInfo)
1015 {
1016 struct filecollection *This = impl_from_IFileCollection(iface);
1017 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1018 return get_typeinfo(IFileCollection_tid, ppTInfo);
1019 }
1020
1021 static HRESULT WINAPI filecoll_GetIDsOfNames(IFileCollection *iface, REFIID riid,
1022 LPOLESTR *rgszNames, UINT cNames,
1023 LCID lcid, DISPID *rgDispId)
1024 {
1025 struct filecollection *This = impl_from_IFileCollection(iface);
1026 ITypeInfo *typeinfo;
1027 HRESULT hr;
1028
1029 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
1030
1031 hr = get_typeinfo(IFileCollection_tid, &typeinfo);
1032 if(SUCCEEDED(hr))
1033 {
1034 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1035 ITypeInfo_Release(typeinfo);
1036 }
1037
1038 return hr;
1039 }
1040
1041 static HRESULT WINAPI filecoll_Invoke(IFileCollection *iface, DISPID dispIdMember,
1042 REFIID riid, LCID lcid, WORD wFlags,
1043 DISPPARAMS *pDispParams, VARIANT *pVarResult,
1044 EXCEPINFO *pExcepInfo, UINT *puArgErr)
1045 {
1046 struct filecollection *This = impl_from_IFileCollection(iface);
1047 ITypeInfo *typeinfo;
1048 HRESULT hr;
1049
1050 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1051 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1052
1053 hr = get_typeinfo(IFileCollection_tid, &typeinfo);
1054 if(SUCCEEDED(hr))
1055 {
1056 hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
1057 pDispParams, pVarResult, pExcepInfo, puArgErr);
1058 ITypeInfo_Release(typeinfo);
1059 }
1060
1061 return hr;
1062 }
1063
1064 static HRESULT WINAPI filecoll_get_Item(IFileCollection *iface, VARIANT Key, IFile **file)
1065 {
1066 struct filecollection *This = impl_from_IFileCollection(iface);
1067 FIXME("(%p)->(%p)\n", This, file);
1068 return E_NOTIMPL;
1069 }
1070
1071 static HRESULT WINAPI filecoll_get__NewEnum(IFileCollection *iface, IUnknown **ppenum)
1072 {
1073 struct filecollection *This = impl_from_IFileCollection(iface);
1074
1075 TRACE("(%p)->(%p)\n", This, ppenum);
1076
1077 if(!ppenum)
1078 return E_POINTER;
1079
1080 return create_filecoll_enum(This, ppenum);
1081 }
1082
1083 static HRESULT WINAPI filecoll_get_Count(IFileCollection *iface, LONG *count)
1084 {
1085 struct filecollection *This = impl_from_IFileCollection(iface);
1086 FIXME("(%p)->(%p)\n", This, count);
1087 return E_NOTIMPL;
1088 }
1089
1090 static const IFileCollectionVtbl filecollectionvtbl = {
1091 filecoll_QueryInterface,
1092 filecoll_AddRef,
1093 filecoll_Release,
1094 filecoll_GetTypeInfoCount,
1095 filecoll_GetTypeInfo,
1096 filecoll_GetIDsOfNames,
1097 filecoll_Invoke,
1098 filecoll_get_Item,
1099 filecoll_get__NewEnum,
1100 filecoll_get_Count
1101 };
1102
1103 static HRESULT create_filecoll(BSTR path, IFileCollection **files)
1104 {
1105 struct filecollection *This;
1106
1107 *files = NULL;
1108
1109 This = heap_alloc(sizeof(*This));
1110 if (!This) return E_OUTOFMEMORY;
1111
1112 This->IFileCollection_iface.lpVtbl = &filecollectionvtbl;
1113 This->ref = 1;
1114 This->path = SysAllocString(path);
1115 if (!This->path)
1116 {
1117 heap_free(This);
1118 return E_OUTOFMEMORY;
1119 }
1120
1121 *files = &This->IFileCollection_iface;
1122 return S_OK;
1123 }
1124
1125 static HRESULT WINAPI folder_QueryInterface(IFolder *iface, REFIID riid, void **obj)
1126 {
1127 struct folder *This = impl_from_IFolder(iface);
1128
1129 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
1130
1131 *obj = NULL;
1132
1133 if (IsEqualIID( riid, &IID_IFolder ) ||
1134 IsEqualIID( riid, &IID_IDispatch ) ||
1135 IsEqualIID( riid, &IID_IUnknown))
1136 {
1137 *obj = iface;
1138 IFolder_AddRef(iface);
1139 }
1140 else
1141 return E_NOINTERFACE;
1142
1143 return S_OK;
1144 }
1145
1146 static ULONG WINAPI folder_AddRef(IFolder *iface)
1147 {
1148 struct folder *This = impl_from_IFolder(iface);
1149 ULONG ref = InterlockedIncrement(&This->ref);
1150 TRACE("(%p)->(%d)\n", This, ref);
1151 return ref;
1152 }
1153
1154 static ULONG WINAPI folder_Release(IFolder *iface)
1155 {
1156 struct folder *This = impl_from_IFolder(iface);
1157 ULONG ref = InterlockedDecrement(&This->ref);
1158 TRACE("(%p)->(%d)\n", This, ref);
1159
1160 if (!ref)
1161 {
1162 SysFreeString(This->path);
1163 heap_free(This);
1164 }
1165
1166 return ref;
1167 }
1168
1169 static HRESULT WINAPI folder_GetTypeInfoCount(IFolder *iface, UINT *pctinfo)
1170 {
1171 struct folder *This = impl_from_IFolder(iface);
1172 TRACE("(%p)->(%p)\n", This, pctinfo);
1173 *pctinfo = 1;
1174 return S_OK;
1175 }
1176
1177 static HRESULT WINAPI folder_GetTypeInfo(IFolder *iface, UINT iTInfo,
1178 LCID lcid, ITypeInfo **ppTInfo)
1179 {
1180 struct folder *This = impl_from_IFolder(iface);
1181 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1182 return get_typeinfo(IFolder_tid, ppTInfo);
1183 }
1184
1185 static HRESULT WINAPI folder_GetIDsOfNames(IFolder *iface, REFIID riid,
1186 LPOLESTR *rgszNames, UINT cNames,
1187 LCID lcid, DISPID *rgDispId)
1188 {
1189 struct folder *This = impl_from_IFolder(iface);
1190 ITypeInfo *typeinfo;
1191 HRESULT hr;
1192
1193 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
1194
1195 hr = get_typeinfo(IFolder_tid, &typeinfo);
1196 if(SUCCEEDED(hr))
1197 {
1198 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1199 ITypeInfo_Release(typeinfo);
1200 }
1201
1202 return hr;
1203 }
1204
1205 static HRESULT WINAPI folder_Invoke(IFolder *iface, DISPID dispIdMember,
1206 REFIID riid, LCID lcid, WORD wFlags,
1207 DISPPARAMS *pDispParams, VARIANT *pVarResult,
1208 EXCEPINFO *pExcepInfo, UINT *puArgErr)
1209 {
1210 struct folder *This = impl_from_IFolder(iface);
1211 ITypeInfo *typeinfo;
1212 HRESULT hr;
1213
1214 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1215 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1216
1217 hr = get_typeinfo(IFolder_tid, &typeinfo);
1218 if(SUCCEEDED(hr))
1219 {
1220 hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
1221 pDispParams, pVarResult, pExcepInfo, puArgErr);
1222 ITypeInfo_Release(typeinfo);
1223 }
1224
1225 return hr;
1226 }
1227
1228 static HRESULT WINAPI folder_get_Path(IFolder *iface, BSTR *path)
1229 {
1230 struct folder *This = impl_from_IFolder(iface);
1231 FIXME("(%p)->(%p): stub\n", This, path);
1232 return E_NOTIMPL;
1233 }
1234
1235 static HRESULT WINAPI folder_get_Name(IFolder *iface, BSTR *name)
1236 {
1237 struct folder *This = impl_from_IFolder(iface);
1238 WCHAR *ptr;
1239
1240 TRACE("(%p)->(%p)\n", This, name);
1241
1242 if(!name)
1243 return E_POINTER;
1244
1245 *name = NULL;
1246
1247 ptr = strrchrW(This->path, '\\');
1248 if (ptr)
1249 {
1250 *name = SysAllocString(ptr+1);
1251 TRACE("%s\n", debugstr_w(*name));
1252 if (!*name) return E_OUTOFMEMORY;
1253 }
1254 else
1255 return E_FAIL;
1256
1257 return S_OK;
1258 }
1259
1260 static HRESULT WINAPI folder_put_Name(IFolder *iface, BSTR name)
1261 {
1262 struct folder *This = impl_from_IFolder(iface);
1263 FIXME("(%p)->(%s): stub\n", This, debugstr_w(name));
1264 return E_NOTIMPL;
1265 }
1266
1267 static HRESULT WINAPI folder_get_ShortPath(IFolder *iface, BSTR *path)
1268 {
1269 struct folder *This = impl_from_IFolder(iface);
1270 FIXME("(%p)->(%p): stub\n", This, path);
1271 return E_NOTIMPL;
1272 }
1273
1274 static HRESULT WINAPI folder_get_ShortName(IFolder *iface, BSTR *name)
1275 {
1276 struct folder *This = impl_from_IFolder(iface);
1277 FIXME("(%p)->(%p): stub\n", This, name);
1278 return E_NOTIMPL;
1279 }
1280
1281 static HRESULT WINAPI folder_get_Drive(IFolder *iface, IDrive **drive)
1282 {
1283 struct folder *This = impl_from_IFolder(iface);
1284 FIXME("(%p)->(%p): stub\n", This, drive);
1285 return E_NOTIMPL;
1286 }
1287
1288 static HRESULT WINAPI folder_get_ParentFolder(IFolder *iface, IFolder **parent)
1289 {
1290 struct folder *This = impl_from_IFolder(iface);
1291 FIXME("(%p)->(%p): stub\n", This, parent);
1292 return E_NOTIMPL;
1293 }
1294
1295 static HRESULT WINAPI folder_get_Attributes(IFolder *iface, FileAttribute *attr)
1296 {
1297 struct folder *This = impl_from_IFolder(iface);
1298 FIXME("(%p)->(%p): stub\n", This, attr);
1299 return E_NOTIMPL;
1300 }
1301
1302 static HRESULT WINAPI folder_put_Attributes(IFolder *iface, FileAttribute attr)
1303 {
1304 struct folder *This = impl_from_IFolder(iface);
1305 FIXME("(%p)->(0x%x): stub\n", This, attr);
1306 return E_NOTIMPL;
1307 }
1308
1309 static HRESULT WINAPI folder_get_DateCreated(IFolder *iface, DATE *date)
1310 {
1311 struct folder *This = impl_from_IFolder(iface);
1312 FIXME("(%p)->(%p): stub\n", This, date);
1313 return E_NOTIMPL;
1314 }
1315
1316 static HRESULT WINAPI folder_get_DateLastModified(IFolder *iface, DATE *date)
1317 {
1318 struct folder *This = impl_from_IFolder(iface);
1319 FIXME("(%p)->(%p): stub\n", This, date);
1320 return E_NOTIMPL;
1321 }
1322
1323 static HRESULT WINAPI folder_get_DateLastAccessed(IFolder *iface, DATE *date)
1324 {
1325 struct folder *This = impl_from_IFolder(iface);
1326 FIXME("(%p)->(%p): stub\n", This, date);
1327 return E_NOTIMPL;
1328 }
1329
1330 static HRESULT WINAPI folder_get_Type(IFolder *iface, BSTR *type)
1331 {
1332 struct folder *This = impl_from_IFolder(iface);
1333 FIXME("(%p)->(%p): stub\n", This, type);
1334 return E_NOTIMPL;
1335 }
1336
1337 static HRESULT WINAPI folder_Delete(IFolder *iface, VARIANT_BOOL force)
1338 {
1339 struct folder *This = impl_from_IFolder(iface);
1340 FIXME("(%p)->(%x): stub\n", This, force);
1341 return E_NOTIMPL;
1342 }
1343
1344 static HRESULT WINAPI folder_Copy(IFolder *iface, BSTR dest, VARIANT_BOOL overwrite)
1345 {
1346 struct folder *This = impl_from_IFolder(iface);
1347 FIXME("(%p)->(%s %x): stub\n", This, debugstr_w(dest), overwrite);
1348 return E_NOTIMPL;
1349 }
1350
1351 static HRESULT WINAPI folder_Move(IFolder *iface, BSTR dest)
1352 {
1353 struct folder *This = impl_from_IFolder(iface);
1354 FIXME("(%p)->(%s): stub\n", This, debugstr_w(dest));
1355 return E_NOTIMPL;
1356 }
1357
1358 static HRESULT WINAPI folder_get_IsRootFolder(IFolder *iface, VARIANT_BOOL *isroot)
1359 {
1360 struct folder *This = impl_from_IFolder(iface);
1361 FIXME("(%p)->(%p): stub\n", This, isroot);
1362 return E_NOTIMPL;
1363 }
1364
1365 static HRESULT WINAPI folder_get_Size(IFolder *iface, VARIANT *size)
1366 {
1367 struct folder *This = impl_from_IFolder(iface);
1368 FIXME("(%p)->(%p): stub\n", This, size);
1369 return E_NOTIMPL;
1370 }
1371
1372 static HRESULT WINAPI folder_get_SubFolders(IFolder *iface, IFolderCollection **folders)
1373 {
1374 struct folder *This = impl_from_IFolder(iface);
1375
1376 TRACE("(%p)->(%p)\n", This, folders);
1377
1378 if(!folders)
1379 return E_POINTER;
1380
1381 return create_foldercoll(This->path, folders);
1382 }
1383
1384 static HRESULT WINAPI folder_get_Files(IFolder *iface, IFileCollection **files)
1385 {
1386 struct folder *This = impl_from_IFolder(iface);
1387
1388 TRACE("(%p)->(%p)\n", This, files);
1389
1390 if(!files)
1391 return E_POINTER;
1392
1393 return create_filecoll(This->path, files);
1394 }
1395
1396 static HRESULT WINAPI folder_CreateTextFile(IFolder *iface, BSTR filename, VARIANT_BOOL overwrite,
1397 VARIANT_BOOL unicode, ITextStream **stream)
1398 {
1399 struct folder *This = impl_from_IFolder(iface);
1400 FIXME("(%p)->(%s %x %x %p): stub\n", This, debugstr_w(filename), overwrite, unicode, stream);
1401 return E_NOTIMPL;
1402 }
1403
1404 static const IFolderVtbl foldervtbl = {
1405 folder_QueryInterface,
1406 folder_AddRef,
1407 folder_Release,
1408 folder_GetTypeInfoCount,
1409 folder_GetTypeInfo,
1410 folder_GetIDsOfNames,
1411 folder_Invoke,
1412 folder_get_Path,
1413 folder_get_Name,
1414 folder_put_Name,
1415 folder_get_ShortPath,
1416 folder_get_ShortName,
1417 folder_get_Drive,
1418 folder_get_ParentFolder,
1419 folder_get_Attributes,
1420 folder_put_Attributes,
1421 folder_get_DateCreated,
1422 folder_get_DateLastModified,
1423 folder_get_DateLastAccessed,
1424 folder_get_Type,
1425 folder_Delete,
1426 folder_Copy,
1427 folder_Move,
1428 folder_get_IsRootFolder,
1429 folder_get_Size,
1430 folder_get_SubFolders,
1431 folder_get_Files,
1432 folder_CreateTextFile
1433 };
1434
1435 HRESULT create_folder(const WCHAR *path, IFolder **folder)
1436 {
1437 struct folder *This;
1438
1439 *folder = NULL;
1440
1441 TRACE("%s\n", debugstr_w(path));
1442
1443 This = heap_alloc(sizeof(struct folder));
1444 if (!This) return E_OUTOFMEMORY;
1445
1446 This->IFolder_iface.lpVtbl = &foldervtbl;
1447 This->ref = 1;
1448 This->path = SysAllocString(path);
1449 if (!This->path)
1450 {
1451 heap_free(This);
1452 return E_OUTOFMEMORY;
1453 }
1454
1455 *folder = &This->IFolder_iface;
1456
1457 return S_OK;
1458 }
1459
1460 static HRESULT WINAPI file_QueryInterface(IFile *iface, REFIID riid, void **obj)
1461 {
1462 struct file *This = impl_from_IFile(iface);
1463
1464 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
1465
1466 if (IsEqualIID(riid, &IID_IFile) ||
1467 IsEqualIID(riid, &IID_IDispatch) ||
1468 IsEqualIID(riid, &IID_IUnknown))
1469 {
1470 *obj = iface;
1471 IFile_AddRef(iface);
1472 return S_OK;
1473 }
1474
1475 *obj = NULL;
1476 return E_NOINTERFACE;
1477 }
1478
1479 static ULONG WINAPI file_AddRef(IFile *iface)
1480 {
1481 struct file *This = impl_from_IFile(iface);
1482 LONG ref = InterlockedIncrement(&This->ref);
1483
1484 TRACE("(%p) ref=%d\n", This, ref);
1485
1486 return ref;
1487 }
1488
1489 static ULONG WINAPI file_Release(IFile *iface)
1490 {
1491 struct file *This = impl_from_IFile(iface);
1492 LONG ref = InterlockedDecrement(&This->ref);
1493
1494 TRACE("(%p) ref=%d\n", This, ref);
1495
1496 if(!ref)
1497 heap_free(This->path);
1498
1499 return ref;
1500 }
1501
1502 static HRESULT WINAPI file_GetTypeInfoCount(IFile *iface, UINT *pctinfo)
1503 {
1504 struct file *This = impl_from_IFile(iface);
1505
1506 TRACE("(%p)->(%p)\n", This, pctinfo);
1507
1508 *pctinfo = 1;
1509 return S_OK;
1510 }
1511
1512 static HRESULT WINAPI file_GetTypeInfo(IFile *iface,
1513 UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
1514 {
1515 struct file *This = impl_from_IFile(iface);
1516
1517 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1518
1519 return get_typeinfo(IFile_tid, ppTInfo);
1520 }
1521
1522 static HRESULT WINAPI file_GetIDsOfNames(IFile *iface, REFIID riid,
1523 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1524 {
1525 struct file *This = impl_from_IFile(iface);
1526 ITypeInfo *typeinfo;
1527 HRESULT hr;
1528
1529 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid),
1530 rgszNames, cNames, lcid, rgDispId);
1531
1532 hr = get_typeinfo(IFile_tid, &typeinfo);
1533 if(SUCCEEDED(hr)) {
1534 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1535 ITypeInfo_Release(typeinfo);
1536 }
1537 return hr;
1538 }
1539
1540 static HRESULT WINAPI file_Invoke(IFile *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1541 {
1542 struct file *This = impl_from_IFile(iface);
1543 ITypeInfo *typeinfo;
1544 HRESULT hr;
1545
1546 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1547 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1548
1549 hr = get_typeinfo(IFile_tid, &typeinfo);
1550 if(SUCCEEDED(hr))
1551 {
1552 hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
1553 pDispParams, pVarResult, pExcepInfo, puArgErr);
1554 ITypeInfo_Release(typeinfo);
1555 }
1556 return hr;
1557 }
1558
1559 static HRESULT WINAPI file_get_Path(IFile *iface, BSTR *pbstrPath)
1560 {
1561 struct file *This = impl_from_IFile(iface);
1562 FIXME("(%p)->(%p)\n", This, pbstrPath);
1563 return E_NOTIMPL;
1564 }
1565
1566 static HRESULT WINAPI file_get_Name(IFile *iface, BSTR *name)
1567 {
1568 struct file *This = impl_from_IFile(iface);
1569 WCHAR *ptr;
1570
1571 TRACE("(%p)->(%p)\n", This, name);
1572
1573 if(!name)
1574 return E_POINTER;
1575
1576 *name = NULL;
1577
1578 ptr = strrchrW(This->path, '\\');
1579 if (ptr)
1580 {
1581 *name = SysAllocString(ptr+1);
1582 TRACE("%s\n", debugstr_w(*name));
1583 if (!*name) return E_OUTOFMEMORY;
1584 }
1585 else
1586 return E_FAIL;
1587
1588 return S_OK;
1589 }
1590
1591 static HRESULT WINAPI file_put_Name(IFile *iface, BSTR pbstrName)
1592 {
1593 struct file *This = impl_from_IFile(iface);
1594 FIXME("(%p)->(%s)\n", This, debugstr_w(pbstrName));
1595 return E_NOTIMPL;
1596 }
1597
1598 static HRESULT WINAPI file_get_ShortPath(IFile *iface, BSTR *pbstrPath)
1599 {
1600 struct file *This = impl_from_IFile(iface);
1601 FIXME("(%p)->(%p)\n", This, pbstrPath);
1602 return E_NOTIMPL;
1603 }
1604
1605 static HRESULT WINAPI file_get_ShortName(IFile *iface, BSTR *pbstrName)
1606 {
1607 struct file *This = impl_from_IFile(iface);
1608 FIXME("(%p)->(%p)\n", This, pbstrName);
1609 return E_NOTIMPL;
1610 }
1611
1612 static HRESULT WINAPI file_get_Drive(IFile *iface, IDrive **ppdrive)
1613 {
1614 struct file *This = impl_from_IFile(iface);
1615 FIXME("(%p)->(%p)\n", This, ppdrive);
1616 return E_NOTIMPL;
1617 }
1618
1619 static HRESULT WINAPI file_get_ParentFolder(IFile *iface, IFolder **ppfolder)
1620 {
1621 struct file *This = impl_from_IFile(iface);
1622 FIXME("(%p)->(%p)\n", This, ppfolder);
1623 return E_NOTIMPL;
1624 }
1625
1626 static HRESULT WINAPI file_get_Attributes(IFile *iface, FileAttribute *pfa)
1627 {
1628 struct file *This = impl_from_IFile(iface);
1629 DWORD fa;
1630
1631 TRACE("(%p)->(%p)\n", This, pfa);
1632
1633 if(!pfa)
1634 return E_POINTER;
1635
1636 fa = GetFileAttributesW(This->path);
1637 if(fa == INVALID_FILE_ATTRIBUTES)
1638 return create_error(GetLastError());
1639
1640 *pfa = fa & (FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN |
1641 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_ARCHIVE |
1642 FILE_ATTRIBUTE_REPARSE_POINT | FILE_ATTRIBUTE_COMPRESSED);
1643 return S_OK;
1644 }
1645
1646 static HRESULT WINAPI file_put_Attributes(IFile *iface, FileAttribute pfa)
1647 {
1648 struct file *This = impl_from_IFile(iface);
1649 FIXME("(%p)->(%x)\n", This, pfa);
1650 return E_NOTIMPL;
1651 }
1652
1653 static HRESULT WINAPI file_get_DateCreated(IFile *iface, DATE *pdate)
1654 {
1655 struct file *This = impl_from_IFile(iface);
1656 FIXME("(%p)->(%p)\n", This, pdate);
1657 return E_NOTIMPL;
1658 }
1659
1660 static HRESULT WINAPI file_get_DateLastModified(IFile *iface, DATE *pdate)
1661 {
1662 struct file *This = impl_from_IFile(iface);
1663 FIXME("(%p)->(%p)\n", This, pdate);
1664 return E_NOTIMPL;
1665 }
1666
1667 static HRESULT WINAPI file_get_DateLastAccessed(IFile *iface, DATE *pdate)
1668 {
1669 struct file *This = impl_from_IFile(iface);
1670 FIXME("(%p)->(%p)\n", This, pdate);
1671 return E_NOTIMPL;
1672 }
1673
1674 static HRESULT WINAPI file_get_Size(IFile *iface, VARIANT *pvarSize)
1675 {
1676 struct file *This = impl_from_IFile(iface);
1677 WIN32_FIND_DATAW fd;
1678 HANDLE f;
1679
1680 TRACE("(%p)->(%p)\n", This, pvarSize);
1681
1682 if(!pvarSize)
1683 return E_POINTER;
1684
1685 f = FindFirstFileW(This->path, &fd);
1686 if(f == INVALID_HANDLE_VALUE)
1687 return create_error(GetLastError());
1688 FindClose(f);
1689
1690 if(fd.nFileSizeHigh || fd.nFileSizeLow>INT_MAX) {
1691 V_VT(pvarSize) = VT_R8;
1692 V_R8(pvarSize) = ((ULONGLONG)fd.nFileSizeHigh<<32) + fd.nFileSizeLow;
1693 }else {
1694 V_VT(pvarSize) = VT_I4;
1695 V_I4(pvarSize) = fd.nFileSizeLow;
1696 }
1697 return S_OK;
1698 }
1699
1700 static HRESULT WINAPI file_get_Type(IFile *iface, BSTR *pbstrType)
1701 {
1702 struct file *This = impl_from_IFile(iface);
1703 FIXME("(%p)->(%p)\n", This, pbstrType);
1704 return E_NOTIMPL;
1705 }
1706
1707 static HRESULT WINAPI file_Delete(IFile *iface, VARIANT_BOOL Force)
1708 {
1709 struct file *This = impl_from_IFile(iface);
1710 FIXME("(%p)->(%x)\n", This, Force);
1711 return E_NOTIMPL;
1712 }
1713
1714 static HRESULT WINAPI file_Copy(IFile *iface, BSTR Destination, VARIANT_BOOL OverWriteFiles)
1715 {
1716 struct file *This = impl_from_IFile(iface);
1717 FIXME("(%p)->(%s %x)\n", This, debugstr_w(Destination), OverWriteFiles);
1718 return E_NOTIMPL;
1719 }
1720
1721 static HRESULT WINAPI file_Move(IFile *iface, BSTR Destination)
1722 {
1723 struct file *This = impl_from_IFile(iface);
1724 FIXME("(%p)->(%s)\n", This, debugstr_w(Destination));
1725 return E_NOTIMPL;
1726 }
1727
1728 static HRESULT WINAPI file_OpenAsTextStream(IFile *iface, IOMode IOMode, Tristate Format, ITextStream **ppts)
1729 {
1730 struct file *This = impl_from_IFile(iface);
1731 FIXME("(%p)->(%x %x %p)\n", This, IOMode, Format, ppts);
1732 return E_NOTIMPL;
1733 }
1734
1735 static const IFileVtbl file_vtbl = {
1736 file_QueryInterface,
1737 file_AddRef,
1738 file_Release,
1739 file_GetTypeInfoCount,
1740 file_GetTypeInfo,
1741 file_GetIDsOfNames,
1742 file_Invoke,
1743 file_get_Path,
1744 file_get_Name,
1745 file_put_Name,
1746 file_get_ShortPath,
1747 file_get_ShortName,
1748 file_get_Drive,
1749 file_get_ParentFolder,
1750 file_get_Attributes,
1751 file_put_Attributes,
1752 file_get_DateCreated,
1753 file_get_DateLastModified,
1754 file_get_DateLastAccessed,
1755 file_get_Size,
1756 file_get_Type,
1757 file_Delete,
1758 file_Copy,
1759 file_Move,
1760 file_OpenAsTextStream
1761 };
1762
1763 static HRESULT create_file(BSTR path, IFile **file)
1764 {
1765 struct file *f;
1766 DWORD len, attrs;
1767
1768 *file = NULL;
1769
1770 f = heap_alloc(sizeof(struct file));
1771 if(!f)
1772 return E_OUTOFMEMORY;
1773
1774 f->IFile_iface.lpVtbl = &file_vtbl;
1775 f->ref = 1;
1776
1777 len = GetFullPathNameW(path, 0, NULL, NULL);
1778 if(!len) {
1779 heap_free(f);
1780 return E_FAIL;
1781 }
1782
1783 f->path = heap_alloc(len*sizeof(WCHAR));
1784 if(!f->path) {
1785 heap_free(f);
1786 return E_OUTOFMEMORY;
1787 }
1788
1789 if(!GetFullPathNameW(path, len, f->path, NULL)) {
1790 heap_free(f->path);
1791 heap_free(f);
1792 return E_FAIL;
1793 }
1794
1795 if(path[len-1]=='/' || path[len-1]=='\\')
1796 path[len-1] = 0;
1797
1798 attrs = GetFileAttributesW(f->path);
1799 if(attrs==INVALID_FILE_ATTRIBUTES ||
1800 (attrs&(FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_DEVICE))) {
1801 heap_free(f->path);
1802 heap_free(f);
1803 return create_error(GetLastError());
1804 }
1805
1806 *file = &f->IFile_iface;
1807 return S_OK;
1808 }
1809
1810 static HRESULT WINAPI filesys_QueryInterface(IFileSystem3 *iface, REFIID riid, void **ppvObject)
1811 {
1812 TRACE("%p %s %p\n", iface, debugstr_guid(riid), ppvObject);
1813
1814 if ( IsEqualGUID( riid, &IID_IFileSystem3 ) ||
1815 IsEqualGUID( riid, &IID_IFileSystem ) ||
1816 IsEqualGUID( riid, &IID_IDispatch ) ||
1817 IsEqualGUID( riid, &IID_IUnknown ) )
1818 {
1819 *ppvObject = iface;
1820 }
1821 else if ( IsEqualGUID( riid, &IID_IDispatchEx ))
1822 {
1823 TRACE("Interface IDispatchEx not supported - returning NULL\n");
1824 *ppvObject = NULL;
1825 return E_NOINTERFACE;
1826 }
1827 else if ( IsEqualGUID( riid, &IID_IObjectWithSite ))
1828 {
1829 TRACE("Interface IObjectWithSite not supported - returning NULL\n");
1830 *ppvObject = NULL;
1831 return E_NOINTERFACE;
1832 }
1833 else
1834 {
1835 FIXME("Unsupported interface %s\n", debugstr_guid(riid));
1836 return E_NOINTERFACE;
1837 }
1838
1839 IFileSystem3_AddRef(iface);
1840
1841 return S_OK;
1842 }
1843
1844 static ULONG WINAPI filesys_AddRef(IFileSystem3 *iface)
1845 {
1846 TRACE("%p\n", iface);
1847
1848 return 2;
1849 }
1850
1851 static ULONG WINAPI filesys_Release(IFileSystem3 *iface)
1852 {
1853 TRACE("%p\n", iface);
1854
1855 return 1;
1856 }
1857
1858 static HRESULT WINAPI filesys_GetTypeInfoCount(IFileSystem3 *iface, UINT *pctinfo)
1859 {
1860 TRACE("(%p)->(%p)\n", iface, pctinfo);
1861
1862 *pctinfo = 1;
1863 return S_OK;
1864 }
1865
1866 static HRESULT WINAPI filesys_GetTypeInfo(IFileSystem3 *iface, UINT iTInfo,
1867 LCID lcid, ITypeInfo **ppTInfo)
1868 {
1869 TRACE("(%p)->(%u %u %p)\n", iface, iTInfo, lcid, ppTInfo);
1870 return get_typeinfo(IFileSystem3_tid, ppTInfo);
1871 }
1872
1873 static HRESULT WINAPI filesys_GetIDsOfNames(IFileSystem3 *iface, REFIID riid,
1874 LPOLESTR *rgszNames, UINT cNames,
1875 LCID lcid, DISPID *rgDispId)
1876 {
1877 ITypeInfo *typeinfo;
1878 HRESULT hr;
1879
1880 TRACE("(%p)->(%s %p %u %u %p)\n", iface, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
1881
1882 hr = get_typeinfo(IFileSystem3_tid, &typeinfo);
1883 if(SUCCEEDED(hr))
1884 {
1885 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1886 ITypeInfo_Release(typeinfo);
1887 }
1888
1889 return hr;
1890 }
1891
1892 static HRESULT WINAPI filesys_Invoke(IFileSystem3 *iface, DISPID dispIdMember,
1893 REFIID riid, LCID lcid, WORD wFlags,
1894 DISPPARAMS *pDispParams, VARIANT *pVarResult,
1895 EXCEPINFO *pExcepInfo, UINT *puArgErr)
1896 {
1897 ITypeInfo *typeinfo;
1898 HRESULT hr;
1899
1900 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", iface, dispIdMember, debugstr_guid(riid),
1901 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1902
1903 hr = get_typeinfo(IFileSystem3_tid, &typeinfo);
1904 if(SUCCEEDED(hr))
1905 {
1906 hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
1907 pDispParams, pVarResult, pExcepInfo, puArgErr);
1908 ITypeInfo_Release(typeinfo);
1909 }
1910
1911 return hr;
1912 }
1913
1914 static HRESULT WINAPI filesys_get_Drives(IFileSystem3 *iface, IDriveCollection **ppdrives)
1915 {
1916 FIXME("%p %p\n", iface, ppdrives);
1917
1918 return E_NOTIMPL;
1919 }
1920
1921 static HRESULT WINAPI filesys_BuildPath(IFileSystem3 *iface, BSTR Path,
1922 BSTR Name, BSTR *Result)
1923 {
1924 BSTR ret;
1925
1926 TRACE("%p %s %s %p\n", iface, debugstr_w(Path), debugstr_w(Name), Result);
1927
1928 if (!Result) return E_POINTER;
1929
1930 if (Path && Name)
1931 {
1932 int path_len = SysStringLen(Path), name_len = SysStringLen(Name);
1933
1934 /* if both parts have backslashes strip one from Path */
1935 if (Path[path_len-1] == '\\' && Name[0] == '\\')
1936 {
1937 path_len -= 1;
1938
1939 ret = SysAllocStringLen(NULL, path_len + name_len);
1940 if (ret)
1941 {
1942 strcpyW(ret, Path);
1943 ret[path_len] = 0;
1944 strcatW(ret, Name);
1945 }
1946 }
1947 else if (Path[path_len-1] != '\\' && Name[0] != '\\')
1948 {
1949 ret = SysAllocStringLen(NULL, path_len + name_len + 1);
1950 if (ret)
1951 {
1952 strcpyW(ret, Path);
1953 if (Path[path_len-1] != ':')
1954 strcatW(ret, bsW);
1955 strcatW(ret, Name);
1956 }
1957 }
1958 else
1959 {
1960 ret = SysAllocStringLen(NULL, path_len + name_len);
1961 if (ret)
1962 {
1963 strcpyW(ret, Path);
1964 strcatW(ret, Name);
1965 }
1966 }
1967 }
1968 else if (Path || Name)
1969 ret = SysAllocString(Path ? Path : Name);
1970 else
1971 ret = SysAllocStringLen(NULL, 0);
1972
1973 if (!ret) return E_OUTOFMEMORY;
1974 *Result = ret;
1975
1976 return S_OK;
1977 }
1978
1979 static HRESULT WINAPI filesys_GetDriveName(IFileSystem3 *iface, BSTR Path,
1980 BSTR *pbstrResult)
1981 {
1982 FIXME("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
1983
1984 return E_NOTIMPL;
1985 }
1986
1987 static inline DWORD get_parent_folder_name(const WCHAR *path, DWORD len)
1988 {
1989 int i;
1990
1991 if(!path)
1992 return 0;
1993
1994 for(i=len-1; i>=0; i--)
1995 if(path[i]!='/' && path[i]!='\\')
1996 break;
1997
1998 for(; i>=0; i--)
1999 if(path[i]=='/' || path[i]=='\\')
2000 break;
2001
2002 for(; i>=0; i--)
2003 if(path[i]!='/' && path[i]!='\\')
2004 break;
2005
2006 if(i < 0)
2007 return 0;
2008
2009 if(path[i]==':' && i==1)
2010 i++;
2011 return i+1;
2012 }
2013
2014 static HRESULT WINAPI filesys_GetParentFolderName(IFileSystem3 *iface, BSTR Path,
2015 BSTR *pbstrResult)
2016 {
2017 DWORD len;
2018
2019 TRACE("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
2020
2021 if(!pbstrResult)
2022 return E_POINTER;
2023
2024 len = get_parent_folder_name(Path, SysStringLen(Path));
2025 if(!len) {
2026 *pbstrResult = NULL;
2027 return S_OK;
2028 }
2029
2030 *pbstrResult = SysAllocStringLen(Path, len);
2031 if(!*pbstrResult)
2032 return E_OUTOFMEMORY;
2033 return S_OK;
2034 }
2035
2036 static HRESULT WINAPI filesys_GetFileName(IFileSystem3 *iface, BSTR Path,
2037 BSTR *pbstrResult)
2038 {
2039 int i, end;
2040
2041 TRACE("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
2042
2043 if(!pbstrResult)
2044 return E_POINTER;
2045
2046 if(!Path) {
2047 *pbstrResult = NULL;
2048 return S_OK;
2049 }
2050
2051 for(end=strlenW(Path)-1; end>=0; end--)
2052 if(Path[end]!='/' && Path[end]!='\\')
2053 break;
2054
2055 for(i=end; i>=0; i--)
2056 if(Path[i]=='/' || Path[i]=='\\')
2057 break;
2058 i++;
2059
2060 if(i>end || (i==0 && end==1 && Path[1]==':')) {
2061 *pbstrResult = NULL;
2062 return S_OK;
2063 }
2064
2065 *pbstrResult = SysAllocStringLen(Path+i, end-i+1);
2066 if(!*pbstrResult)
2067 return E_OUTOFMEMORY;
2068 return S_OK;
2069 }
2070
2071 static HRESULT WINAPI filesys_GetBaseName(IFileSystem3 *iface, BSTR Path,
2072 BSTR *pbstrResult)
2073 {
2074 int i, end;
2075
2076 TRACE("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
2077
2078 if(!pbstrResult)
2079 return E_POINTER;
2080
2081 if(!Path) {
2082 *pbstrResult = NULL;
2083 return S_OK;
2084 }
2085
2086 for(end=strlenW(Path)-1; end>=0; end--)
2087 if(Path[end]!='/' && Path[end]!='\\')
2088 break;
2089
2090 for(i=end; i>=0; i--) {
2091 if(Path[i]=='.' && Path[end+1]!='.')
2092 end = i-1;
2093 if(Path[i]=='/' || Path[i]=='\\')
2094 break;
2095 }
2096 i++;
2097
2098 if((i>end && Path[end+1]!='.') || (i==0 && end==1 && Path[1]==':')) {
2099 *pbstrResult = NULL;
2100 return S_OK;
2101 }
2102
2103 *pbstrResult = SysAllocStringLen(Path+i, end-i+1);
2104 if(!*pbstrResult)
2105 return E_OUTOFMEMORY;
2106 return S_OK;
2107 }
2108
2109 static HRESULT WINAPI filesys_GetExtensionName(IFileSystem3 *iface, BSTR Path,
2110 BSTR *pbstrResult)
2111 {
2112 FIXME("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
2113
2114 return E_NOTIMPL;
2115 }
2116
2117 static HRESULT WINAPI filesys_GetAbsolutePathName(IFileSystem3 *iface, BSTR Path,
2118 BSTR *pbstrResult)
2119 {
2120 static const WCHAR cur_path[] = {'.',0};
2121
2122 WCHAR buf[MAX_PATH], ch;
2123 const WCHAR *path;
2124 DWORD i, beg, len, exp_len;
2125 WIN32_FIND_DATAW fdata;
2126 HANDLE fh;
2127
2128 TRACE("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
2129
2130 if(!pbstrResult)
2131 return E_POINTER;
2132
2133 if(!Path)
2134 path = cur_path;
2135 else
2136 path = Path;
2137
2138 len = GetFullPathNameW(path, MAX_PATH, buf, NULL);
2139 if(!len)
2140 return E_FAIL;
2141
2142 buf[0] = toupperW(buf[0]);
2143 if(len>3 && buf[len-1] == '\\')
2144 buf[--len] = 0;
2145
2146 for(beg=3, i=3; i<=len; i++) {
2147 if(buf[i]!='\\' && buf[i])
2148 continue;
2149
2150 ch = buf[i];
2151 buf[i] = 0;
2152 fh = FindFirstFileW(buf, &fdata);
2153 if(fh == INVALID_HANDLE_VALUE)
2154 break;
2155
2156 exp_len = strlenW(fdata.cFileName);
2157 if(exp_len == i-beg)
2158 memcpy(buf+beg, fdata.cFileName, exp_len*sizeof(WCHAR));
2159 FindClose(fh);
2160 buf[i] = ch;
2161 beg = i+1;
2162 }
2163
2164 *pbstrResult = SysAllocString(buf);
2165 if(!*pbstrResult)
2166 return E_OUTOFMEMORY;
2167 return S_OK;
2168 }
2169
2170 static HRESULT WINAPI filesys_GetTempName(IFileSystem3 *iface, BSTR *pbstrResult)
2171 {
2172 static const WCHAR fmt[] = {'r','a','d','%','0','5','X','.','t','x','t',0};
2173
2174 DWORD random;
2175
2176 TRACE("%p %p\n", iface, pbstrResult);
2177
2178 if(!pbstrResult)
2179 return E_POINTER;
2180
2181 *pbstrResult = SysAllocStringLen(NULL, 12);
2182 if(!*pbstrResult)
2183 return E_OUTOFMEMORY;
2184
2185 if(!RtlGenRandom(&random, sizeof(random)))
2186 return E_FAIL;
2187 sprintfW(*pbstrResult, fmt, random & 0xfffff);
2188 return S_OK;
2189 }
2190
2191 static HRESULT WINAPI filesys_DriveExists(IFileSystem3 *iface, BSTR DriveSpec,
2192 VARIANT_BOOL *pfExists)
2193 {
2194 FIXME("%p %s %p\n", iface, debugstr_w(DriveSpec), pfExists);
2195
2196 return E_NOTIMPL;
2197 }
2198
2199 static HRESULT WINAPI filesys_FileExists(IFileSystem3 *iface, BSTR path, VARIANT_BOOL *ret)
2200 {
2201 DWORD attrs;
2202 TRACE("%p %s %p\n", iface, debugstr_w(path), ret);
2203
2204 if (!ret) return E_POINTER;
2205
2206 attrs = GetFileAttributesW(path);
2207 *ret = attrs != INVALID_FILE_ATTRIBUTES && !(attrs & FILE_ATTRIBUTE_DIRECTORY) ? VARIANT_TRUE : VARIANT_FALSE;
2208 return S_OK;
2209 }
2210
2211 static HRESULT WINAPI filesys_FolderExists(IFileSystem3 *iface, BSTR path, VARIANT_BOOL *ret)
2212 {
2213 DWORD attrs;
2214 TRACE("%p %s %p\n", iface, debugstr_w(path), ret);
2215
2216 if (!ret) return E_POINTER;
2217
2218 attrs = GetFileAttributesW(path);
2219 *ret = attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY) ? VARIANT_TRUE : VARIANT_FALSE;
2220
2221 return S_OK;
2222 }
2223
2224 static HRESULT WINAPI filesys_GetDrive(IFileSystem3 *iface, BSTR DriveSpec,
2225 IDrive **ppdrive)
2226 {
2227 FIXME("%p %s %p\n", iface, debugstr_w(DriveSpec), ppdrive);
2228
2229 return E_NOTIMPL;
2230 }
2231
2232 static HRESULT WINAPI filesys_GetFile(IFileSystem3 *iface, BSTR FilePath,
2233 IFile **ppfile)
2234 {
2235 TRACE("%p %s %p\n", iface, debugstr_w(FilePath), ppfile);
2236
2237 if(!ppfile)
2238 return E_POINTER;
2239 if(!FilePath)
2240 return E_INVALIDARG;
2241
2242 return create_file(FilePath, ppfile);
2243 }
2244
2245 static HRESULT WINAPI filesys_GetFolder(IFileSystem3 *iface, BSTR FolderPath,
2246 IFolder **folder)
2247 {
2248 DWORD attrs;
2249
2250 TRACE("%p %s %p\n", iface, debugstr_w(FolderPath), folder);
2251
2252 if(!folder)
2253 return E_POINTER;
2254
2255 *folder = NULL;
2256 if(!FolderPath)
2257 return E_INVALIDARG;
2258
2259 attrs = GetFileAttributesW(FolderPath);
2260 if((attrs == INVALID_FILE_ATTRIBUTES) || !(attrs & FILE_ATTRIBUTE_DIRECTORY))
2261 return CTL_E_PATHNOTFOUND;
2262
2263 return create_folder(FolderPath, folder);
2264 }
2265
2266 static HRESULT WINAPI filesys_GetSpecialFolder(IFileSystem3 *iface,
2267 SpecialFolderConst SpecialFolder,
2268 IFolder **ppfolder)
2269 {
2270 FIXME("%p %d %p\n", iface, SpecialFolder, ppfolder);
2271
2272 return E_NOTIMPL;
2273 }
2274
2275 static inline HRESULT delete_file(const WCHAR *file, DWORD file_len, VARIANT_BOOL force)
2276 {
2277 WCHAR path[MAX_PATH];
2278 DWORD len, name_len;
2279 WIN32_FIND_DATAW ffd;
2280 HANDLE f;
2281
2282 f = FindFirstFileW(file, &ffd);
2283 if(f == INVALID_HANDLE_VALUE)
2284 return create_error(GetLastError());
2285
2286 len = get_parent_folder_name(file, file_len);
2287 if(len+1 >= MAX_PATH) {
2288 FindClose(f);
2289 return E_FAIL;
2290 }
2291 if(len) {
2292 memcpy(path, file, len*sizeof(WCHAR));
2293 path[len++] = '\\';
2294 }
2295
2296 do {
2297 if(ffd.dwFileAttributes & (FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_DEVICE))
2298 continue;
2299
2300 name_len = strlenW(ffd.cFileName);
2301 if(len+name_len+1 >= MAX_PATH) {
2302 FindClose(f);
2303 return E_FAIL;
2304 }
2305 memcpy(path+len, ffd.cFileName, (name_len+1)*sizeof(WCHAR));
2306
2307 TRACE("deleting %s\n", debugstr_w(path));
2308
2309 if(!DeleteFileW(path)) {
2310 if(!force || !SetFileAttributesW(path, FILE_ATTRIBUTE_NORMAL)
2311 || !DeleteFileW(path)) {
2312 FindClose(f);
2313 return create_error(GetLastError());
2314 }
2315 }
2316 } while(FindNextFileW(f, &ffd));
2317 FindClose(f);
2318
2319 return S_OK;
2320 }
2321
2322 static HRESULT WINAPI filesys_DeleteFile(IFileSystem3 *iface, BSTR FileSpec,
2323 VARIANT_BOOL Force)
2324 {
2325 TRACE("%p %s %d\n", iface, debugstr_w(FileSpec), Force);
2326
2327 if(!FileSpec)
2328 return E_POINTER;
2329
2330 return delete_file(FileSpec, SysStringLen(FileSpec), Force);
2331 }
2332
2333 static HRESULT delete_folder(const WCHAR *folder, DWORD folder_len, VARIANT_BOOL force)
2334 {
2335 WCHAR path[MAX_PATH];
2336 DWORD len, name_len;
2337 WIN32_FIND_DATAW ffd;
2338 HANDLE f;
2339 HRESULT hr;
2340
2341 f = FindFirstFileW(folder, &ffd);
2342 if(f == INVALID_HANDLE_VALUE)
2343 return create_error(GetLastError());
2344
2345 len = get_parent_folder_name(folder, folder_len);
2346 if(len+1 >= MAX_PATH) {
2347 FindClose(f);
2348 return E_FAIL;
2349 }
2350 if(len) {
2351 memcpy(path, folder, len*sizeof(WCHAR));
2352 path[len++] = '\\';
2353 }
2354
2355 do {
2356 if(!(ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
2357 continue;
2358 if(ffd.cFileName[0]=='.' && (ffd.cFileName[1]==0 ||
2359 (ffd.cFileName[1]=='.' && ffd.cFileName[2]==0)))
2360 continue;
2361
2362 name_len = strlenW(ffd.cFileName);
2363 if(len+name_len+3 >= MAX_PATH) {
2364 FindClose(f);
2365 return E_FAIL;
2366 }
2367 memcpy(path+len, ffd.cFileName, name_len*sizeof(WCHAR));
2368 path[len+name_len] = '\\';
2369 path[len+name_len+1] = '*';
2370 path[len+name_len+2] = 0;
2371
2372 hr = delete_file(path, len+name_len+2, force);
2373 if(FAILED(hr)) {
2374 FindClose(f);
2375 return hr;
2376 }
2377
2378 hr = delete_folder(path, len+name_len+2, force);
2379 if(FAILED(hr)) {
2380 FindClose(f);
2381 return hr;
2382 }
2383
2384 path[len+name_len] = 0;
2385 TRACE("deleting %s\n", debugstr_w(path));
2386
2387 if(!RemoveDirectoryW(path)) {
2388 FindClose(f);
2389 return create_error(GetLastError());
2390 }
2391 } while(FindNextFileW(f, &ffd));
2392 FindClose(f);
2393
2394 return S_OK;
2395 }
2396
2397 static HRESULT WINAPI filesys_DeleteFolder(IFileSystem3 *iface, BSTR FolderSpec,
2398 VARIANT_BOOL Force)
2399 {
2400 TRACE("%p %s %d\n", iface, debugstr_w(FolderSpec), Force);
2401
2402 if(!FolderSpec)
2403 return E_POINTER;
2404
2405 return delete_folder(FolderSpec, SysStringLen(FolderSpec), Force);
2406 }
2407
2408 static HRESULT WINAPI filesys_MoveFile(IFileSystem3 *iface, BSTR Source,
2409 BSTR Destination)
2410 {
2411 FIXME("%p %s %s\n", iface, debugstr_w(Source), debugstr_w(Destination));
2412
2413 return E_NOTIMPL;
2414 }
2415
2416 static HRESULT WINAPI filesys_MoveFolder(IFileSystem3 *iface,BSTR Source,
2417 BSTR Destination)
2418 {
2419 FIXME("%p %s %s\n", iface, debugstr_w(Source), debugstr_w(Destination));
2420
2421 return E_NOTIMPL;
2422 }
2423
2424 static inline HRESULT copy_file(const WCHAR *source, DWORD source_len,
2425 const WCHAR *destination, DWORD destination_len, VARIANT_BOOL overwrite)
2426 {
2427 DWORD attrs;
2428 WCHAR src_path[MAX_PATH], dst_path[MAX_PATH];
2429 DWORD src_len, dst_len, name_len;
2430 WIN32_FIND_DATAW ffd;
2431 HANDLE f;
2432 HRESULT hr;
2433
2434 if(!source[0] || !destination[0])
2435 return E_INVALIDARG;
2436
2437 attrs = GetFileAttributesW(destination);
2438 if(attrs==INVALID_FILE_ATTRIBUTES || !(attrs & FILE_ATTRIBUTE_DIRECTORY)) {
2439 attrs = GetFileAttributesW(source);
2440 if(attrs == INVALID_FILE_ATTRIBUTES)
2441 return create_error(GetLastError());
2442 else if(attrs & FILE_ATTRIBUTE_DIRECTORY)
2443 return CTL_E_FILENOTFOUND;
2444
2445 if(!CopyFileW(source, destination, !overwrite))
2446 return create_error(GetLastError());
2447 return S_OK;
2448 }
2449
2450 f = FindFirstFileW(source, &ffd);
2451 if(f == INVALID_HANDLE_VALUE)
2452 return CTL_E_FILENOTFOUND;
2453
2454 src_len = get_parent_folder_name(source, source_len);
2455 if(src_len+1 >= MAX_PATH)
2456 return E_FAIL;
2457 if(src_len) {
2458 memcpy(src_path, source, src_len*sizeof(WCHAR));
2459 src_path[src_len++] = '\\';
2460 }
2461
2462 dst_len = destination_len;
2463 if(dst_len+1 >= MAX_PATH) {
2464 FindClose(f);
2465 return E_FAIL;
2466 }
2467 memcpy(dst_path, destination, dst_len*sizeof(WCHAR));
2468 if(dst_path[dst_len-1]!= '\\' && dst_path[dst_len-1]!='/')
2469 dst_path[dst_len++] = '\\';
2470
2471 hr = CTL_E_FILENOTFOUND;
2472 do {
2473 if(ffd.dwFileAttributes & (FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_DEVICE))
2474 continue;
2475
2476 name_len = strlenW(ffd.cFileName);
2477 if(src_len+name_len+1>=MAX_PATH || dst_len+name_len+1>=MAX_PATH) {
2478 FindClose(f);
2479 return E_FAIL;
2480 }
2481 memcpy(src_path+src_len, ffd.cFileName, (name_len+1)*sizeof(WCHAR));
2482 memcpy(dst_path+dst_len, ffd.cFileName, (name_len+1)*sizeof(WCHAR));
2483
2484 TRACE("copying %s to %s\n", debugstr_w(src_path), debugstr_w(dst_path));
2485
2486 if(!CopyFileW(src_path, dst_path, !overwrite)) {
2487 FindClose(f);
2488 return create_error(GetLastError());
2489 }else {
2490 hr = S_OK;
2491 }
2492 } while(FindNextFileW(f, &ffd));
2493 FindClose(f);
2494
2495 return hr;
2496 }
2497
2498 static HRESULT WINAPI filesys_CopyFile(IFileSystem3 *iface, BSTR Source,
2499 BSTR Destination, VARIANT_BOOL OverWriteFiles)
2500 {
2501 TRACE("%p %s %s %d\n", iface, debugstr_w(Source), debugstr_w(Destination), OverWriteFiles);
2502
2503 if(!Source || !Destination)
2504 return E_POINTER;
2505
2506 return copy_file(Source, SysStringLen(Source), Destination,
2507 SysStringLen(Destination), OverWriteFiles);
2508 }
2509
2510 static HRESULT copy_folder(const WCHAR *source, DWORD source_len, const WCHAR *destination,
2511 DWORD destination_len, VARIANT_BOOL overwrite)
2512 {
2513 DWORD tmp, src_len, dst_len, name_len;
2514 WCHAR src[MAX_PATH], dst[MAX_PATH];
2515 WIN32_FIND_DATAW ffd;
2516 HANDLE f;
2517 HRESULT hr;
2518 BOOL copied = FALSE;
2519
2520 if(!source[0] || !destination[0])
2521 return E_INVALIDARG;
2522
2523 dst_len = destination_len;
2524 if(dst_len+1 >= MAX_PATH)
2525 return E_FAIL;
2526 memcpy(dst, destination, (dst_len+1)*sizeof(WCHAR));
2527
2528 if(dst[dst_len-1]!='\\' && dst[dst_len-1]!='/' &&
2529 (tmp = GetFileAttributesW(source))!=INVALID_FILE_ATTRIBUTES &&
2530 tmp&FILE_ATTRIBUTE_DIRECTORY) {
2531 if(!CreateDirectoryW(dst, NULL)) {
2532 if(overwrite && GetLastError()==ERROR_ALREADY_EXISTS) {
2533 tmp = GetFileAttributesW(dst);
2534 if(tmp==INVALID_FILE_ATTRIBUTES || !(tmp&FILE_ATTRIBUTE_DIRECTORY))
2535 return CTL_E_FILEALREADYEXISTS;
2536 }else {
2537 return create_error(GetLastError());
2538 }
2539 }
2540 copied = TRUE;
2541
2542 src_len = source_len;
2543 if(src_len+2 >= MAX_PATH)
2544 return E_FAIL;
2545 memcpy(src, source, src_len*sizeof(WCHAR));
2546 src[src_len++] = '\\';
2547 src[src_len] = '*';
2548 src[src_len+1] = 0;
2549
2550 hr = copy_file(src, src_len+1, dst, dst_len, overwrite);
2551 if(FAILED(hr) && hr!=CTL_E_FILENOTFOUND)
2552 return create_error(GetLastError());
2553
2554 f = FindFirstFileW(src, &ffd);
2555 }else {
2556 src_len = get_parent_folder_name(source, source_len);
2557 if(src_len+2 >= MAX_PATH)
2558 return E_FAIL;
2559 memcpy(src, source, src_len*sizeof(WCHAR));
2560 if(src_len)
2561 src[src_len++] = '\\';
2562
2563 f = FindFirstFileW(source, &ffd);
2564 }
2565 if(f == INVALID_HANDLE_VALUE)
2566 return CTL_E_PATHNOTFOUND;
2567
2568 dst[dst_len++] = '\\';
2569 dst[dst_len] = 0;
2570
2571 do {
2572 if(!(ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
2573 continue;
2574 if(ffd.cFileName[0]=='.' && (ffd.cFileName[1]==0 ||
2575 (ffd.cFileName[1]=='.' && ffd.cFileName[2]==0)))
2576 continue;
2577
2578 name_len = strlenW(ffd.cFileName);
2579 if(dst_len+name_len>=MAX_PATH || src_len+name_len+2>=MAX_PATH) {
2580 FindClose(f);
2581 return E_FAIL;
2582 }
2583 memcpy(dst+dst_len, ffd.cFileName, name_len*sizeof(WCHAR));
2584 dst[dst_len+name_len] = 0;
2585 memcpy(src+src_len, ffd.cFileName, name_len*sizeof(WCHAR));
2586 src[src_len+name_len] = '\\';
2587 src[src_len+name_len+1] = '*';
2588 src[src_len+name_len+2] = 0;
2589
2590 TRACE("copying %s to %s\n", debugstr_w(src), debugstr_w(dst));
2591
2592 if(!CreateDirectoryW(dst, NULL)) {
2593 if(overwrite && GetLastError()==ERROR_ALREADY_EXISTS) {
2594 tmp = GetFileAttributesW(dst);
2595 if(tmp==INVALID_FILE_ATTRIBUTES || !(tmp&FILE_ATTRIBUTE_DIRECTORY)) {
2596 FindClose(f);
2597 return CTL_E_FILEALREADYEXISTS;
2598 }
2599 }else {
2600 FindClose(f);
2601 return create_error(GetLastError());
2602 }
2603 return create_error(GetLastError());
2604 }
2605 copied = TRUE;
2606
2607 hr = copy_file(src, src_len+name_len+2, dst, dst_len+name_len, overwrite);
2608 if(FAILED(hr) && hr!=CTL_E_FILENOTFOUND) {
2609 FindClose(f);
2610 return hr;
2611 }
2612
2613 hr = copy_folder(src, src_len+name_len+2, dst, dst_len+name_len, overwrite);
2614 if(FAILED(hr) && hr!=CTL_E_PATHNOTFOUND) {
2615 FindClose(f);
2616 return hr;
2617 }
2618 } while(FindNextFileW(f, &ffd));
2619 FindClose(f);
2620
2621 return copied ? S_OK : CTL_E_PATHNOTFOUND;
2622 }
2623
2624 static HRESULT WINAPI filesys_CopyFolder(IFileSystem3 *iface, BSTR Source,
2625 BSTR Destination, VARIANT_BOOL OverWriteFiles)
2626 {
2627 TRACE("%p %s %s %d\n", iface, debugstr_w(Source), debugstr_w(Destination), OverWriteFiles);
2628
2629 if(!Source || !Destination)
2630 return E_POINTER;
2631
2632 return copy_folder(Source, SysStringLen(Source), Destination,
2633 SysStringLen(Destination), OverWriteFiles);
2634 }
2635
2636 static HRESULT WINAPI filesys_CreateFolder(IFileSystem3 *iface, BSTR path,
2637 IFolder **folder)
2638 {
2639 BOOL ret;
2640
2641 TRACE("(%p)->(%s %p)\n", iface, debugstr_w(path), folder);
2642
2643 ret = CreateDirectoryW(path, NULL);
2644 if (!ret)
2645 {
2646 *folder = NULL;
2647 if (GetLastError() == ERROR_ALREADY_EXISTS) return CTL_E_FILEALREADYEXISTS;
2648 return HRESULT_FROM_WIN32(GetLastError());
2649 }
2650
2651 return create_folder(path, folder);
2652 }
2653
2654 static HRESULT WINAPI filesys_CreateTextFile(IFileSystem3 *iface, BSTR FileName,
2655 VARIANT_BOOL Overwrite, VARIANT_BOOL Unicode,
2656 ITextStream **ppts)
2657 {
2658 FIXME("%p %s %d %d %p\n", iface, debugstr_w(FileName), Overwrite, Unicode, ppts);
2659
2660 return E_NOTIMPL;
2661 }
2662
2663 static HRESULT WINAPI filesys_OpenTextFile(IFileSystem3 *iface, BSTR filename,
2664 IOMode mode, VARIANT_BOOL create,
2665 Tristate format, ITextStream **stream)
2666 {
2667 FIXME("(%p)->(%s %d %d %d %p)\n", iface, debugstr_w(filename), mode, create, format, stream);
2668 return create_textstream(mode, stream);
2669 }
2670
2671 static HRESULT WINAPI filesys_GetStandardStream(IFileSystem3 *iface,
2672 StandardStreamTypes StandardStreamType,
2673 VARIANT_BOOL Unicode,
2674 ITextStream **ppts)
2675 {
2676 FIXME("%p %d %d %p\n", iface, StandardStreamType, Unicode, ppts);
2677
2678 return E_NOTIMPL;
2679 }
2680
2681 static void get_versionstring(VS_FIXEDFILEINFO *info, WCHAR *ver)
2682 {
2683 static const WCHAR fmtW[] = {'%','d','.','%','d','.','%','d','.','%','d',0};
2684 DWORDLONG version;
2685 WORD a, b, c, d;
2686
2687 version = (((DWORDLONG)info->dwFileVersionMS) << 32) + info->dwFileVersionLS;
2688 a = (WORD)( version >> 48);
2689 b = (WORD)((version >> 32) & 0xffff);
2690 c = (WORD)((version >> 16) & 0xffff);
2691 d = (WORD)( version & 0xffff);
2692
2693 sprintfW(ver, fmtW, a, b, c, d);
2694 }
2695
2696 static HRESULT WINAPI filesys_GetFileVersion(IFileSystem3 *iface, BSTR name, BSTR *version)
2697 {
2698 static const WCHAR rootW[] = {'\\',0};
2699 VS_FIXEDFILEINFO *info;
2700 WCHAR ver[30];
2701 void *ptr;
2702 DWORD len;
2703 BOOL ret;
2704
2705 TRACE("%p %s %p\n", iface, debugstr_w(name), version);
2706
2707 len = GetFileVersionInfoSizeW(name, NULL);
2708 if (!len)
2709 return HRESULT_FROM_WIN32(GetLastError());
2710
2711 ptr = heap_alloc(len);
2712 if (!GetFileVersionInfoW(name, 0, len, ptr))
2713 {
2714 heap_free(ptr);
2715 return HRESULT_FROM_WIN32(GetLastError());
2716 }
2717
2718 ret = VerQueryValueW(ptr, rootW, (void**)&info, &len);
2719 heap_free(ptr);
2720 if (!ret)
2721 return HRESULT_FROM_WIN32(GetLastError());
2722
2723 get_versionstring(info, ver);
2724 *version = SysAllocString(ver);
2725 TRACE("version=%s\n", debugstr_w(ver));
2726
2727 return S_OK;
2728 }
2729
2730 static const struct IFileSystem3Vtbl filesys_vtbl =
2731 {
2732 filesys_QueryInterface,
2733 filesys_AddRef,
2734 filesys_Release,
2735 filesys_GetTypeInfoCount,
2736 filesys_GetTypeInfo,
2737 filesys_GetIDsOfNames,
2738 filesys_Invoke,
2739 filesys_get_Drives,
2740 filesys_BuildPath,
2741 filesys_GetDriveName,
2742 filesys_GetParentFolderName,
2743 filesys_GetFileName,
2744 filesys_GetBaseName,
2745 filesys_GetExtensionName,
2746 filesys_GetAbsolutePathName,
2747 filesys_GetTempName,
2748 filesys_DriveExists,
2749 filesys_FileExists,
2750 filesys_FolderExists,
2751 filesys_GetDrive,
2752 filesys_GetFile,
2753 filesys_GetFolder,
2754 filesys_GetSpecialFolder,
2755 filesys_DeleteFile,
2756 filesys_DeleteFolder,
2757 filesys_MoveFile,
2758 filesys_MoveFolder,
2759 filesys_CopyFile,
2760 filesys_CopyFolder,
2761 filesys_CreateFolder,
2762 filesys_CreateTextFile,
2763 filesys_OpenTextFile,
2764 filesys_GetStandardStream,
2765 filesys_GetFileVersion
2766 };
2767
2768 static IFileSystem3 filesystem = { &filesys_vtbl };
2769
2770 HRESULT WINAPI FileSystem_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
2771 {
2772 TRACE("(%p %s %p)\n", outer, debugstr_guid(riid), ppv);
2773
2774 return IFileSystem3_QueryInterface(&filesystem, riid, ppv);
2775 }
Maarten's multimedia branch