?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3dx9/tests: Fix expected values when mipmaps on cube maps are not supported.
[wine.git] / dlls / scrrun / filesystem.c
blobb04637c46a04889ab88c30a02993b569cee32f91
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 static const WCHAR utf16bom = 0xfeff;
41
42 struct foldercollection {
43 IFolderCollection IFolderCollection_iface;
44 LONG ref;
45 BSTR path;
46 };
47
48 struct filecollection {
49 IFileCollection IFileCollection_iface;
50 LONG ref;
51 BSTR path;
52 };
53
54 struct drivecollection {
55 IDriveCollection IDriveCollection_iface;
56 LONG ref;
57 DWORD drives;
58 LONG count;
59 };
60
61 struct enumdata {
62 union
63 {
64 struct
65 {
66 struct foldercollection *coll;
67 HANDLE find;
68 } foldercoll;
69 struct
70 {
71 struct filecollection *coll;
72 HANDLE find;
73 } filecoll;
74 struct
75 {
76 struct drivecollection *coll;
77 INT cur;
78 } drivecoll;
79 } u;
80 };
81
82 struct enumvariant {
83 IEnumVARIANT IEnumVARIANT_iface;
84 LONG ref;
85
86 struct enumdata data;
87 };
88
89 struct drive {
90 IDrive IDrive_iface;
91 LONG ref;
92 BSTR root;
93 };
94
95 struct folder {
96 IFolder IFolder_iface;
97 LONG ref;
98 BSTR path;
99 };
100
101 struct file {
102 IFile IFile_iface;
103 LONG ref;
104
105 WCHAR *path;
106 };
107
108 struct textstream {
109 ITextStream ITextStream_iface;
110 LONG ref;
111
112 IOMode mode;
113 BOOL unicode;
114 BOOL first_read;
115 LARGE_INTEGER size;
116 HANDLE file;
117 };
118
119 enum iotype {
120 IORead,
121 IOWrite
122 };
123
124 static inline struct drive *impl_from_IDrive(IDrive *iface)
125 {
126 return CONTAINING_RECORD(iface, struct drive, IDrive_iface);
127 }
128
129 static inline struct folder *impl_from_IFolder(IFolder *iface)
130 {
131 return CONTAINING_RECORD(iface, struct folder, IFolder_iface);
132 }
133
134 static inline struct file *impl_from_IFile(IFile *iface)
135 {
136 return CONTAINING_RECORD(iface, struct file, IFile_iface);
137 }
138
139 static inline struct textstream *impl_from_ITextStream(ITextStream *iface)
140 {
141 return CONTAINING_RECORD(iface, struct textstream, ITextStream_iface);
142 }
143
144 static inline struct foldercollection *impl_from_IFolderCollection(IFolderCollection *iface)
145 {
146 return CONTAINING_RECORD(iface, struct foldercollection, IFolderCollection_iface);
147 }
148
149 static inline struct filecollection *impl_from_IFileCollection(IFileCollection *iface)
150 {
151 return CONTAINING_RECORD(iface, struct filecollection, IFileCollection_iface);
152 }
153
154 static inline struct drivecollection *impl_from_IDriveCollection(IDriveCollection *iface)
155 {
156 return CONTAINING_RECORD(iface, struct drivecollection, IDriveCollection_iface);
157 }
158
159 static inline struct enumvariant *impl_from_IEnumVARIANT(IEnumVARIANT *iface)
160 {
161 return CONTAINING_RECORD(iface, struct enumvariant, IEnumVARIANT_iface);
162 }
163
164 static inline HRESULT create_error(DWORD err)
165 {
166 switch(err) {
167 case ERROR_FILE_NOT_FOUND: return CTL_E_FILENOTFOUND;
168 case ERROR_PATH_NOT_FOUND: return CTL_E_PATHNOTFOUND;
169 case ERROR_ACCESS_DENIED: return CTL_E_PERMISSIONDENIED;
170 case ERROR_FILE_EXISTS: return CTL_E_FILEALREADYEXISTS;
171 case ERROR_ALREADY_EXISTS: return CTL_E_FILEALREADYEXISTS;
172 default:
173 FIXME("Unsupported error code: %d\n", err);
174 return E_FAIL;
175 }
176 }
177
178 static HRESULT create_folder(const WCHAR*, IFolder**);
179 static HRESULT create_file(BSTR, IFile**);
180 static HRESULT create_foldercoll_enum(struct foldercollection*, IUnknown**);
181 static HRESULT create_filecoll_enum(struct filecollection*, IUnknown**);
182
183 static inline BOOL is_dir_data(const WIN32_FIND_DATAW *data)
184 {
185 static const WCHAR dotdotW[] = {'.','.',0};
186 static const WCHAR dotW[] = {'.',0};
187
188 return (data->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
189 strcmpW(data->cFileName, dotdotW) &&
190 strcmpW(data->cFileName, dotW);
191 }
192
193 static inline BOOL is_file_data(const WIN32_FIND_DATAW *data)
194 {
195 return !(data->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
196 }
197
198 static BSTR get_full_path(BSTR path, const WIN32_FIND_DATAW *data)
199 {
200 int len = SysStringLen(path);
201 WCHAR buffW[MAX_PATH];
202
203 strcpyW(buffW, path);
204 if (path[len-1] != '\\')
205 strcatW(buffW, bsW);
206 strcatW(buffW, data->cFileName);
207
208 return SysAllocString(buffW);
209 }
210
211 static BOOL textstream_check_iomode(struct textstream *This, enum iotype type)
212 {
213 if (type == IORead)
214 return This->mode == ForWriting || This->mode == ForAppending;
215 else
216 return This->mode == ForReading;
217 }
218
219 static HRESULT WINAPI textstream_QueryInterface(ITextStream *iface, REFIID riid, void **obj)
220 {
221 struct textstream *This = impl_from_ITextStream(iface);
222
223 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
224
225 if (IsEqualIID(riid, &IID_ITextStream) ||
226 IsEqualIID(riid, &IID_IDispatch) ||
227 IsEqualIID(riid, &IID_IUnknown))
228 {
229 *obj = iface;
230 ITextStream_AddRef(iface);
231 return S_OK;
232 }
233
234 *obj = NULL;
235 return E_NOINTERFACE;
236 }
237
238 static ULONG WINAPI textstream_AddRef(ITextStream *iface)
239 {
240 struct textstream *This = impl_from_ITextStream(iface);
241 ULONG ref = InterlockedIncrement(&This->ref);
242 TRACE("(%p)->(%d)\n", This, ref);
243 return ref;
244 }
245
246 static ULONG WINAPI textstream_Release(ITextStream *iface)
247 {
248 struct textstream *This = impl_from_ITextStream(iface);
249 ULONG ref = InterlockedDecrement(&This->ref);
250 TRACE("(%p)->(%d)\n", This, ref);
251
252 if (!ref)
253 {
254 CloseHandle(This->file);
255 heap_free(This);
256 }
257
258 return ref;
259 }
260
261 static HRESULT WINAPI textstream_GetTypeInfoCount(ITextStream *iface, UINT *pctinfo)
262 {
263 struct textstream *This = impl_from_ITextStream(iface);
264 TRACE("(%p)->(%p)\n", This, pctinfo);
265 *pctinfo = 1;
266 return S_OK;
267 }
268
269 static HRESULT WINAPI textstream_GetTypeInfo(ITextStream *iface, UINT iTInfo,
270 LCID lcid, ITypeInfo **ppTInfo)
271 {
272 struct textstream *This = impl_from_ITextStream(iface);
273 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
274 return get_typeinfo(ITextStream_tid, ppTInfo);
275 }
276
277 static HRESULT WINAPI textstream_GetIDsOfNames(ITextStream *iface, REFIID riid,
278 LPOLESTR *rgszNames, UINT cNames,
279 LCID lcid, DISPID *rgDispId)
280 {
281 struct textstream *This = impl_from_ITextStream(iface);
282 ITypeInfo *typeinfo;
283 HRESULT hr;
284
285 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
286
287 hr = get_typeinfo(ITextStream_tid, &typeinfo);
288 if(SUCCEEDED(hr))
289 {
290 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
291 ITypeInfo_Release(typeinfo);
292 }
293
294 return hr;
295 }
296
297 static HRESULT WINAPI textstream_Invoke(ITextStream *iface, DISPID dispIdMember,
298 REFIID riid, LCID lcid, WORD wFlags,
299 DISPPARAMS *pDispParams, VARIANT *pVarResult,
300 EXCEPINFO *pExcepInfo, UINT *puArgErr)
301 {
302 struct textstream *This = impl_from_ITextStream(iface);
303 ITypeInfo *typeinfo;
304 HRESULT hr;
305
306 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
307 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
308
309 hr = get_typeinfo(ITextStream_tid, &typeinfo);
310 if(SUCCEEDED(hr))
311 {
312 hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
313 pDispParams, pVarResult, pExcepInfo, puArgErr);
314 ITypeInfo_Release(typeinfo);
315 }
316
317 return hr;
318 }
319
320 static HRESULT WINAPI textstream_get_Line(ITextStream *iface, LONG *line)
321 {
322 struct textstream *This = impl_from_ITextStream(iface);
323 FIXME("(%p)->(%p): stub\n", This, line);
324 return E_NOTIMPL;
325 }
326
327 static HRESULT WINAPI textstream_get_Column(ITextStream *iface, LONG *column)
328 {
329 struct textstream *This = impl_from_ITextStream(iface);
330 FIXME("(%p)->(%p): stub\n", This, column);
331 return E_NOTIMPL;
332 }
333
334 static HRESULT WINAPI textstream_get_AtEndOfStream(ITextStream *iface, VARIANT_BOOL *eos)
335 {
336 struct textstream *This = impl_from_ITextStream(iface);
337 LARGE_INTEGER pos, dist;
338
339 TRACE("(%p)->(%p)\n", This, eos);
340
341 if (!eos)
342 return E_POINTER;
343
344 if (textstream_check_iomode(This, IORead)) {
345 *eos = VARIANT_TRUE;
346 return CTL_E_BADFILEMODE;
347 }
348
349 dist.QuadPart = 0;
350 if (!SetFilePointerEx(This->file, dist, &pos, FILE_CURRENT))
351 return E_FAIL;
352
353 *eos = This->size.QuadPart == pos.QuadPart ? VARIANT_TRUE : VARIANT_FALSE;
354 return S_OK;
355 }
356
357 static HRESULT WINAPI textstream_get_AtEndOfLine(ITextStream *iface, VARIANT_BOOL *eol)
358 {
359 struct textstream *This = impl_from_ITextStream(iface);
360 FIXME("(%p)->(%p): stub\n", This, eol);
361 return E_NOTIMPL;
362 }
363
364 /*
365 Reads 'toread' bytes from a file, converts if needed
366 BOM is skipped if 'bof' is set.
367 */
368 static HRESULT textstream_read(struct textstream *stream, LONG toread, BOOL bof, BSTR *text)
369 {
370 HRESULT hr = S_OK;
371 DWORD read;
372 char *buff;
373 BOOL ret;
374
375 if (toread == 0) {
376 *text = SysAllocStringLen(NULL, 0);
377 return *text ? S_FALSE : E_OUTOFMEMORY;
378 }
379
380 if (toread < sizeof(WCHAR))
381 return CTL_E_ENDOFFILE;
382
383 buff = heap_alloc(toread);
384 if (!buff)
385 return E_OUTOFMEMORY;
386
387 ret = ReadFile(stream->file, buff, toread, &read, NULL);
388 if (!ret || toread != read) {
389 WARN("failed to read from file %d, %d, error %d\n", read, toread, GetLastError());
390 heap_free(buff);
391 return E_FAIL;
392 }
393
394 if (stream->unicode) {
395 int i = 0;
396
397 /* skip BOM */
398 if (bof && *(WCHAR*)buff == utf16bom) {
399 read -= sizeof(WCHAR);
400 i += sizeof(WCHAR);
401 }
402
403 *text = SysAllocStringLen(read ? (WCHAR*)&buff[i] : NULL, read/sizeof(WCHAR));
404 if (!*text) hr = E_OUTOFMEMORY;
405 }
406 else {
407 INT len = MultiByteToWideChar(CP_ACP, 0, buff, read, NULL, 0);
408 *text = SysAllocStringLen(NULL, len);
409 if (*text)
410 MultiByteToWideChar(CP_ACP, 0, buff, read, *text, len);
411 else
412 hr = E_OUTOFMEMORY;
413 }
414 heap_free(buff);
415
416 return hr;
417 }
418
419 static HRESULT WINAPI textstream_Read(ITextStream *iface, LONG len, BSTR *text)
420 {
421 struct textstream *This = impl_from_ITextStream(iface);
422 LARGE_INTEGER start, end, dist;
423 DWORD toread;
424 HRESULT hr;
425
426 TRACE("(%p)->(%d %p)\n", This, len, text);
427
428 if (!text)
429 return E_POINTER;
430
431 *text = NULL;
432 if (len <= 0)
433 return len == 0 ? S_OK : E_INVALIDARG;
434
435 if (textstream_check_iomode(This, IORead))
436 return CTL_E_BADFILEMODE;
437
438 if (!This->first_read) {
439 VARIANT_BOOL eos;
440
441 /* check for EOF */
442 hr = ITextStream_get_AtEndOfStream(iface, &eos);
443 if (FAILED(hr))
444 return hr;
445
446 if (eos == VARIANT_TRUE)
447 return CTL_E_ENDOFFILE;
448 }
449
450 /* read everything from current position */
451 dist.QuadPart = 0;
452 SetFilePointerEx(This->file, dist, &start, FILE_CURRENT);
453 SetFilePointerEx(This->file, dist, &end, FILE_END);
454 toread = end.QuadPart - start.QuadPart;
455 /* rewind back */
456 dist.QuadPart = start.QuadPart;
457 SetFilePointerEx(This->file, dist, NULL, FILE_BEGIN);
458
459 This->first_read = FALSE;
460 if (This->unicode) len *= sizeof(WCHAR);
461
462 hr = textstream_read(This, min(toread, len), start.QuadPart == 0, text);
463 if (FAILED(hr))
464 return hr;
465 else
466 return toread <= len ? S_FALSE : S_OK;
467 }
468
469 static HRESULT WINAPI textstream_ReadLine(ITextStream *iface, BSTR *text)
470 {
471 struct textstream *This = impl_from_ITextStream(iface);
472 VARIANT_BOOL eos;
473 HRESULT hr;
474
475 FIXME("(%p)->(%p): stub\n", This, text);
476
477 if (!text)
478 return E_POINTER;
479
480 *text = NULL;
481 if (textstream_check_iomode(This, IORead))
482 return CTL_E_BADFILEMODE;
483
484 /* check for EOF */
485 hr = ITextStream_get_AtEndOfStream(iface, &eos);
486 if (FAILED(hr))
487 return hr;
488
489 if (eos == VARIANT_TRUE)
490 return CTL_E_ENDOFFILE;
491
492 return E_NOTIMPL;
493 }
494
495 static HRESULT WINAPI textstream_ReadAll(ITextStream *iface, BSTR *text)
496 {
497 struct textstream *This = impl_from_ITextStream(iface);
498 LARGE_INTEGER start, end, dist;
499 DWORD toread;
500 HRESULT hr;
501
502 TRACE("(%p)->(%p)\n", This, text);
503
504 if (!text)
505 return E_POINTER;
506
507 *text = NULL;
508 if (textstream_check_iomode(This, IORead))
509 return CTL_E_BADFILEMODE;
510
511 if (!This->first_read) {
512 VARIANT_BOOL eos;
513
514 /* check for EOF */
515 hr = ITextStream_get_AtEndOfStream(iface, &eos);
516 if (FAILED(hr))
517 return hr;
518
519 if (eos == VARIANT_TRUE)
520 return CTL_E_ENDOFFILE;
521 }
522
523 /* read everything from current position */
524 dist.QuadPart = 0;
525 SetFilePointerEx(This->file, dist, &start, FILE_CURRENT);
526 SetFilePointerEx(This->file, dist, &end, FILE_END);
527 toread = end.QuadPart - start.QuadPart;
528 /* rewind back */
529 dist.QuadPart = start.QuadPart;
530 SetFilePointerEx(This->file, dist, NULL, FILE_BEGIN);
531
532 This->first_read = FALSE;
533
534 hr = textstream_read(This, toread, start.QuadPart == 0, text);
535 return FAILED(hr) ? hr : S_FALSE;
536 }
537
538 static HRESULT textstream_writestr(struct textstream *stream, BSTR text)
539 {
540 DWORD written = 0;
541 BOOL ret;
542
543 if (stream->unicode) {
544 ret = WriteFile(stream->file, text, SysStringByteLen(text), &written, NULL);
545 return (ret && written == SysStringByteLen(text)) ? S_OK : create_error(GetLastError());
546 } else {
547 DWORD len = WideCharToMultiByte(CP_ACP, 0, text, SysStringLen(text), NULL, 0, NULL, NULL);
548 char *buffA;
549 HRESULT hr;
550
551 buffA = heap_alloc(len);
552 if (!buffA)
553 return E_OUTOFMEMORY;
554
555 WideCharToMultiByte(CP_ACP, 0, text, SysStringLen(text), buffA, len, NULL, NULL);
556 ret = WriteFile(stream->file, buffA, len, &written, NULL);
557 hr = (ret && written == len) ? S_OK : create_error(GetLastError());
558 heap_free(buffA);
559 return hr;
560 }
561 }
562
563 static HRESULT WINAPI textstream_Write(ITextStream *iface, BSTR text)
564 {
565 struct textstream *This = impl_from_ITextStream(iface);
566
567 TRACE("(%p)->(%s)\n", This, debugstr_w(text));
568
569 if (textstream_check_iomode(This, IOWrite))
570 return CTL_E_BADFILEMODE;
571
572 return textstream_writestr(This, text);
573 }
574
575 static HRESULT textstream_writecrlf(struct textstream *stream)
576 {
577 static const WCHAR crlfW[] = {'\r','\n'};
578 static const char crlfA[] = {'\r','\n'};
579 DWORD written = 0, len;
580 const void *ptr;
581 BOOL ret;
582
583 if (stream->unicode) {
584 ptr = crlfW;
585 len = sizeof(crlfW);
586 }
587 else {
588 ptr = crlfA;
589 len = sizeof(crlfA);
590 }
591
592 ret = WriteFile(stream->file, ptr, len, &written, NULL);
593 return (ret && written == len) ? S_OK : create_error(GetLastError());
594 }
595
596 static HRESULT WINAPI textstream_WriteLine(ITextStream *iface, BSTR text)
597 {
598 struct textstream *This = impl_from_ITextStream(iface);
599 HRESULT hr;
600
601 TRACE("(%p)->(%s)\n", This, debugstr_w(text));
602
603 if (textstream_check_iomode(This, IOWrite))
604 return CTL_E_BADFILEMODE;
605
606 hr = textstream_writestr(This, text);
607 if (SUCCEEDED(hr))
608 hr = textstream_writecrlf(This);
609 return hr;
610 }
611
612 static HRESULT WINAPI textstream_WriteBlankLines(ITextStream *iface, LONG lines)
613 {
614 struct textstream *This = impl_from_ITextStream(iface);
615 FIXME("(%p)->(%d): stub\n", This, lines);
616 return E_NOTIMPL;
617 }
618
619 static HRESULT WINAPI textstream_Skip(ITextStream *iface, LONG count)
620 {
621 struct textstream *This = impl_from_ITextStream(iface);
622 FIXME("(%p)->(%d): stub\n", This, count);
623 return E_NOTIMPL;
624 }
625
626 static HRESULT WINAPI textstream_SkipLine(ITextStream *iface)
627 {
628 struct textstream *This = impl_from_ITextStream(iface);
629 FIXME("(%p): stub\n", This);
630 return E_NOTIMPL;
631 }
632
633 static HRESULT WINAPI textstream_Close(ITextStream *iface)
634 {
635 struct textstream *This = impl_from_ITextStream(iface);
636 FIXME("(%p): stub\n", This);
637 return E_NOTIMPL;
638 }
639
640 static const ITextStreamVtbl textstreamvtbl = {
641 textstream_QueryInterface,
642 textstream_AddRef,
643 textstream_Release,
644 textstream_GetTypeInfoCount,
645 textstream_GetTypeInfo,
646 textstream_GetIDsOfNames,
647 textstream_Invoke,
648 textstream_get_Line,
649 textstream_get_Column,
650 textstream_get_AtEndOfStream,
651 textstream_get_AtEndOfLine,
652 textstream_Read,
653 textstream_ReadLine,
654 textstream_ReadAll,
655 textstream_Write,
656 textstream_WriteLine,
657 textstream_WriteBlankLines,
658 textstream_Skip,
659 textstream_SkipLine,
660 textstream_Close
661 };
662
663 static HRESULT create_textstream(const WCHAR *filename, DWORD disposition, IOMode mode, BOOL unicode, ITextStream **ret)
664 {
665 struct textstream *stream;
666 DWORD access = 0;
667
668 /* map access mode */
669 switch (mode)
670 {
671 case ForReading:
672 access = GENERIC_READ;
673 break;
674 case ForWriting:
675 access = GENERIC_WRITE;
676 break;
677 case ForAppending:
678 access = FILE_APPEND_DATA;
679 break;
680 default:
681 return E_INVALIDARG;
682 }
683
684 stream = heap_alloc(sizeof(struct textstream));
685 if (!stream) return E_OUTOFMEMORY;
686
687 stream->ITextStream_iface.lpVtbl = &textstreamvtbl;
688 stream->ref = 1;
689 stream->mode = mode;
690 stream->unicode = unicode;
691 stream->first_read = TRUE;
692
693 stream->file = CreateFileW(filename, access, 0, NULL, disposition, FILE_ATTRIBUTE_NORMAL, NULL);
694 if (stream->file == INVALID_HANDLE_VALUE)
695 {
696 HRESULT hr = create_error(GetLastError());
697 heap_free(stream);
698 return hr;
699 }
700
701 if (mode == ForReading)
702 GetFileSizeEx(stream->file, &stream->size);
703 else
704 stream->size.QuadPart = 0;
705
706 /* Write Unicode BOM */
707 if (unicode && mode == ForWriting && (disposition == CREATE_ALWAYS || disposition == CREATE_NEW)) {
708 DWORD written = 0;
709 BOOL ret = WriteFile(stream->file, &utf16bom, sizeof(utf16bom), &written, NULL);
710 if (!ret || written != sizeof(utf16bom)) {
711 ITextStream_Release(&stream->ITextStream_iface);
712 return create_error(GetLastError());
713 }
714 }
715
716 *ret = &stream->ITextStream_iface;
717 return S_OK;
718 }
719
720 static HRESULT WINAPI drive_QueryInterface(IDrive *iface, REFIID riid, void **obj)
721 {
722 struct drive *This = impl_from_IDrive(iface);
723
724 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
725
726 *obj = NULL;
727
728 if (IsEqualIID( riid, &IID_IDrive ) ||
729 IsEqualIID( riid, &IID_IDispatch ) ||
730 IsEqualIID( riid, &IID_IUnknown))
731 {
732 *obj = iface;
733 IDrive_AddRef(iface);
734 }
735 else
736 return E_NOINTERFACE;
737
738 return S_OK;
739 }
740
741 static ULONG WINAPI drive_AddRef(IDrive *iface)
742 {
743 struct drive *This = impl_from_IDrive(iface);
744 ULONG ref = InterlockedIncrement(&This->ref);
745 TRACE("(%p)->(%d)\n", This, ref);
746 return ref;
747 }
748
749 static ULONG WINAPI drive_Release(IDrive *iface)
750 {
751 struct drive *This = impl_from_IDrive(iface);
752 ULONG ref = InterlockedDecrement(&This->ref);
753 TRACE("(%p)->(%d)\n", This, ref);
754
755 if (!ref)
756 {
757 SysFreeString(This->root);
758 heap_free(This);
759 }
760
761 return ref;
762 }
763
764 static HRESULT WINAPI drive_GetTypeInfoCount(IDrive *iface, UINT *pctinfo)
765 {
766 struct drive *This = impl_from_IDrive(iface);
767 TRACE("(%p)->(%p)\n", This, pctinfo);
768 *pctinfo = 1;
769 return S_OK;
770 }
771
772 static HRESULT WINAPI drive_GetTypeInfo(IDrive *iface, UINT iTInfo,
773 LCID lcid, ITypeInfo **ppTInfo)
774 {
775 struct drive *This = impl_from_IDrive(iface);
776 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
777 return get_typeinfo(IDrive_tid, ppTInfo);
778 }
779
780 static HRESULT WINAPI drive_GetIDsOfNames(IDrive *iface, REFIID riid,
781 LPOLESTR *rgszNames, UINT cNames,
782 LCID lcid, DISPID *rgDispId)
783 {
784 struct drive *This = impl_from_IDrive(iface);
785 ITypeInfo *typeinfo;
786 HRESULT hr;
787
788 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
789
790 hr = get_typeinfo(IDrive_tid, &typeinfo);
791 if(SUCCEEDED(hr))
792 {
793 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
794 ITypeInfo_Release(typeinfo);
795 }
796
797 return hr;
798 }
799
800 static HRESULT WINAPI drive_Invoke(IDrive *iface, DISPID dispIdMember,
801 REFIID riid, LCID lcid, WORD wFlags,
802 DISPPARAMS *pDispParams, VARIANT *pVarResult,
803 EXCEPINFO *pExcepInfo, UINT *puArgErr)
804 {
805 struct drive *This = impl_from_IDrive(iface);
806 ITypeInfo *typeinfo;
807 HRESULT hr;
808
809 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
810 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
811
812 hr = get_typeinfo(IDrive_tid, &typeinfo);
813 if(SUCCEEDED(hr))
814 {
815 hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
816 pDispParams, pVarResult, pExcepInfo, puArgErr);
817 ITypeInfo_Release(typeinfo);
818 }
819
820 return hr;
821 }
822
823 static HRESULT WINAPI drive_get_Path(IDrive *iface, BSTR *path)
824 {
825 struct drive *This = impl_from_IDrive(iface);
826 FIXME("(%p)->(%p): stub\n", This, path);
827 return E_NOTIMPL;
828 }
829
830 static HRESULT WINAPI drive_get_DriveLetter(IDrive *iface, BSTR *letter)
831 {
832 struct drive *This = impl_from_IDrive(iface);
833
834 TRACE("(%p)->(%p)\n", This, letter);
835
836 if (!letter)
837 return E_POINTER;
838
839 *letter = SysAllocStringLen(This->root, 1);
840 if (!*letter)
841 return E_OUTOFMEMORY;
842
843 return S_OK;
844 }
845
846 static HRESULT WINAPI drive_get_ShareName(IDrive *iface, BSTR *share_name)
847 {
848 struct drive *This = impl_from_IDrive(iface);
849 FIXME("(%p)->(%p): stub\n", This, share_name);
850 return E_NOTIMPL;
851 }
852
853 static HRESULT WINAPI drive_get_DriveType(IDrive *iface, DriveTypeConst *type)
854 {
855 struct drive *This = impl_from_IDrive(iface);
856
857 TRACE("(%p)->(%p)\n", This, type);
858
859 switch (GetDriveTypeW(This->root))
860 {
861 case DRIVE_REMOVABLE:
862 *type = Removable;
863 break;
864 case DRIVE_FIXED:
865 *type = Fixed;
866 break;
867 case DRIVE_REMOTE:
868 *type = Remote;
869 break;
870 case DRIVE_CDROM:
871 *type = CDRom;
872 break;
873 case DRIVE_RAMDISK:
874 *type = RamDisk;
875 break;
876 default:
877 *type = UnknownType;
878 break;
879 }
880
881 return S_OK;
882 }
883
884 static HRESULT WINAPI drive_get_RootFolder(IDrive *iface, IFolder **folder)
885 {
886 struct drive *This = impl_from_IDrive(iface);
887 FIXME("(%p)->(%p): stub\n", This, folder);
888 return E_NOTIMPL;
889 }
890
891 static HRESULT WINAPI drive_get_AvailableSpace(IDrive *iface, VARIANT *v)
892 {
893 struct drive *This = impl_from_IDrive(iface);
894 ULARGE_INTEGER avail;
895
896 TRACE("(%p)->(%p)\n", This, v);
897
898 if (!v)
899 return E_POINTER;
900
901 if (!GetDiskFreeSpaceExW(This->root, &avail, NULL, NULL))
902 return E_FAIL;
903
904 V_VT(v) = VT_R8;
905 return VarR8FromUI8(avail.QuadPart, &V_R8(v));
906 }
907
908 static HRESULT WINAPI drive_get_FreeSpace(IDrive *iface, VARIANT *v)
909 {
910 struct drive *This = impl_from_IDrive(iface);
911 ULARGE_INTEGER freespace;
912
913 TRACE("(%p)->(%p)\n", This, v);
914
915 if (!v)
916 return E_POINTER;
917
918 if (!GetDiskFreeSpaceExW(This->root, &freespace, NULL, NULL))
919 return E_FAIL;
920
921 V_VT(v) = VT_R8;
922 return VarR8FromUI8(freespace.QuadPart, &V_R8(v));
923 }
924
925 static HRESULT WINAPI drive_get_TotalSize(IDrive *iface, VARIANT *v)
926 {
927 struct drive *This = impl_from_IDrive(iface);
928 ULARGE_INTEGER total;
929
930 TRACE("(%p)->(%p)\n", This, v);
931
932 if (!v)
933 return E_POINTER;
934
935 if (!GetDiskFreeSpaceExW(This->root, NULL, &total, NULL))
936 return E_FAIL;
937
938 V_VT(v) = VT_R8;
939 return VarR8FromUI8(total.QuadPart, &V_R8(v));
940 }
941
942 static HRESULT WINAPI drive_get_VolumeName(IDrive *iface, BSTR *name)
943 {
944 struct drive *This = impl_from_IDrive(iface);
945 FIXME("(%p)->(%p): stub\n", This, name);
946 return E_NOTIMPL;
947 }
948
949 static HRESULT WINAPI drive_put_VolumeName(IDrive *iface, BSTR name)
950 {
951 struct drive *This = impl_from_IDrive(iface);
952 FIXME("(%p)->(%s): stub\n", This, debugstr_w(name));
953 return E_NOTIMPL;
954 }
955
956 static HRESULT WINAPI drive_get_FileSystem(IDrive *iface, BSTR *fs)
957 {
958 struct drive *This = impl_from_IDrive(iface);
959 FIXME("(%p)->(%p): stub\n", This, fs);
960 return E_NOTIMPL;
961 }
962
963 static HRESULT WINAPI drive_get_SerialNumber(IDrive *iface, LONG *serial)
964 {
965 struct drive *This = impl_from_IDrive(iface);
966 FIXME("(%p)->(%p): stub\n", This, serial);
967 return E_NOTIMPL;
968 }
969
970 static HRESULT WINAPI drive_get_IsReady(IDrive *iface, VARIANT_BOOL *ready)
971 {
972 struct drive *This = impl_from_IDrive(iface);
973 ULARGE_INTEGER freespace;
974 BOOL ret;
975
976 TRACE("(%p)->(%p)\n", This, ready);
977
978 if (!ready)
979 return E_POINTER;
980
981 ret = GetDiskFreeSpaceExW(This->root, &freespace, NULL, NULL);
982 *ready = ret ? VARIANT_TRUE : VARIANT_FALSE;
983 return S_OK;
984 }
985
986 static const IDriveVtbl drivevtbl = {
987 drive_QueryInterface,
988 drive_AddRef,
989 drive_Release,
990 drive_GetTypeInfoCount,
991 drive_GetTypeInfo,
992 drive_GetIDsOfNames,
993 drive_Invoke,
994 drive_get_Path,
995 drive_get_DriveLetter,
996 drive_get_ShareName,
997 drive_get_DriveType,
998 drive_get_RootFolder,
999 drive_get_AvailableSpace,
1000 drive_get_FreeSpace,
1001 drive_get_TotalSize,
1002 drive_get_VolumeName,
1003 drive_put_VolumeName,
1004 drive_get_FileSystem,
1005 drive_get_SerialNumber,
1006 drive_get_IsReady
1007 };
1008
1009 static HRESULT create_drive(WCHAR letter, IDrive **drive)
1010 {
1011 struct drive *This;
1012
1013 *drive = NULL;
1014
1015 This = heap_alloc(sizeof(*This));
1016 if (!This) return E_OUTOFMEMORY;
1017
1018 This->IDrive_iface.lpVtbl = &drivevtbl;
1019 This->ref = 1;
1020 This->root = SysAllocStringLen(NULL, 3);
1021 if (!This->root)
1022 {
1023 heap_free(This);
1024 return E_OUTOFMEMORY;
1025 }
1026 This->root[0] = letter;
1027 This->root[1] = ':';
1028 This->root[2] = '\\';
1029 This->root[3] = 0;
1030
1031 *drive = &This->IDrive_iface;
1032 return S_OK;
1033 }
1034
1035 static HRESULT WINAPI enumvariant_QueryInterface(IEnumVARIANT *iface, REFIID riid, void **obj)
1036 {
1037 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
1038
1039 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
1040
1041 *obj = NULL;
1042
1043 if (IsEqualIID( riid, &IID_IEnumVARIANT ) ||
1044 IsEqualIID( riid, &IID_IUnknown ))
1045 {
1046 *obj = iface;
1047 IEnumVARIANT_AddRef(iface);
1048 }
1049 else
1050 return E_NOINTERFACE;
1051
1052 return S_OK;
1053 }
1054
1055 static ULONG WINAPI enumvariant_AddRef(IEnumVARIANT *iface)
1056 {
1057 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
1058 ULONG ref = InterlockedIncrement(&This->ref);
1059 TRACE("(%p)->(%d)\n", This, ref);
1060 return ref;
1061 }
1062
1063 static ULONG WINAPI foldercoll_enumvariant_Release(IEnumVARIANT *iface)
1064 {
1065 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
1066 ULONG ref = InterlockedDecrement(&This->ref);
1067
1068 TRACE("(%p)->(%d)\n", This, ref);
1069
1070 if (!ref)
1071 {
1072 IFolderCollection_Release(&This->data.u.foldercoll.coll->IFolderCollection_iface);
1073 FindClose(This->data.u.foldercoll.find);
1074 heap_free(This);
1075 }
1076
1077 return ref;
1078 }
1079
1080 static HANDLE start_enumeration(const WCHAR *path, WIN32_FIND_DATAW *data, BOOL file)
1081 {
1082 static const WCHAR allW[] = {'*',0};
1083 WCHAR pathW[MAX_PATH];
1084 int len;
1085 HANDLE handle;
1086
1087 strcpyW(pathW, path);
1088 len = strlenW(pathW);
1089 if (pathW[len-1] != '\\')
1090 strcatW(pathW, bsW);
1091 strcatW(pathW, allW);
1092 handle = FindFirstFileW(pathW, data);
1093 if (handle == INVALID_HANDLE_VALUE) return 0;
1094
1095 /* find first dir/file */
1096 while (1)
1097 {
1098 if (file ? is_file_data(data) : is_dir_data(data))
1099 break;
1100
1101 if (!FindNextFileW(handle, data))
1102 {
1103 FindClose(handle);
1104 return 0;
1105 }
1106 }
1107 return handle;
1108 }
1109
1110 static HRESULT WINAPI foldercoll_enumvariant_Next(IEnumVARIANT *iface, ULONG celt, VARIANT *var, ULONG *fetched)
1111 {
1112 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
1113 HANDLE handle = This->data.u.foldercoll.find;
1114 WIN32_FIND_DATAW data;
1115 ULONG count = 0;
1116
1117 TRACE("(%p)->(%d %p %p)\n", This, celt, var, fetched);
1118
1119 if (fetched)
1120 *fetched = 0;
1121
1122 if (!celt) return S_OK;
1123
1124 if (!handle)
1125 {
1126 handle = start_enumeration(This->data.u.foldercoll.coll->path, &data, FALSE);
1127 if (!handle) return S_FALSE;
1128
1129 This->data.u.foldercoll.find = handle;
1130 }
1131 else
1132 {
1133 if (!FindNextFileW(handle, &data))
1134 return S_FALSE;
1135 }
1136
1137 do
1138 {
1139 if (is_dir_data(&data))
1140 {
1141 IFolder *folder;
1142 HRESULT hr;
1143 BSTR str;
1144
1145 str = get_full_path(This->data.u.foldercoll.coll->path, &data);
1146 hr = create_folder(str, &folder);
1147 SysFreeString(str);
1148 if (FAILED(hr)) return hr;
1149
1150 V_VT(&var[count]) = VT_DISPATCH;
1151 V_DISPATCH(&var[count]) = (IDispatch*)folder;
1152 count++;
1153
1154 if (count >= celt) break;
1155 }
1156 } while (FindNextFileW(handle, &data));
1157
1158 if (fetched)
1159 *fetched = count;
1160
1161 return (count < celt) ? S_FALSE : S_OK;
1162 }
1163
1164 static HRESULT WINAPI foldercoll_enumvariant_Skip(IEnumVARIANT *iface, ULONG celt)
1165 {
1166 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
1167 HANDLE handle = This->data.u.foldercoll.find;
1168 WIN32_FIND_DATAW data;
1169
1170 TRACE("(%p)->(%d)\n", This, celt);
1171
1172 if (!celt) return S_OK;
1173
1174 if (!handle)
1175 {
1176 handle = start_enumeration(This->data.u.foldercoll.coll->path, &data, FALSE);
1177 if (!handle) return S_FALSE;
1178
1179 This->data.u.foldercoll.find = handle;
1180 }
1181 else
1182 {
1183 if (!FindNextFileW(handle, &data))
1184 return S_FALSE;
1185 }
1186
1187 do
1188 {
1189 if (is_dir_data(&data))
1190 --celt;
1191
1192 if (!celt) break;
1193 } while (FindNextFileW(handle, &data));
1194
1195 return celt ? S_FALSE : S_OK;
1196 }
1197
1198 static HRESULT WINAPI foldercoll_enumvariant_Reset(IEnumVARIANT *iface)
1199 {
1200 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
1201
1202 TRACE("(%p)\n", This);
1203
1204 FindClose(This->data.u.foldercoll.find);
1205 This->data.u.foldercoll.find = NULL;
1206
1207 return S_OK;
1208 }
1209
1210 static HRESULT WINAPI foldercoll_enumvariant_Clone(IEnumVARIANT *iface, IEnumVARIANT **pclone)
1211 {
1212 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
1213 TRACE("(%p)->(%p)\n", This, pclone);
1214 return create_foldercoll_enum(This->data.u.foldercoll.coll, (IUnknown**)pclone);
1215 }
1216
1217 static const IEnumVARIANTVtbl foldercollenumvariantvtbl = {
1218 enumvariant_QueryInterface,
1219 enumvariant_AddRef,
1220 foldercoll_enumvariant_Release,
1221 foldercoll_enumvariant_Next,
1222 foldercoll_enumvariant_Skip,
1223 foldercoll_enumvariant_Reset,
1224 foldercoll_enumvariant_Clone
1225 };
1226
1227 static HRESULT create_foldercoll_enum(struct foldercollection *collection, IUnknown **newenum)
1228 {
1229 struct enumvariant *This;
1230
1231 *newenum = NULL;
1232
1233 This = heap_alloc(sizeof(*This));
1234 if (!This) return E_OUTOFMEMORY;
1235
1236 This->IEnumVARIANT_iface.lpVtbl = &foldercollenumvariantvtbl;
1237 This->ref = 1;
1238 This->data.u.foldercoll.find = NULL;
1239 This->data.u.foldercoll.coll = collection;
1240 IFolderCollection_AddRef(&collection->IFolderCollection_iface);
1241
1242 *newenum = (IUnknown*)&This->IEnumVARIANT_iface;
1243
1244 return S_OK;
1245 }
1246
1247 static ULONG WINAPI filecoll_enumvariant_Release(IEnumVARIANT *iface)
1248 {
1249 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
1250 ULONG ref = InterlockedDecrement(&This->ref);
1251
1252 TRACE("(%p)->(%d)\n", This, ref);
1253
1254 if (!ref)
1255 {
1256 IFileCollection_Release(&This->data.u.filecoll.coll->IFileCollection_iface);
1257 FindClose(This->data.u.filecoll.find);
1258 heap_free(This);
1259 }
1260
1261 return ref;
1262 }
1263
1264 static HRESULT WINAPI filecoll_enumvariant_Next(IEnumVARIANT *iface, ULONG celt, VARIANT *var, ULONG *fetched)
1265 {
1266 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
1267 HANDLE handle = This->data.u.filecoll.find;
1268 WIN32_FIND_DATAW data;
1269 ULONG count = 0;
1270
1271 TRACE("(%p)->(%d %p %p)\n", This, celt, var, fetched);
1272
1273 if (fetched)
1274 *fetched = 0;
1275
1276 if (!celt) return S_OK;
1277
1278 if (!handle)
1279 {
1280 handle = start_enumeration(This->data.u.filecoll.coll->path, &data, TRUE);
1281 if (!handle) return S_FALSE;
1282 This->data.u.filecoll.find = handle;
1283 }
1284 else if (!FindNextFileW(handle, &data))
1285 return S_FALSE;
1286
1287 do
1288 {
1289 if (is_file_data(&data))
1290 {
1291 IFile *file;
1292 HRESULT hr;
1293 BSTR str;
1294
1295 str = get_full_path(This->data.u.filecoll.coll->path, &data);
1296 hr = create_file(str, &file);
1297 SysFreeString(str);
1298 if (FAILED(hr)) return hr;
1299
1300 V_VT(&var[count]) = VT_DISPATCH;
1301 V_DISPATCH(&var[count]) = (IDispatch*)file;
1302 if (++count >= celt) break;
1303 }
1304 } while (FindNextFileW(handle, &data));
1305
1306 if (fetched)
1307 *fetched = count;
1308
1309 return (count < celt) ? S_FALSE : S_OK;
1310 }
1311
1312 static HRESULT WINAPI filecoll_enumvariant_Skip(IEnumVARIANT *iface, ULONG celt)
1313 {
1314 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
1315 HANDLE handle = This->data.u.filecoll.find;
1316 WIN32_FIND_DATAW data;
1317
1318 TRACE("(%p)->(%d)\n", This, celt);
1319
1320 if (!celt) return S_OK;
1321
1322 if (!handle)
1323 {
1324 handle = start_enumeration(This->data.u.filecoll.coll->path, &data, TRUE);
1325 if (!handle) return S_FALSE;
1326 This->data.u.filecoll.find = handle;
1327 }
1328 else if (!FindNextFileW(handle, &data))
1329 return S_FALSE;
1330
1331 do
1332 {
1333 if (is_file_data(&data))
1334 --celt;
1335 } while (celt && FindNextFileW(handle, &data));
1336
1337 return celt ? S_FALSE : S_OK;
1338 }
1339
1340 static HRESULT WINAPI filecoll_enumvariant_Reset(IEnumVARIANT *iface)
1341 {
1342 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
1343
1344 TRACE("(%p)\n", This);
1345
1346 FindClose(This->data.u.filecoll.find);
1347 This->data.u.filecoll.find = NULL;
1348
1349 return S_OK;
1350 }
1351
1352 static HRESULT WINAPI filecoll_enumvariant_Clone(IEnumVARIANT *iface, IEnumVARIANT **pclone)
1353 {
1354 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
1355 TRACE("(%p)->(%p)\n", This, pclone);
1356 return create_filecoll_enum(This->data.u.filecoll.coll, (IUnknown**)pclone);
1357 }
1358
1359 static const IEnumVARIANTVtbl filecollenumvariantvtbl = {
1360 enumvariant_QueryInterface,
1361 enumvariant_AddRef,
1362 filecoll_enumvariant_Release,
1363 filecoll_enumvariant_Next,
1364 filecoll_enumvariant_Skip,
1365 filecoll_enumvariant_Reset,
1366 filecoll_enumvariant_Clone
1367 };
1368
1369 static HRESULT create_filecoll_enum(struct filecollection *collection, IUnknown **newenum)
1370 {
1371 struct enumvariant *This;
1372
1373 *newenum = NULL;
1374
1375 This = heap_alloc(sizeof(*This));
1376 if (!This) return E_OUTOFMEMORY;
1377
1378 This->IEnumVARIANT_iface.lpVtbl = &filecollenumvariantvtbl;
1379 This->ref = 1;
1380 This->data.u.filecoll.find = NULL;
1381 This->data.u.filecoll.coll = collection;
1382 IFileCollection_AddRef(&collection->IFileCollection_iface);
1383
1384 *newenum = (IUnknown*)&This->IEnumVARIANT_iface;
1385
1386 return S_OK;
1387 }
1388
1389 static ULONG WINAPI drivecoll_enumvariant_Release(IEnumVARIANT *iface)
1390 {
1391 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
1392 ULONG ref = InterlockedDecrement(&This->ref);
1393
1394 TRACE("(%p)->(%d)\n", This, ref);
1395
1396 if (!ref)
1397 {
1398 IDriveCollection_Release(&This->data.u.drivecoll.coll->IDriveCollection_iface);
1399 heap_free(This);
1400 }
1401
1402 return ref;
1403 }
1404
1405 static HRESULT find_next_drive(struct enumvariant *penum)
1406 {
1407 int i = penum->data.u.drivecoll.cur == -1 ? 0 : penum->data.u.drivecoll.cur + 1;
1408
1409 for (; i < 32; i++)
1410 if (penum->data.u.drivecoll.coll->drives & (1 << i))
1411 {
1412 penum->data.u.drivecoll.cur = i;
1413 return S_OK;
1414 }
1415
1416 return S_FALSE;
1417 }
1418
1419 static HRESULT WINAPI drivecoll_enumvariant_Next(IEnumVARIANT *iface, ULONG celt, VARIANT *var, ULONG *fetched)
1420 {
1421 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
1422 ULONG count = 0;
1423
1424 TRACE("(%p)->(%d %p %p)\n", This, celt, var, fetched);
1425
1426 if (fetched)
1427 *fetched = 0;
1428
1429 if (!celt) return S_OK;
1430
1431 while (find_next_drive(This) == S_OK)
1432 {
1433 IDrive *drive;
1434 HRESULT hr;
1435
1436 hr = create_drive('A' + This->data.u.drivecoll.cur, &drive);
1437 if (FAILED(hr)) return hr;
1438
1439 V_VT(&var[count]) = VT_DISPATCH;
1440 V_DISPATCH(&var[count]) = (IDispatch*)drive;
1441
1442 if (++count >= celt) break;
1443 }
1444
1445 if (fetched)
1446 *fetched = count;
1447
1448 return (count < celt) ? S_FALSE : S_OK;
1449 }
1450
1451 static HRESULT WINAPI drivecoll_enumvariant_Skip(IEnumVARIANT *iface, ULONG celt)
1452 {
1453 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
1454
1455 TRACE("(%p)->(%d)\n", This, celt);
1456
1457 if (!celt) return S_OK;
1458
1459 while (celt && find_next_drive(This) == S_OK)
1460 celt--;
1461
1462 return celt ? S_FALSE : S_OK;
1463 }
1464
1465 static HRESULT WINAPI drivecoll_enumvariant_Reset(IEnumVARIANT *iface)
1466 {
1467 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
1468
1469 TRACE("(%p)\n", This);
1470
1471 This->data.u.drivecoll.cur = -1;
1472 return S_OK;
1473 }
1474
1475 static HRESULT WINAPI drivecoll_enumvariant_Clone(IEnumVARIANT *iface, IEnumVARIANT **pclone)
1476 {
1477 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
1478 FIXME("(%p)->(%p): stub\n", This, pclone);
1479 return E_NOTIMPL;
1480 }
1481
1482 static const IEnumVARIANTVtbl drivecollenumvariantvtbl = {
1483 enumvariant_QueryInterface,
1484 enumvariant_AddRef,
1485 drivecoll_enumvariant_Release,
1486 drivecoll_enumvariant_Next,
1487 drivecoll_enumvariant_Skip,
1488 drivecoll_enumvariant_Reset,
1489 drivecoll_enumvariant_Clone
1490 };
1491
1492 static HRESULT create_drivecoll_enum(struct drivecollection *collection, IUnknown **newenum)
1493 {
1494 struct enumvariant *This;
1495
1496 *newenum = NULL;
1497
1498 This = heap_alloc(sizeof(*This));
1499 if (!This) return E_OUTOFMEMORY;
1500
1501 This->IEnumVARIANT_iface.lpVtbl = &drivecollenumvariantvtbl;
1502 This->ref = 1;
1503 This->data.u.drivecoll.coll = collection;
1504 This->data.u.drivecoll.cur = -1;
1505 IDriveCollection_AddRef(&collection->IDriveCollection_iface);
1506
1507 *newenum = (IUnknown*)&This->IEnumVARIANT_iface;
1508
1509 return S_OK;
1510 }
1511
1512 static HRESULT WINAPI foldercoll_QueryInterface(IFolderCollection *iface, REFIID riid, void **obj)
1513 {
1514 struct foldercollection *This = impl_from_IFolderCollection(iface);
1515
1516 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
1517
1518 *obj = NULL;
1519
1520 if (IsEqualIID( riid, &IID_IFolderCollection ) ||
1521 IsEqualIID( riid, &IID_IDispatch ) ||
1522 IsEqualIID( riid, &IID_IUnknown ))
1523 {
1524 *obj = iface;
1525 IFolderCollection_AddRef(iface);
1526 }
1527 else
1528 return E_NOINTERFACE;
1529
1530 return S_OK;
1531 }
1532
1533 static ULONG WINAPI foldercoll_AddRef(IFolderCollection *iface)
1534 {
1535 struct foldercollection *This = impl_from_IFolderCollection(iface);
1536 ULONG ref = InterlockedIncrement(&This->ref);
1537 TRACE("(%p)->(%d)\n", This, ref);
1538 return ref;
1539 }
1540
1541 static ULONG WINAPI foldercoll_Release(IFolderCollection *iface)
1542 {
1543 struct foldercollection *This = impl_from_IFolderCollection(iface);
1544 ULONG ref = InterlockedDecrement(&This->ref);
1545 TRACE("(%p)->(%d)\n", This, ref);
1546
1547 if (!ref)
1548 {
1549 SysFreeString(This->path);
1550 heap_free(This);
1551 }
1552
1553 return ref;
1554 }
1555
1556 static HRESULT WINAPI foldercoll_GetTypeInfoCount(IFolderCollection *iface, UINT *pctinfo)
1557 {
1558 struct foldercollection *This = impl_from_IFolderCollection(iface);
1559 TRACE("(%p)->(%p)\n", This, pctinfo);
1560 *pctinfo = 1;
1561 return S_OK;
1562 }
1563
1564 static HRESULT WINAPI foldercoll_GetTypeInfo(IFolderCollection *iface, UINT iTInfo,
1565 LCID lcid, ITypeInfo **ppTInfo)
1566 {
1567 struct foldercollection *This = impl_from_IFolderCollection(iface);
1568 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1569 return get_typeinfo(IFolderCollection_tid, ppTInfo);
1570 }
1571
1572 static HRESULT WINAPI foldercoll_GetIDsOfNames(IFolderCollection *iface, REFIID riid,
1573 LPOLESTR *rgszNames, UINT cNames,
1574 LCID lcid, DISPID *rgDispId)
1575 {
1576 struct foldercollection *This = impl_from_IFolderCollection(iface);
1577 ITypeInfo *typeinfo;
1578 HRESULT hr;
1579
1580 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
1581
1582 hr = get_typeinfo(IFolderCollection_tid, &typeinfo);
1583 if(SUCCEEDED(hr))
1584 {
1585 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1586 ITypeInfo_Release(typeinfo);
1587 }
1588
1589 return hr;
1590 }
1591
1592 static HRESULT WINAPI foldercoll_Invoke(IFolderCollection *iface, DISPID dispIdMember,
1593 REFIID riid, LCID lcid, WORD wFlags,
1594 DISPPARAMS *pDispParams, VARIANT *pVarResult,
1595 EXCEPINFO *pExcepInfo, UINT *puArgErr)
1596 {
1597 struct foldercollection *This = impl_from_IFolderCollection(iface);
1598 ITypeInfo *typeinfo;
1599 HRESULT hr;
1600
1601 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1602 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1603
1604 hr = get_typeinfo(IFolderCollection_tid, &typeinfo);
1605 if(SUCCEEDED(hr))
1606 {
1607 hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
1608 pDispParams, pVarResult, pExcepInfo, puArgErr);
1609 ITypeInfo_Release(typeinfo);
1610 }
1611
1612 return hr;
1613 }
1614
1615 static HRESULT WINAPI foldercoll_Add(IFolderCollection *iface, BSTR name, IFolder **folder)
1616 {
1617 struct foldercollection *This = impl_from_IFolderCollection(iface);
1618 FIXME("(%p)->(%s %p): stub\n", This, debugstr_w(name), folder);
1619 return E_NOTIMPL;
1620 }
1621
1622 static HRESULT WINAPI foldercoll_get_Item(IFolderCollection *iface, VARIANT key, IFolder **folder)
1623 {
1624 struct foldercollection *This = impl_from_IFolderCollection(iface);
1625 FIXME("(%p)->(%p): stub\n", This, folder);
1626 return E_NOTIMPL;
1627 }
1628
1629 static HRESULT WINAPI foldercoll_get__NewEnum(IFolderCollection *iface, IUnknown **newenum)
1630 {
1631 struct foldercollection *This = impl_from_IFolderCollection(iface);
1632
1633 TRACE("(%p)->(%p)\n", This, newenum);
1634
1635 if(!newenum)
1636 return E_POINTER;
1637
1638 return create_foldercoll_enum(This, newenum);
1639 }
1640
1641 static HRESULT WINAPI foldercoll_get_Count(IFolderCollection *iface, LONG *count)
1642 {
1643 struct foldercollection *This = impl_from_IFolderCollection(iface);
1644 static const WCHAR allW[] = {'\\','*',0};
1645 WIN32_FIND_DATAW data;
1646 WCHAR pathW[MAX_PATH];
1647 HANDLE handle;
1648
1649 TRACE("(%p)->(%p)\n", This, count);
1650
1651 if(!count)
1652 return E_POINTER;
1653
1654 *count = 0;
1655
1656 strcpyW(pathW, This->path);
1657 strcatW(pathW, allW);
1658 handle = FindFirstFileW(pathW, &data);
1659 if (handle == INVALID_HANDLE_VALUE)
1660 return HRESULT_FROM_WIN32(GetLastError());
1661
1662 do
1663 {
1664 if (is_dir_data(&data))
1665 *count += 1;
1666 } while (FindNextFileW(handle, &data));
1667 FindClose(handle);
1668
1669 return S_OK;
1670 }
1671
1672 static const IFolderCollectionVtbl foldercollvtbl = {
1673 foldercoll_QueryInterface,
1674 foldercoll_AddRef,
1675 foldercoll_Release,
1676 foldercoll_GetTypeInfoCount,
1677 foldercoll_GetTypeInfo,
1678 foldercoll_GetIDsOfNames,
1679 foldercoll_Invoke,
1680 foldercoll_Add,
1681 foldercoll_get_Item,
1682 foldercoll_get__NewEnum,
1683 foldercoll_get_Count
1684 };
1685
1686 static HRESULT create_foldercoll(BSTR path, IFolderCollection **folders)
1687 {
1688 struct foldercollection *This;
1689
1690 *folders = NULL;
1691
1692 This = heap_alloc(sizeof(struct foldercollection));
1693 if (!This) return E_OUTOFMEMORY;
1694
1695 This->IFolderCollection_iface.lpVtbl = &foldercollvtbl;
1696 This->ref = 1;
1697 This->path = SysAllocString(path);
1698 if (!This->path)
1699 {
1700 heap_free(This);
1701 return E_OUTOFMEMORY;
1702 }
1703
1704 *folders = &This->IFolderCollection_iface;
1705
1706 return S_OK;
1707 }
1708
1709 static HRESULT WINAPI filecoll_QueryInterface(IFileCollection *iface, REFIID riid, void **obj)
1710 {
1711 struct filecollection *This = impl_from_IFileCollection(iface);
1712
1713 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
1714
1715 *obj = NULL;
1716
1717 if (IsEqualIID( riid, &IID_IFileCollection ) ||
1718 IsEqualIID( riid, &IID_IDispatch ) ||
1719 IsEqualIID( riid, &IID_IUnknown ))
1720 {
1721 *obj = iface;
1722 IFileCollection_AddRef(iface);
1723 }
1724 else
1725 return E_NOINTERFACE;
1726
1727 return S_OK;
1728 }
1729
1730 static ULONG WINAPI filecoll_AddRef(IFileCollection *iface)
1731 {
1732 struct filecollection *This = impl_from_IFileCollection(iface);
1733 ULONG ref = InterlockedIncrement(&This->ref);
1734 TRACE("(%p)->(%d)\n", This, ref);
1735 return ref;
1736 }
1737
1738 static ULONG WINAPI filecoll_Release(IFileCollection *iface)
1739 {
1740 struct filecollection *This = impl_from_IFileCollection(iface);
1741 ULONG ref = InterlockedDecrement(&This->ref);
1742 TRACE("(%p)->(%d)\n", This, ref);
1743
1744 if (!ref)
1745 {
1746 SysFreeString(This->path);
1747 heap_free(This);
1748 }
1749
1750 return ref;
1751 }
1752
1753 static HRESULT WINAPI filecoll_GetTypeInfoCount(IFileCollection *iface, UINT *pctinfo)
1754 {
1755 struct filecollection *This = impl_from_IFileCollection(iface);
1756 TRACE("(%p)->(%p)\n", This, pctinfo);
1757 *pctinfo = 1;
1758 return S_OK;
1759 }
1760
1761 static HRESULT WINAPI filecoll_GetTypeInfo(IFileCollection *iface, UINT iTInfo,
1762 LCID lcid, ITypeInfo **ppTInfo)
1763 {
1764 struct filecollection *This = impl_from_IFileCollection(iface);
1765 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1766 return get_typeinfo(IFileCollection_tid, ppTInfo);
1767 }
1768
1769 static HRESULT WINAPI filecoll_GetIDsOfNames(IFileCollection *iface, REFIID riid,
1770 LPOLESTR *rgszNames, UINT cNames,
1771 LCID lcid, DISPID *rgDispId)
1772 {
1773 struct filecollection *This = impl_from_IFileCollection(iface);
1774 ITypeInfo *typeinfo;
1775 HRESULT hr;
1776
1777 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
1778
1779 hr = get_typeinfo(IFileCollection_tid, &typeinfo);
1780 if(SUCCEEDED(hr))
1781 {
1782 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1783 ITypeInfo_Release(typeinfo);
1784 }
1785
1786 return hr;
1787 }
1788
1789 static HRESULT WINAPI filecoll_Invoke(IFileCollection *iface, DISPID dispIdMember,
1790 REFIID riid, LCID lcid, WORD wFlags,
1791 DISPPARAMS *pDispParams, VARIANT *pVarResult,
1792 EXCEPINFO *pExcepInfo, UINT *puArgErr)
1793 {
1794 struct filecollection *This = impl_from_IFileCollection(iface);
1795 ITypeInfo *typeinfo;
1796 HRESULT hr;
1797
1798 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1799 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1800
1801 hr = get_typeinfo(IFileCollection_tid, &typeinfo);
1802 if(SUCCEEDED(hr))
1803 {
1804 hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
1805 pDispParams, pVarResult, pExcepInfo, puArgErr);
1806 ITypeInfo_Release(typeinfo);
1807 }
1808
1809 return hr;
1810 }
1811
1812 static HRESULT WINAPI filecoll_get_Item(IFileCollection *iface, VARIANT Key, IFile **file)
1813 {
1814 struct filecollection *This = impl_from_IFileCollection(iface);
1815 FIXME("(%p)->(%p)\n", This, file);
1816 return E_NOTIMPL;
1817 }
1818
1819 static HRESULT WINAPI filecoll_get__NewEnum(IFileCollection *iface, IUnknown **ppenum)
1820 {
1821 struct filecollection *This = impl_from_IFileCollection(iface);
1822
1823 TRACE("(%p)->(%p)\n", This, ppenum);
1824
1825 if(!ppenum)
1826 return E_POINTER;
1827
1828 return create_filecoll_enum(This, ppenum);
1829 }
1830
1831 static HRESULT WINAPI filecoll_get_Count(IFileCollection *iface, LONG *count)
1832 {
1833 struct filecollection *This = impl_from_IFileCollection(iface);
1834 FIXME("(%p)->(%p)\n", This, count);
1835 return E_NOTIMPL;
1836 }
1837
1838 static const IFileCollectionVtbl filecollectionvtbl = {
1839 filecoll_QueryInterface,
1840 filecoll_AddRef,
1841 filecoll_Release,
1842 filecoll_GetTypeInfoCount,
1843 filecoll_GetTypeInfo,
1844 filecoll_GetIDsOfNames,
1845 filecoll_Invoke,
1846 filecoll_get_Item,
1847 filecoll_get__NewEnum,
1848 filecoll_get_Count
1849 };
1850
1851 static HRESULT create_filecoll(BSTR path, IFileCollection **files)
1852 {
1853 struct filecollection *This;
1854
1855 *files = NULL;
1856
1857 This = heap_alloc(sizeof(*This));
1858 if (!This) return E_OUTOFMEMORY;
1859
1860 This->IFileCollection_iface.lpVtbl = &filecollectionvtbl;
1861 This->ref = 1;
1862 This->path = SysAllocString(path);
1863 if (!This->path)
1864 {
1865 heap_free(This);
1866 return E_OUTOFMEMORY;
1867 }
1868
1869 *files = &This->IFileCollection_iface;
1870 return S_OK;
1871 }
1872
1873 static HRESULT WINAPI drivecoll_QueryInterface(IDriveCollection *iface, REFIID riid, void **obj)
1874 {
1875 struct drivecollection *This = impl_from_IDriveCollection(iface);
1876
1877 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
1878
1879 *obj = NULL;
1880
1881 if (IsEqualIID( riid, &IID_IDriveCollection ) ||
1882 IsEqualIID( riid, &IID_IDispatch ) ||
1883 IsEqualIID( riid, &IID_IUnknown ))
1884 {
1885 *obj = iface;
1886 IDriveCollection_AddRef(iface);
1887 }
1888 else
1889 return E_NOINTERFACE;
1890
1891 return S_OK;
1892 }
1893
1894 static ULONG WINAPI drivecoll_AddRef(IDriveCollection *iface)
1895 {
1896 struct drivecollection *This = impl_from_IDriveCollection(iface);
1897 ULONG ref = InterlockedIncrement(&This->ref);
1898 TRACE("(%p)->(%d)\n", This, ref);
1899 return ref;
1900 }
1901
1902 static ULONG WINAPI drivecoll_Release(IDriveCollection *iface)
1903 {
1904 struct drivecollection *This = impl_from_IDriveCollection(iface);
1905 ULONG ref = InterlockedDecrement(&This->ref);
1906 TRACE("(%p)->(%d)\n", This, ref);
1907
1908 if (!ref)
1909 heap_free(This);
1910
1911 return ref;
1912 }
1913
1914 static HRESULT WINAPI drivecoll_GetTypeInfoCount(IDriveCollection *iface, UINT *pctinfo)
1915 {
1916 struct drivecollection *This = impl_from_IDriveCollection(iface);
1917 TRACE("(%p)->(%p)\n", This, pctinfo);
1918 *pctinfo = 1;
1919 return S_OK;
1920 }
1921
1922 static HRESULT WINAPI drivecoll_GetTypeInfo(IDriveCollection *iface, UINT iTInfo,
1923 LCID lcid, ITypeInfo **ppTInfo)
1924 {
1925 struct drivecollection *This = impl_from_IDriveCollection(iface);
1926 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1927 return get_typeinfo(IDriveCollection_tid, ppTInfo);
1928 }
1929
1930 static HRESULT WINAPI drivecoll_GetIDsOfNames(IDriveCollection *iface, REFIID riid,
1931 LPOLESTR *rgszNames, UINT cNames,
1932 LCID lcid, DISPID *rgDispId)
1933 {
1934 struct drivecollection *This = impl_from_IDriveCollection(iface);
1935 ITypeInfo *typeinfo;
1936 HRESULT hr;
1937
1938 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
1939
1940 hr = get_typeinfo(IDriveCollection_tid, &typeinfo);
1941 if(SUCCEEDED(hr))
1942 {
1943 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1944 ITypeInfo_Release(typeinfo);
1945 }
1946
1947 return hr;
1948 }
1949
1950 static HRESULT WINAPI drivecoll_Invoke(IDriveCollection *iface, DISPID dispIdMember,
1951 REFIID riid, LCID lcid, WORD wFlags,
1952 DISPPARAMS *pDispParams, VARIANT *pVarResult,
1953 EXCEPINFO *pExcepInfo, UINT *puArgErr)
1954 {
1955 struct drivecollection *This = impl_from_IDriveCollection(iface);
1956 ITypeInfo *typeinfo;
1957 HRESULT hr;
1958
1959 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1960 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1961
1962 hr = get_typeinfo(IDriveCollection_tid, &typeinfo);
1963 if(SUCCEEDED(hr))
1964 {
1965 hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
1966 pDispParams, pVarResult, pExcepInfo, puArgErr);
1967 ITypeInfo_Release(typeinfo);
1968 }
1969
1970 return hr;
1971 }
1972
1973 static HRESULT WINAPI drivecoll_get_Item(IDriveCollection *iface, VARIANT key, IDrive **drive)
1974 {
1975 struct drivecollection *This = impl_from_IDriveCollection(iface);
1976 FIXME("(%p)->(%p): stub\n", This, drive);
1977 return E_NOTIMPL;
1978 }
1979
1980 static HRESULT WINAPI drivecoll_get__NewEnum(IDriveCollection *iface, IUnknown **ppenum)
1981 {
1982 struct drivecollection *This = impl_from_IDriveCollection(iface);
1983
1984 TRACE("(%p)->(%p)\n", This, ppenum);
1985
1986 if(!ppenum)
1987 return E_POINTER;
1988
1989 return create_drivecoll_enum(This, ppenum);
1990 }
1991
1992 static HRESULT WINAPI drivecoll_get_Count(IDriveCollection *iface, LONG *count)
1993 {
1994 struct drivecollection *This = impl_from_IDriveCollection(iface);
1995
1996 TRACE("(%p)->(%p)\n", This, count);
1997
1998 if (!count) return E_POINTER;
1999
2000 *count = This->count;
2001 return S_OK;
2002 }
2003
2004 static const IDriveCollectionVtbl drivecollectionvtbl = {
2005 drivecoll_QueryInterface,
2006 drivecoll_AddRef,
2007 drivecoll_Release,
2008 drivecoll_GetTypeInfoCount,
2009 drivecoll_GetTypeInfo,
2010 drivecoll_GetIDsOfNames,
2011 drivecoll_Invoke,
2012 drivecoll_get_Item,
2013 drivecoll_get__NewEnum,
2014 drivecoll_get_Count
2015 };
2016
2017 static HRESULT create_drivecoll(IDriveCollection **drives)
2018 {
2019 struct drivecollection *This;
2020 DWORD mask;
2021
2022 *drives = NULL;
2023
2024 This = heap_alloc(sizeof(*This));
2025 if (!This) return E_OUTOFMEMORY;
2026
2027 This->IDriveCollection_iface.lpVtbl = &drivecollectionvtbl;
2028 This->ref = 1;
2029 This->drives = mask = GetLogicalDrives();
2030 /* count set bits */
2031 for (This->count = 0; mask; This->count++)
2032 mask &= mask - 1;
2033
2034 *drives = &This->IDriveCollection_iface;
2035 return S_OK;
2036 }
2037
2038 static HRESULT WINAPI folder_QueryInterface(IFolder *iface, REFIID riid, void **obj)
2039 {
2040 struct folder *This = impl_from_IFolder(iface);
2041
2042 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
2043
2044 *obj = NULL;
2045
2046 if (IsEqualIID( riid, &IID_IFolder ) ||
2047 IsEqualIID( riid, &IID_IDispatch ) ||
2048 IsEqualIID( riid, &IID_IUnknown))
2049 {
2050 *obj = iface;
2051 IFolder_AddRef(iface);
2052 }
2053 else
2054 return E_NOINTERFACE;
2055
2056 return S_OK;
2057 }
2058
2059 static ULONG WINAPI folder_AddRef(IFolder *iface)
2060 {
2061 struct folder *This = impl_from_IFolder(iface);
2062 ULONG ref = InterlockedIncrement(&This->ref);
2063 TRACE("(%p)->(%d)\n", This, ref);
2064 return ref;
2065 }
2066
2067 static ULONG WINAPI folder_Release(IFolder *iface)
2068 {
2069 struct folder *This = impl_from_IFolder(iface);
2070 ULONG ref = InterlockedDecrement(&This->ref);
2071 TRACE("(%p)->(%d)\n", This, ref);
2072
2073 if (!ref)
2074 {
2075 SysFreeString(This->path);
2076 heap_free(This);
2077 }
2078
2079 return ref;
2080 }
2081
2082 static HRESULT WINAPI folder_GetTypeInfoCount(IFolder *iface, UINT *pctinfo)
2083 {
2084 struct folder *This = impl_from_IFolder(iface);
2085 TRACE("(%p)->(%p)\n", This, pctinfo);
2086 *pctinfo = 1;
2087 return S_OK;
2088 }
2089
2090 static HRESULT WINAPI folder_GetTypeInfo(IFolder *iface, UINT iTInfo,
2091 LCID lcid, ITypeInfo **ppTInfo)
2092 {
2093 struct folder *This = impl_from_IFolder(iface);
2094 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
2095 return get_typeinfo(IFolder_tid, ppTInfo);
2096 }
2097
2098 static HRESULT WINAPI folder_GetIDsOfNames(IFolder *iface, REFIID riid,
2099 LPOLESTR *rgszNames, UINT cNames,
2100 LCID lcid, DISPID *rgDispId)
2101 {
2102 struct folder *This = impl_from_IFolder(iface);
2103 ITypeInfo *typeinfo;
2104 HRESULT hr;
2105
2106 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
2107
2108 hr = get_typeinfo(IFolder_tid, &typeinfo);
2109 if(SUCCEEDED(hr))
2110 {
2111 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
2112 ITypeInfo_Release(typeinfo);
2113 }
2114
2115 return hr;
2116 }
2117
2118 static HRESULT WINAPI folder_Invoke(IFolder *iface, DISPID dispIdMember,
2119 REFIID riid, LCID lcid, WORD wFlags,
2120 DISPPARAMS *pDispParams, VARIANT *pVarResult,
2121 EXCEPINFO *pExcepInfo, UINT *puArgErr)
2122 {
2123 struct folder *This = impl_from_IFolder(iface);
2124 ITypeInfo *typeinfo;
2125 HRESULT hr;
2126
2127 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
2128 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2129
2130 hr = get_typeinfo(IFolder_tid, &typeinfo);
2131 if(SUCCEEDED(hr))
2132 {
2133 hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
2134 pDispParams, pVarResult, pExcepInfo, puArgErr);
2135 ITypeInfo_Release(typeinfo);
2136 }
2137
2138 return hr;
2139 }
2140
2141 static HRESULT WINAPI folder_get_Path(IFolder *iface, BSTR *path)
2142 {
2143 struct folder *This = impl_from_IFolder(iface);
2144
2145 TRACE("(%p)->(%p)\n", This, path);
2146
2147 if(!path)
2148 return E_POINTER;
2149
2150 *path = SysAllocString(This->path);
2151 return *path ? S_OK : E_OUTOFMEMORY;
2152 }
2153
2154 static HRESULT WINAPI folder_get_Name(IFolder *iface, BSTR *name)
2155 {
2156 struct folder *This = impl_from_IFolder(iface);
2157 WCHAR *ptr;
2158
2159 TRACE("(%p)->(%p)\n", This, name);
2160
2161 if(!name)
2162 return E_POINTER;
2163
2164 *name = NULL;
2165
2166 ptr = strrchrW(This->path, '\\');
2167 if (ptr)
2168 {
2169 *name = SysAllocString(ptr+1);
2170 TRACE("%s\n", debugstr_w(*name));
2171 if (!*name) return E_OUTOFMEMORY;
2172 }
2173 else
2174 return E_FAIL;
2175
2176 return S_OK;
2177 }
2178
2179 static HRESULT WINAPI folder_put_Name(IFolder *iface, BSTR name)
2180 {
2181 struct folder *This = impl_from_IFolder(iface);
2182 FIXME("(%p)->(%s): stub\n", This, debugstr_w(name));
2183 return E_NOTIMPL;
2184 }
2185
2186 static HRESULT WINAPI folder_get_ShortPath(IFolder *iface, BSTR *path)
2187 {
2188 struct folder *This = impl_from_IFolder(iface);
2189 FIXME("(%p)->(%p): stub\n", This, path);
2190 return E_NOTIMPL;
2191 }
2192
2193 static HRESULT WINAPI folder_get_ShortName(IFolder *iface, BSTR *name)
2194 {
2195 struct folder *This = impl_from_IFolder(iface);
2196 FIXME("(%p)->(%p): stub\n", This, name);
2197 return E_NOTIMPL;
2198 }
2199
2200 static HRESULT WINAPI folder_get_Drive(IFolder *iface, IDrive **drive)
2201 {
2202 struct folder *This = impl_from_IFolder(iface);
2203 FIXME("(%p)->(%p): stub\n", This, drive);
2204 return E_NOTIMPL;
2205 }
2206
2207 static HRESULT WINAPI folder_get_ParentFolder(IFolder *iface, IFolder **parent)
2208 {
2209 struct folder *This = impl_from_IFolder(iface);
2210 FIXME("(%p)->(%p): stub\n", This, parent);
2211 return E_NOTIMPL;
2212 }
2213
2214 static HRESULT WINAPI folder_get_Attributes(IFolder *iface, FileAttribute *attr)
2215 {
2216 struct folder *This = impl_from_IFolder(iface);
2217 FIXME("(%p)->(%p): stub\n", This, attr);
2218 return E_NOTIMPL;
2219 }
2220
2221 static HRESULT WINAPI folder_put_Attributes(IFolder *iface, FileAttribute attr)
2222 {
2223 struct folder *This = impl_from_IFolder(iface);
2224 FIXME("(%p)->(0x%x): stub\n", This, attr);
2225 return E_NOTIMPL;
2226 }
2227
2228 static HRESULT WINAPI folder_get_DateCreated(IFolder *iface, DATE *date)
2229 {
2230 struct folder *This = impl_from_IFolder(iface);
2231 FIXME("(%p)->(%p): stub\n", This, date);
2232 return E_NOTIMPL;
2233 }
2234
2235 static HRESULT WINAPI folder_get_DateLastModified(IFolder *iface, DATE *date)
2236 {
2237 struct folder *This = impl_from_IFolder(iface);
2238 FIXME("(%p)->(%p): stub\n", This, date);
2239 return E_NOTIMPL;
2240 }
2241
2242 static HRESULT WINAPI folder_get_DateLastAccessed(IFolder *iface, DATE *date)
2243 {
2244 struct folder *This = impl_from_IFolder(iface);
2245 FIXME("(%p)->(%p): stub\n", This, date);
2246 return E_NOTIMPL;
2247 }
2248
2249 static HRESULT WINAPI folder_get_Type(IFolder *iface, BSTR *type)
2250 {
2251 struct folder *This = impl_from_IFolder(iface);
2252 FIXME("(%p)->(%p): stub\n", This, type);
2253 return E_NOTIMPL;
2254 }
2255
2256 static HRESULT WINAPI folder_Delete(IFolder *iface, VARIANT_BOOL force)
2257 {
2258 struct folder *This = impl_from_IFolder(iface);
2259 FIXME("(%p)->(%x): stub\n", This, force);
2260 return E_NOTIMPL;
2261 }
2262
2263 static HRESULT WINAPI folder_Copy(IFolder *iface, BSTR dest, VARIANT_BOOL overwrite)
2264 {
2265 struct folder *This = impl_from_IFolder(iface);
2266 FIXME("(%p)->(%s %x): stub\n", This, debugstr_w(dest), overwrite);
2267 return E_NOTIMPL;
2268 }
2269
2270 static HRESULT WINAPI folder_Move(IFolder *iface, BSTR dest)
2271 {
2272 struct folder *This = impl_from_IFolder(iface);
2273 FIXME("(%p)->(%s): stub\n", This, debugstr_w(dest));
2274 return E_NOTIMPL;
2275 }
2276
2277 static HRESULT WINAPI folder_get_IsRootFolder(IFolder *iface, VARIANT_BOOL *isroot)
2278 {
2279 struct folder *This = impl_from_IFolder(iface);
2280 FIXME("(%p)->(%p): stub\n", This, isroot);
2281 return E_NOTIMPL;
2282 }
2283
2284 static HRESULT WINAPI folder_get_Size(IFolder *iface, VARIANT *size)
2285 {
2286 struct folder *This = impl_from_IFolder(iface);
2287 FIXME("(%p)->(%p): stub\n", This, size);
2288 return E_NOTIMPL;
2289 }
2290
2291 static HRESULT WINAPI folder_get_SubFolders(IFolder *iface, IFolderCollection **folders)
2292 {
2293 struct folder *This = impl_from_IFolder(iface);
2294
2295 TRACE("(%p)->(%p)\n", This, folders);
2296
2297 if(!folders)
2298 return E_POINTER;
2299
2300 return create_foldercoll(This->path, folders);
2301 }
2302
2303 static HRESULT WINAPI folder_get_Files(IFolder *iface, IFileCollection **files)
2304 {
2305 struct folder *This = impl_from_IFolder(iface);
2306
2307 TRACE("(%p)->(%p)\n", This, files);
2308
2309 if(!files)
2310 return E_POINTER;
2311
2312 return create_filecoll(This->path, files);
2313 }
2314
2315 static HRESULT WINAPI folder_CreateTextFile(IFolder *iface, BSTR filename, VARIANT_BOOL overwrite,
2316 VARIANT_BOOL unicode, ITextStream **stream)
2317 {
2318 struct folder *This = impl_from_IFolder(iface);
2319 FIXME("(%p)->(%s %x %x %p): stub\n", This, debugstr_w(filename), overwrite, unicode, stream);
2320 return E_NOTIMPL;
2321 }
2322
2323 static const IFolderVtbl foldervtbl = {
2324 folder_QueryInterface,
2325 folder_AddRef,
2326 folder_Release,
2327 folder_GetTypeInfoCount,
2328 folder_GetTypeInfo,
2329 folder_GetIDsOfNames,
2330 folder_Invoke,
2331 folder_get_Path,
2332 folder_get_Name,
2333 folder_put_Name,
2334 folder_get_ShortPath,
2335 folder_get_ShortName,
2336 folder_get_Drive,
2337 folder_get_ParentFolder,
2338 folder_get_Attributes,
2339 folder_put_Attributes,
2340 folder_get_DateCreated,
2341 folder_get_DateLastModified,
2342 folder_get_DateLastAccessed,
2343 folder_get_Type,
2344 folder_Delete,
2345 folder_Copy,
2346 folder_Move,
2347 folder_get_IsRootFolder,
2348 folder_get_Size,
2349 folder_get_SubFolders,
2350 folder_get_Files,
2351 folder_CreateTextFile
2352 };
2353
2354 HRESULT create_folder(const WCHAR *path, IFolder **folder)
2355 {
2356 struct folder *This;
2357
2358 *folder = NULL;
2359
2360 TRACE("%s\n", debugstr_w(path));
2361
2362 This = heap_alloc(sizeof(struct folder));
2363 if (!This) return E_OUTOFMEMORY;
2364
2365 This->IFolder_iface.lpVtbl = &foldervtbl;
2366 This->ref = 1;
2367 This->path = SysAllocString(path);
2368 if (!This->path)
2369 {
2370 heap_free(This);
2371 return E_OUTOFMEMORY;
2372 }
2373
2374 *folder = &This->IFolder_iface;
2375
2376 return S_OK;
2377 }
2378
2379 static HRESULT WINAPI file_QueryInterface(IFile *iface, REFIID riid, void **obj)
2380 {
2381 struct file *This = impl_from_IFile(iface);
2382
2383 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
2384
2385 if (IsEqualIID(riid, &IID_IFile) ||
2386 IsEqualIID(riid, &IID_IDispatch) ||
2387 IsEqualIID(riid, &IID_IUnknown))
2388 {
2389 *obj = iface;
2390 IFile_AddRef(iface);
2391 return S_OK;
2392 }
2393
2394 *obj = NULL;
2395 return E_NOINTERFACE;
2396 }
2397
2398 static ULONG WINAPI file_AddRef(IFile *iface)
2399 {
2400 struct file *This = impl_from_IFile(iface);
2401 LONG ref = InterlockedIncrement(&This->ref);
2402
2403 TRACE("(%p) ref=%d\n", This, ref);
2404
2405 return ref;
2406 }
2407
2408 static ULONG WINAPI file_Release(IFile *iface)
2409 {
2410 struct file *This = impl_from_IFile(iface);
2411 LONG ref = InterlockedDecrement(&This->ref);
2412
2413 TRACE("(%p) ref=%d\n", This, ref);
2414
2415 if(!ref)
2416 {
2417 heap_free(This->path);
2418 heap_free(This);
2419 }
2420
2421 return ref;
2422 }
2423
2424 static HRESULT WINAPI file_GetTypeInfoCount(IFile *iface, UINT *pctinfo)
2425 {
2426 struct file *This = impl_from_IFile(iface);
2427
2428 TRACE("(%p)->(%p)\n", This, pctinfo);
2429
2430 *pctinfo = 1;
2431 return S_OK;
2432 }
2433
2434 static HRESULT WINAPI file_GetTypeInfo(IFile *iface,
2435 UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
2436 {
2437 struct file *This = impl_from_IFile(iface);
2438
2439 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
2440
2441 return get_typeinfo(IFile_tid, ppTInfo);
2442 }
2443
2444 static HRESULT WINAPI file_GetIDsOfNames(IFile *iface, REFIID riid,
2445 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
2446 {
2447 struct file *This = impl_from_IFile(iface);
2448 ITypeInfo *typeinfo;
2449 HRESULT hr;
2450
2451 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid),
2452 rgszNames, cNames, lcid, rgDispId);
2453
2454 hr = get_typeinfo(IFile_tid, &typeinfo);
2455 if(SUCCEEDED(hr)) {
2456 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
2457 ITypeInfo_Release(typeinfo);
2458 }
2459 return hr;
2460 }
2461
2462 static HRESULT WINAPI file_Invoke(IFile *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2463 {
2464 struct file *This = impl_from_IFile(iface);
2465 ITypeInfo *typeinfo;
2466 HRESULT hr;
2467
2468 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
2469 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2470
2471 hr = get_typeinfo(IFile_tid, &typeinfo);
2472 if(SUCCEEDED(hr))
2473 {
2474 hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
2475 pDispParams, pVarResult, pExcepInfo, puArgErr);
2476 ITypeInfo_Release(typeinfo);
2477 }
2478 return hr;
2479 }
2480
2481 static HRESULT WINAPI file_get_Path(IFile *iface, BSTR *pbstrPath)
2482 {
2483 struct file *This = impl_from_IFile(iface);
2484 FIXME("(%p)->(%p)\n", This, pbstrPath);
2485 return E_NOTIMPL;
2486 }
2487
2488 static HRESULT WINAPI file_get_Name(IFile *iface, BSTR *name)
2489 {
2490 struct file *This = impl_from_IFile(iface);
2491 WCHAR *ptr;
2492
2493 TRACE("(%p)->(%p)\n", This, name);
2494
2495 if(!name)
2496 return E_POINTER;
2497
2498 *name = NULL;
2499
2500 ptr = strrchrW(This->path, '\\');
2501 if (ptr)
2502 {
2503 *name = SysAllocString(ptr+1);
2504 TRACE("%s\n", debugstr_w(*name));
2505 if (!*name) return E_OUTOFMEMORY;
2506 }
2507 else
2508 return E_FAIL;
2509
2510 return S_OK;
2511 }
2512
2513 static HRESULT WINAPI file_put_Name(IFile *iface, BSTR pbstrName)
2514 {
2515 struct file *This = impl_from_IFile(iface);
2516 FIXME("(%p)->(%s)\n", This, debugstr_w(pbstrName));
2517 return E_NOTIMPL;
2518 }
2519
2520 static HRESULT WINAPI file_get_ShortPath(IFile *iface, BSTR *pbstrPath)
2521 {
2522 struct file *This = impl_from_IFile(iface);
2523 FIXME("(%p)->(%p)\n", This, pbstrPath);
2524 return E_NOTIMPL;
2525 }
2526
2527 static HRESULT WINAPI file_get_ShortName(IFile *iface, BSTR *pbstrName)
2528 {
2529 struct file *This = impl_from_IFile(iface);
2530 FIXME("(%p)->(%p)\n", This, pbstrName);
2531 return E_NOTIMPL;
2532 }
2533
2534 static HRESULT WINAPI file_get_Drive(IFile *iface, IDrive **ppdrive)
2535 {
2536 struct file *This = impl_from_IFile(iface);
2537 FIXME("(%p)->(%p)\n", This, ppdrive);
2538 return E_NOTIMPL;
2539 }
2540
2541 static HRESULT WINAPI file_get_ParentFolder(IFile *iface, IFolder **ppfolder)
2542 {
2543 struct file *This = impl_from_IFile(iface);
2544 FIXME("(%p)->(%p)\n", This, ppfolder);
2545 return E_NOTIMPL;
2546 }
2547
2548 static HRESULT WINAPI file_get_Attributes(IFile *iface, FileAttribute *pfa)
2549 {
2550 struct file *This = impl_from_IFile(iface);
2551 DWORD fa;
2552
2553 TRACE("(%p)->(%p)\n", This, pfa);
2554
2555 if(!pfa)
2556 return E_POINTER;
2557
2558 fa = GetFileAttributesW(This->path);
2559 if(fa == INVALID_FILE_ATTRIBUTES)
2560 return create_error(GetLastError());
2561
2562 *pfa = fa & (FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN |
2563 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_ARCHIVE |
2564 FILE_ATTRIBUTE_REPARSE_POINT | FILE_ATTRIBUTE_COMPRESSED);
2565 return S_OK;
2566 }
2567
2568 static HRESULT WINAPI file_put_Attributes(IFile *iface, FileAttribute pfa)
2569 {
2570 struct file *This = impl_from_IFile(iface);
2571 FIXME("(%p)->(%x)\n", This, pfa);
2572 return E_NOTIMPL;
2573 }
2574
2575 static HRESULT WINAPI file_get_DateCreated(IFile *iface, DATE *pdate)
2576 {
2577 struct file *This = impl_from_IFile(iface);
2578 FIXME("(%p)->(%p)\n", This, pdate);
2579 return E_NOTIMPL;
2580 }
2581
2582 static HRESULT WINAPI file_get_DateLastModified(IFile *iface, DATE *pdate)
2583 {
2584 struct file *This = impl_from_IFile(iface);
2585 FIXME("(%p)->(%p)\n", This, pdate);
2586 return E_NOTIMPL;
2587 }
2588
2589 static HRESULT WINAPI file_get_DateLastAccessed(IFile *iface, DATE *pdate)
2590 {
2591 struct file *This = impl_from_IFile(iface);
2592 FIXME("(%p)->(%p)\n", This, pdate);
2593 return E_NOTIMPL;
2594 }
2595
2596 static HRESULT WINAPI file_get_Size(IFile *iface, VARIANT *pvarSize)
2597 {
2598 struct file *This = impl_from_IFile(iface);
2599 WIN32_FIND_DATAW fd;
2600 HANDLE f;
2601
2602 TRACE("(%p)->(%p)\n", This, pvarSize);
2603
2604 if(!pvarSize)
2605 return E_POINTER;
2606
2607 f = FindFirstFileW(This->path, &fd);
2608 if(f == INVALID_HANDLE_VALUE)
2609 return create_error(GetLastError());
2610 FindClose(f);
2611
2612 if(fd.nFileSizeHigh || fd.nFileSizeLow>INT_MAX) {
2613 V_VT(pvarSize) = VT_R8;
2614 V_R8(pvarSize) = ((ULONGLONG)fd.nFileSizeHigh<<32) + fd.nFileSizeLow;
2615 }else {
2616 V_VT(pvarSize) = VT_I4;
2617 V_I4(pvarSize) = fd.nFileSizeLow;
2618 }
2619 return S_OK;
2620 }
2621
2622 static HRESULT WINAPI file_get_Type(IFile *iface, BSTR *pbstrType)
2623 {
2624 struct file *This = impl_from_IFile(iface);
2625 FIXME("(%p)->(%p)\n", This, pbstrType);
2626 return E_NOTIMPL;
2627 }
2628
2629 static HRESULT WINAPI file_Delete(IFile *iface, VARIANT_BOOL Force)
2630 {
2631 struct file *This = impl_from_IFile(iface);
2632 FIXME("(%p)->(%x)\n", This, Force);
2633 return E_NOTIMPL;
2634 }
2635
2636 static HRESULT WINAPI file_Copy(IFile *iface, BSTR Destination, VARIANT_BOOL OverWriteFiles)
2637 {
2638 struct file *This = impl_from_IFile(iface);
2639 FIXME("(%p)->(%s %x)\n", This, debugstr_w(Destination), OverWriteFiles);
2640 return E_NOTIMPL;
2641 }
2642
2643 static HRESULT WINAPI file_Move(IFile *iface, BSTR Destination)
2644 {
2645 struct file *This = impl_from_IFile(iface);
2646 FIXME("(%p)->(%s)\n", This, debugstr_w(Destination));
2647 return E_NOTIMPL;
2648 }
2649
2650 static HRESULT WINAPI file_OpenAsTextStream(IFile *iface, IOMode mode, Tristate format, ITextStream **stream)
2651 {
2652 struct file *This = impl_from_IFile(iface);
2653
2654 TRACE("(%p)->(%d %d %p)\n", This, mode, format, stream);
2655
2656 if (format == TristateUseDefault) {
2657 FIXME("default format not handled, defaulting to unicode\n");
2658 format = TristateTrue;
2659 }
2660
2661 return create_textstream(This->path, OPEN_EXISTING, mode, format == TristateTrue, stream);
2662 }
2663
2664 static const IFileVtbl file_vtbl = {
2665 file_QueryInterface,
2666 file_AddRef,
2667 file_Release,
2668 file_GetTypeInfoCount,
2669 file_GetTypeInfo,
2670 file_GetIDsOfNames,
2671 file_Invoke,
2672 file_get_Path,
2673 file_get_Name,
2674 file_put_Name,
2675 file_get_ShortPath,
2676 file_get_ShortName,
2677 file_get_Drive,
2678 file_get_ParentFolder,
2679 file_get_Attributes,
2680 file_put_Attributes,
2681 file_get_DateCreated,
2682 file_get_DateLastModified,
2683 file_get_DateLastAccessed,
2684 file_get_Size,
2685 file_get_Type,
2686 file_Delete,
2687 file_Copy,
2688 file_Move,
2689 file_OpenAsTextStream
2690 };
2691
2692 static HRESULT create_file(BSTR path, IFile **file)
2693 {
2694 struct file *f;
2695 DWORD len, attrs;
2696
2697 *file = NULL;
2698
2699 f = heap_alloc(sizeof(struct file));
2700 if(!f)
2701 return E_OUTOFMEMORY;
2702
2703 f->IFile_iface.lpVtbl = &file_vtbl;
2704 f->ref = 1;
2705
2706 len = GetFullPathNameW(path, 0, NULL, NULL);
2707 if(!len) {
2708 heap_free(f);
2709 return E_FAIL;
2710 }
2711
2712 f->path = heap_alloc(len*sizeof(WCHAR));
2713 if(!f->path) {
2714 heap_free(f);
2715 return E_OUTOFMEMORY;
2716 }
2717
2718 if(!GetFullPathNameW(path, len, f->path, NULL)) {
2719 heap_free(f->path);
2720 heap_free(f);
2721 return E_FAIL;
2722 }
2723
2724 if(path[len-1]=='/' || path[len-1]=='\\')
2725 path[len-1] = 0;
2726
2727 attrs = GetFileAttributesW(f->path);
2728 if(attrs==INVALID_FILE_ATTRIBUTES ||
2729 (attrs&(FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_DEVICE))) {
2730 heap_free(f->path);
2731 heap_free(f);
2732 return create_error(GetLastError());
2733 }
2734
2735 *file = &f->IFile_iface;
2736 return S_OK;
2737 }
2738
2739 static HRESULT WINAPI filesys_QueryInterface(IFileSystem3 *iface, REFIID riid, void **ppvObject)
2740 {
2741 TRACE("%p %s %p\n", iface, debugstr_guid(riid), ppvObject);
2742
2743 if ( IsEqualGUID( riid, &IID_IFileSystem3 ) ||
2744 IsEqualGUID( riid, &IID_IFileSystem ) ||
2745 IsEqualGUID( riid, &IID_IDispatch ) ||
2746 IsEqualGUID( riid, &IID_IUnknown ) )
2747 {
2748 *ppvObject = iface;
2749 }
2750 else if ( IsEqualGUID( riid, &IID_IDispatchEx ))
2751 {
2752 TRACE("Interface IDispatchEx not supported - returning NULL\n");
2753 *ppvObject = NULL;
2754 return E_NOINTERFACE;
2755 }
2756 else if ( IsEqualGUID( riid, &IID_IObjectWithSite ))
2757 {
2758 TRACE("Interface IObjectWithSite not supported - returning NULL\n");
2759 *ppvObject = NULL;
2760 return E_NOINTERFACE;
2761 }
2762 else
2763 {
2764 FIXME("Unsupported interface %s\n", debugstr_guid(riid));
2765 return E_NOINTERFACE;
2766 }
2767
2768 IFileSystem3_AddRef(iface);
2769
2770 return S_OK;
2771 }
2772
2773 static ULONG WINAPI filesys_AddRef(IFileSystem3 *iface)
2774 {
2775 TRACE("%p\n", iface);
2776
2777 return 2;
2778 }
2779
2780 static ULONG WINAPI filesys_Release(IFileSystem3 *iface)
2781 {
2782 TRACE("%p\n", iface);
2783
2784 return 1;
2785 }
2786
2787 static HRESULT WINAPI filesys_GetTypeInfoCount(IFileSystem3 *iface, UINT *pctinfo)
2788 {
2789 TRACE("(%p)->(%p)\n", iface, pctinfo);
2790
2791 *pctinfo = 1;
2792 return S_OK;
2793 }
2794
2795 static HRESULT WINAPI filesys_GetTypeInfo(IFileSystem3 *iface, UINT iTInfo,
2796 LCID lcid, ITypeInfo **ppTInfo)
2797 {
2798 TRACE("(%p)->(%u %u %p)\n", iface, iTInfo, lcid, ppTInfo);
2799 return get_typeinfo(IFileSystem3_tid, ppTInfo);
2800 }
2801
2802 static HRESULT WINAPI filesys_GetIDsOfNames(IFileSystem3 *iface, REFIID riid,
2803 LPOLESTR *rgszNames, UINT cNames,
2804 LCID lcid, DISPID *rgDispId)
2805 {
2806 ITypeInfo *typeinfo;
2807 HRESULT hr;
2808
2809 TRACE("(%p)->(%s %p %u %u %p)\n", iface, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
2810
2811 hr = get_typeinfo(IFileSystem3_tid, &typeinfo);
2812 if(SUCCEEDED(hr))
2813 {
2814 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
2815 ITypeInfo_Release(typeinfo);
2816 }
2817
2818 return hr;
2819 }
2820
2821 static HRESULT WINAPI filesys_Invoke(IFileSystem3 *iface, DISPID dispIdMember,
2822 REFIID riid, LCID lcid, WORD wFlags,
2823 DISPPARAMS *pDispParams, VARIANT *pVarResult,
2824 EXCEPINFO *pExcepInfo, UINT *puArgErr)
2825 {
2826 ITypeInfo *typeinfo;
2827 HRESULT hr;
2828
2829 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", iface, dispIdMember, debugstr_guid(riid),
2830 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2831
2832 hr = get_typeinfo(IFileSystem3_tid, &typeinfo);
2833 if(SUCCEEDED(hr))
2834 {
2835 hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
2836 pDispParams, pVarResult, pExcepInfo, puArgErr);
2837 ITypeInfo_Release(typeinfo);
2838 }
2839
2840 return hr;
2841 }
2842
2843 static HRESULT WINAPI filesys_get_Drives(IFileSystem3 *iface, IDriveCollection **ppdrives)
2844 {
2845 TRACE("%p %p\n", iface, ppdrives);
2846 return create_drivecoll(ppdrives);
2847 }
2848
2849 static HRESULT WINAPI filesys_BuildPath(IFileSystem3 *iface, BSTR Path,
2850 BSTR Name, BSTR *Result)
2851 {
2852 BSTR ret;
2853
2854 TRACE("%p %s %s %p\n", iface, debugstr_w(Path), debugstr_w(Name), Result);
2855
2856 if (!Result) return E_POINTER;
2857
2858 if (Path && Name)
2859 {
2860 int path_len = SysStringLen(Path), name_len = SysStringLen(Name);
2861
2862 /* if both parts have backslashes strip one from Path */
2863 if (Path[path_len-1] == '\\' && Name[0] == '\\')
2864 {
2865 path_len -= 1;
2866
2867 ret = SysAllocStringLen(NULL, path_len + name_len);
2868 if (ret)
2869 {
2870 strcpyW(ret, Path);
2871 ret[path_len] = 0;
2872 strcatW(ret, Name);
2873 }
2874 }
2875 else if (Path[path_len-1] != '\\' && Name[0] != '\\')
2876 {
2877 ret = SysAllocStringLen(NULL, path_len + name_len + 1);
2878 if (ret)
2879 {
2880 strcpyW(ret, Path);
2881 if (Path[path_len-1] != ':')
2882 strcatW(ret, bsW);
2883 strcatW(ret, Name);
2884 }
2885 }
2886 else
2887 {
2888 ret = SysAllocStringLen(NULL, path_len + name_len);
2889 if (ret)
2890 {
2891 strcpyW(ret, Path);
2892 strcatW(ret, Name);
2893 }
2894 }
2895 }
2896 else if (Path || Name)
2897 ret = SysAllocString(Path ? Path : Name);
2898 else
2899 ret = SysAllocStringLen(NULL, 0);
2900
2901 if (!ret) return E_OUTOFMEMORY;
2902 *Result = ret;
2903
2904 return S_OK;
2905 }
2906
2907 static HRESULT WINAPI filesys_GetDriveName(IFileSystem3 *iface, BSTR Path,
2908 BSTR *pbstrResult)
2909 {
2910 FIXME("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
2911
2912 return E_NOTIMPL;
2913 }
2914
2915 static inline DWORD get_parent_folder_name(const WCHAR *path, DWORD len)
2916 {
2917 int i;
2918
2919 if(!path)
2920 return 0;
2921
2922 for(i=len-1; i>=0; i--)
2923 if(path[i]!='/' && path[i]!='\\')
2924 break;
2925
2926 for(; i>=0; i--)
2927 if(path[i]=='/' || path[i]=='\\')
2928 break;
2929
2930 for(; i>=0; i--)
2931 if(path[i]!='/' && path[i]!='\\')
2932 break;
2933
2934 if(i < 0)
2935 return 0;
2936
2937 if(path[i]==':' && i==1)
2938 i++;
2939 return i+1;
2940 }
2941
2942 static HRESULT WINAPI filesys_GetParentFolderName(IFileSystem3 *iface, BSTR Path,
2943 BSTR *pbstrResult)
2944 {
2945 DWORD len;
2946
2947 TRACE("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
2948
2949 if(!pbstrResult)
2950 return E_POINTER;
2951
2952 len = get_parent_folder_name(Path, SysStringLen(Path));
2953 if(!len) {
2954 *pbstrResult = NULL;
2955 return S_OK;
2956 }
2957
2958 *pbstrResult = SysAllocStringLen(Path, len);
2959 if(!*pbstrResult)
2960 return E_OUTOFMEMORY;
2961 return S_OK;
2962 }
2963
2964 static HRESULT WINAPI filesys_GetFileName(IFileSystem3 *iface, BSTR Path,
2965 BSTR *pbstrResult)
2966 {
2967 int i, end;
2968
2969 TRACE("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
2970
2971 if(!pbstrResult)
2972 return E_POINTER;
2973
2974 if(!Path) {
2975 *pbstrResult = NULL;
2976 return S_OK;
2977 }
2978
2979 for(end=strlenW(Path)-1; end>=0; end--)
2980 if(Path[end]!='/' && Path[end]!='\\')
2981 break;
2982
2983 for(i=end; i>=0; i--)
2984 if(Path[i]=='/' || Path[i]=='\\')
2985 break;
2986 i++;
2987
2988 if(i>end || (i==0 && end==1 && Path[1]==':')) {
2989 *pbstrResult = NULL;
2990 return S_OK;
2991 }
2992
2993 *pbstrResult = SysAllocStringLen(Path+i, end-i+1);
2994 if(!*pbstrResult)
2995 return E_OUTOFMEMORY;
2996 return S_OK;
2997 }
2998
2999 static HRESULT WINAPI filesys_GetBaseName(IFileSystem3 *iface, BSTR Path,
3000 BSTR *pbstrResult)
3001 {
3002 int i, end;
3003
3004 TRACE("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
3005
3006 if(!pbstrResult)
3007 return E_POINTER;
3008
3009 if(!Path) {
3010 *pbstrResult = NULL;
3011 return S_OK;
3012 }
3013
3014 for(end=strlenW(Path)-1; end>=0; end--)
3015 if(Path[end]!='/' && Path[end]!='\\')
3016 break;
3017
3018 for(i=end; i>=0; i--) {
3019 if(Path[i]=='.' && Path[end+1]!='.')
3020 end = i-1;
3021 if(Path[i]=='/' || Path[i]=='\\')
3022 break;
3023 }
3024 i++;
3025
3026 if((i>end && Path[end+1]!='.') || (i==0 && end==1 && Path[1]==':')) {
3027 *pbstrResult = NULL;
3028 return S_OK;
3029 }
3030
3031 *pbstrResult = SysAllocStringLen(Path+i, end-i+1);
3032 if(!*pbstrResult)
3033 return E_OUTOFMEMORY;
3034 return S_OK;
3035 }
3036
3037 static HRESULT WINAPI filesys_GetExtensionName(IFileSystem3 *iface, BSTR Path,
3038 BSTR *pbstrResult)
3039 {
3040 FIXME("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
3041
3042 return E_NOTIMPL;
3043 }
3044
3045 static HRESULT WINAPI filesys_GetAbsolutePathName(IFileSystem3 *iface, BSTR Path,
3046 BSTR *pbstrResult)
3047 {
3048 static const WCHAR cur_path[] = {'.',0};
3049
3050 WCHAR buf[MAX_PATH], ch;
3051 const WCHAR *path;
3052 DWORD i, beg, len, exp_len;
3053 WIN32_FIND_DATAW fdata;
3054 HANDLE fh;
3055
3056 TRACE("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
3057
3058 if(!pbstrResult)
3059 return E_POINTER;
3060
3061 if(!Path)
3062 path = cur_path;
3063 else
3064 path = Path;
3065
3066 len = GetFullPathNameW(path, MAX_PATH, buf, NULL);
3067 if(!len)
3068 return E_FAIL;
3069
3070 buf[0] = toupperW(buf[0]);
3071 if(len>3 && buf[len-1] == '\\')
3072 buf[--len] = 0;
3073
3074 for(beg=3, i=3; i<=len; i++) {
3075 if(buf[i]!='\\' && buf[i])
3076 continue;
3077
3078 ch = buf[i];
3079 buf[i] = 0;
3080 fh = FindFirstFileW(buf, &fdata);
3081 if(fh == INVALID_HANDLE_VALUE)
3082 break;
3083
3084 exp_len = strlenW(fdata.cFileName);
3085 if(exp_len == i-beg)
3086 memcpy(buf+beg, fdata.cFileName, exp_len*sizeof(WCHAR));
3087 FindClose(fh);
3088 buf[i] = ch;
3089 beg = i+1;
3090 }
3091
3092 *pbstrResult = SysAllocString(buf);
3093 if(!*pbstrResult)
3094 return E_OUTOFMEMORY;
3095 return S_OK;
3096 }
3097
3098 static HRESULT WINAPI filesys_GetTempName(IFileSystem3 *iface, BSTR *pbstrResult)
3099 {
3100 static const WCHAR fmt[] = {'r','a','d','%','0','5','X','.','t','x','t',0};
3101
3102 DWORD random;
3103
3104 TRACE("%p %p\n", iface, pbstrResult);
3105
3106 if(!pbstrResult)
3107 return E_POINTER;
3108
3109 *pbstrResult = SysAllocStringLen(NULL, 12);
3110 if(!*pbstrResult)
3111 return E_OUTOFMEMORY;
3112
3113 if(!RtlGenRandom(&random, sizeof(random)))
3114 return E_FAIL;
3115 sprintfW(*pbstrResult, fmt, random & 0xfffff);
3116 return S_OK;
3117 }
3118
3119 static HRESULT WINAPI filesys_DriveExists(IFileSystem3 *iface, BSTR DriveSpec,
3120 VARIANT_BOOL *pfExists)
3121 {
3122 FIXME("%p %s %p\n", iface, debugstr_w(DriveSpec), pfExists);
3123
3124 return E_NOTIMPL;
3125 }
3126
3127 static HRESULT WINAPI filesys_FileExists(IFileSystem3 *iface, BSTR path, VARIANT_BOOL *ret)
3128 {
3129 DWORD attrs;
3130 TRACE("%p %s %p\n", iface, debugstr_w(path), ret);
3131
3132 if (!ret) return E_POINTER;
3133
3134 attrs = GetFileAttributesW(path);
3135 *ret = attrs != INVALID_FILE_ATTRIBUTES && !(attrs & FILE_ATTRIBUTE_DIRECTORY) ? VARIANT_TRUE : VARIANT_FALSE;
3136 return S_OK;
3137 }
3138
3139 static HRESULT WINAPI filesys_FolderExists(IFileSystem3 *iface, BSTR path, VARIANT_BOOL *ret)
3140 {
3141 DWORD attrs;
3142 TRACE("%p %s %p\n", iface, debugstr_w(path), ret);
3143
3144 if (!ret) return E_POINTER;
3145
3146 attrs = GetFileAttributesW(path);
3147 *ret = attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY) ? VARIANT_TRUE : VARIANT_FALSE;
3148
3149 return S_OK;
3150 }
3151
3152 static HRESULT WINAPI filesys_GetDrive(IFileSystem3 *iface, BSTR DriveSpec,
3153 IDrive **ppdrive)
3154 {
3155 FIXME("%p %s %p\n", iface, debugstr_w(DriveSpec), ppdrive);
3156
3157 return E_NOTIMPL;
3158 }
3159
3160 static HRESULT WINAPI filesys_GetFile(IFileSystem3 *iface, BSTR FilePath,
3161 IFile **ppfile)
3162 {
3163 TRACE("%p %s %p\n", iface, debugstr_w(FilePath), ppfile);
3164
3165 if(!ppfile)
3166 return E_POINTER;
3167 if(!FilePath)
3168 return E_INVALIDARG;
3169
3170 return create_file(FilePath, ppfile);
3171 }
3172
3173 static HRESULT WINAPI filesys_GetFolder(IFileSystem3 *iface, BSTR FolderPath,
3174 IFolder **folder)
3175 {
3176 DWORD attrs;
3177
3178 TRACE("%p %s %p\n", iface, debugstr_w(FolderPath), folder);
3179
3180 if(!folder)
3181 return E_POINTER;
3182
3183 *folder = NULL;
3184 if(!FolderPath)
3185 return E_INVALIDARG;
3186
3187 attrs = GetFileAttributesW(FolderPath);
3188 if((attrs == INVALID_FILE_ATTRIBUTES) || !(attrs & FILE_ATTRIBUTE_DIRECTORY))
3189 return CTL_E_PATHNOTFOUND;
3190
3191 return create_folder(FolderPath, folder);
3192 }
3193
3194 static HRESULT WINAPI filesys_GetSpecialFolder(IFileSystem3 *iface,
3195 SpecialFolderConst SpecialFolder,
3196 IFolder **ppfolder)
3197 {
3198 FIXME("%p %d %p\n", iface, SpecialFolder, ppfolder);
3199
3200 return E_NOTIMPL;
3201 }
3202
3203 static inline HRESULT delete_file(const WCHAR *file, DWORD file_len, VARIANT_BOOL force)
3204 {
3205 WCHAR path[MAX_PATH];
3206 DWORD len, name_len;
3207 WIN32_FIND_DATAW ffd;
3208 HANDLE f;
3209
3210 f = FindFirstFileW(file, &ffd);
3211 if(f == INVALID_HANDLE_VALUE)
3212 return create_error(GetLastError());
3213
3214 len = get_parent_folder_name(file, file_len);
3215 if(len+1 >= MAX_PATH) {
3216 FindClose(f);
3217 return E_FAIL;
3218 }
3219 if(len) {
3220 memcpy(path, file, len*sizeof(WCHAR));
3221 path[len++] = '\\';
3222 }
3223
3224 do {
3225 if(ffd.dwFileAttributes & (FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_DEVICE))
3226 continue;
3227
3228 name_len = strlenW(ffd.cFileName);
3229 if(len+name_len+1 >= MAX_PATH) {
3230 FindClose(f);
3231 return E_FAIL;
3232 }
3233 memcpy(path+len, ffd.cFileName, (name_len+1)*sizeof(WCHAR));
3234
3235 TRACE("deleting %s\n", debugstr_w(path));
3236
3237 if(!DeleteFileW(path)) {
3238 if(!force || !SetFileAttributesW(path, FILE_ATTRIBUTE_NORMAL)
3239 || !DeleteFileW(path)) {
3240 FindClose(f);
3241 return create_error(GetLastError());
3242 }
3243 }
3244 } while(FindNextFileW(f, &ffd));
3245 FindClose(f);
3246
3247 return S_OK;
3248 }
3249
3250 static HRESULT WINAPI filesys_DeleteFile(IFileSystem3 *iface, BSTR FileSpec,
3251 VARIANT_BOOL Force)
3252 {
3253 TRACE("%p %s %d\n", iface, debugstr_w(FileSpec), Force);
3254
3255 if(!FileSpec)
3256 return E_POINTER;
3257
3258 return delete_file(FileSpec, SysStringLen(FileSpec), Force);
3259 }
3260
3261 static HRESULT delete_folder(const WCHAR *folder, DWORD folder_len, VARIANT_BOOL force)
3262 {
3263 WCHAR path[MAX_PATH];
3264 DWORD len, name_len;
3265 WIN32_FIND_DATAW ffd;
3266 HANDLE f;
3267 HRESULT hr;
3268
3269 f = FindFirstFileW(folder, &ffd);
3270 if(f == INVALID_HANDLE_VALUE)
3271 return create_error(GetLastError());
3272
3273 len = get_parent_folder_name(folder, folder_len);
3274 if(len+1 >= MAX_PATH) {
3275 FindClose(f);
3276 return E_FAIL;
3277 }
3278 if(len) {
3279 memcpy(path, folder, len*sizeof(WCHAR));
3280 path[len++] = '\\';
3281 }
3282
3283 do {
3284 if(!(ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
3285 continue;
3286 if(ffd.cFileName[0]=='.' && (ffd.cFileName[1]==0 ||
3287 (ffd.cFileName[1]=='.' && ffd.cFileName[2]==0)))
3288 continue;
3289
3290 name_len = strlenW(ffd.cFileName);
3291 if(len+name_len+3 >= MAX_PATH) {
3292 FindClose(f);
3293 return E_FAIL;
3294 }
3295 memcpy(path+len, ffd.cFileName, name_len*sizeof(WCHAR));
3296 path[len+name_len] = '\\';
3297 path[len+name_len+1] = '*';
3298 path[len+name_len+2] = 0;
3299
3300 hr = delete_file(path, len+name_len+2, force);
3301 if(FAILED(hr)) {
3302 FindClose(f);
3303 return hr;
3304 }
3305
3306 hr = delete_folder(path, len+name_len+2, force);
3307 if(FAILED(hr)) {
3308 FindClose(f);
3309 return hr;
3310 }
3311
3312 path[len+name_len] = 0;
3313 TRACE("deleting %s\n", debugstr_w(path));
3314
3315 if(!RemoveDirectoryW(path)) {
3316 FindClose(f);
3317 return create_error(GetLastError());
3318 }
3319 } while(FindNextFileW(f, &ffd));
3320 FindClose(f);
3321
3322 return S_OK;
3323 }
3324
3325 static HRESULT WINAPI filesys_DeleteFolder(IFileSystem3 *iface, BSTR FolderSpec,
3326 VARIANT_BOOL Force)
3327 {
3328 TRACE("%p %s %d\n", iface, debugstr_w(FolderSpec), Force);
3329
3330 if(!FolderSpec)
3331 return E_POINTER;
3332
3333 return delete_folder(FolderSpec, SysStringLen(FolderSpec), Force);
3334 }
3335
3336 static HRESULT WINAPI filesys_MoveFile(IFileSystem3 *iface, BSTR Source,
3337 BSTR Destination)
3338 {
3339 FIXME("%p %s %s\n", iface, debugstr_w(Source), debugstr_w(Destination));
3340
3341 return E_NOTIMPL;
3342 }
3343
3344 static HRESULT WINAPI filesys_MoveFolder(IFileSystem3 *iface,BSTR Source,
3345 BSTR Destination)
3346 {
3347 FIXME("%p %s %s\n", iface, debugstr_w(Source), debugstr_w(Destination));
3348
3349 return E_NOTIMPL;
3350 }
3351
3352 static inline HRESULT copy_file(const WCHAR *source, DWORD source_len,
3353 const WCHAR *destination, DWORD destination_len, VARIANT_BOOL overwrite)
3354 {
3355 DWORD attrs;
3356 WCHAR src_path[MAX_PATH], dst_path[MAX_PATH];
3357 DWORD src_len, dst_len, name_len;
3358 WIN32_FIND_DATAW ffd;
3359 HANDLE f;
3360 HRESULT hr;
3361
3362 if(!source[0] || !destination[0])
3363 return E_INVALIDARG;
3364
3365 attrs = GetFileAttributesW(destination);
3366 if(attrs==INVALID_FILE_ATTRIBUTES || !(attrs & FILE_ATTRIBUTE_DIRECTORY)) {
3367 attrs = GetFileAttributesW(source);
3368 if(attrs == INVALID_FILE_ATTRIBUTES)
3369 return create_error(GetLastError());
3370 else if(attrs & FILE_ATTRIBUTE_DIRECTORY)
3371 return CTL_E_FILENOTFOUND;
3372
3373 if(!CopyFileW(source, destination, !overwrite))
3374 return create_error(GetLastError());
3375 return S_OK;
3376 }
3377
3378 f = FindFirstFileW(source, &ffd);
3379 if(f == INVALID_HANDLE_VALUE)
3380 return CTL_E_FILENOTFOUND;
3381
3382 src_len = get_parent_folder_name(source, source_len);
3383 if(src_len+1 >= MAX_PATH) {
3384 FindClose(f);
3385 return E_FAIL;
3386 }
3387 if(src_len) {
3388 memcpy(src_path, source, src_len*sizeof(WCHAR));
3389 src_path[src_len++] = '\\';
3390 }
3391
3392 dst_len = destination_len;
3393 if(dst_len+1 >= MAX_PATH) {
3394 FindClose(f);
3395 return E_FAIL;
3396 }
3397 memcpy(dst_path, destination, dst_len*sizeof(WCHAR));
3398 if(dst_path[dst_len-1]!= '\\' && dst_path[dst_len-1]!='/')
3399 dst_path[dst_len++] = '\\';
3400
3401 hr = CTL_E_FILENOTFOUND;
3402 do {
3403 if(ffd.dwFileAttributes & (FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_DEVICE))
3404 continue;
3405
3406 name_len = strlenW(ffd.cFileName);
3407 if(src_len+name_len+1>=MAX_PATH || dst_len+name_len+1>=MAX_PATH) {
3408 FindClose(f);
3409 return E_FAIL;
3410 }
3411 memcpy(src_path+src_len, ffd.cFileName, (name_len+1)*sizeof(WCHAR));
3412 memcpy(dst_path+dst_len, ffd.cFileName, (name_len+1)*sizeof(WCHAR));
3413
3414 TRACE("copying %s to %s\n", debugstr_w(src_path), debugstr_w(dst_path));
3415
3416 if(!CopyFileW(src_path, dst_path, !overwrite)) {
3417 FindClose(f);
3418 return create_error(GetLastError());
3419 }else {
3420 hr = S_OK;
3421 }
3422 } while(FindNextFileW(f, &ffd));
3423 FindClose(f);
3424
3425 return hr;
3426 }
3427
3428 static HRESULT WINAPI filesys_CopyFile(IFileSystem3 *iface, BSTR Source,
3429 BSTR Destination, VARIANT_BOOL OverWriteFiles)
3430 {
3431 TRACE("%p %s %s %d\n", iface, debugstr_w(Source), debugstr_w(Destination), OverWriteFiles);
3432
3433 if(!Source || !Destination)
3434 return E_POINTER;
3435
3436 return copy_file(Source, SysStringLen(Source), Destination,
3437 SysStringLen(Destination), OverWriteFiles);
3438 }
3439
3440 static HRESULT copy_folder(const WCHAR *source, DWORD source_len, const WCHAR *destination,
3441 DWORD destination_len, VARIANT_BOOL overwrite)
3442 {
3443 DWORD tmp, src_len, dst_len, name_len;
3444 WCHAR src[MAX_PATH], dst[MAX_PATH];
3445 WIN32_FIND_DATAW ffd;
3446 HANDLE f;
3447 HRESULT hr;
3448 BOOL copied = FALSE;
3449
3450 if(!source[0] || !destination[0])
3451 return E_INVALIDARG;
3452
3453 dst_len = destination_len;
3454 if(dst_len+1 >= MAX_PATH)
3455 return E_FAIL;
3456 memcpy(dst, destination, (dst_len+1)*sizeof(WCHAR));
3457
3458 if(dst[dst_len-1]!='\\' && dst[dst_len-1]!='/' &&
3459 (tmp = GetFileAttributesW(source))!=INVALID_FILE_ATTRIBUTES &&
3460 tmp&FILE_ATTRIBUTE_DIRECTORY) {
3461 if(!CreateDirectoryW(dst, NULL)) {
3462 if(overwrite && GetLastError()==ERROR_ALREADY_EXISTS) {
3463 tmp = GetFileAttributesW(dst);
3464 if(tmp==INVALID_FILE_ATTRIBUTES || !(tmp&FILE_ATTRIBUTE_DIRECTORY))
3465 return CTL_E_FILEALREADYEXISTS;
3466 }else {
3467 return create_error(GetLastError());
3468 }
3469 }
3470 copied = TRUE;
3471
3472 src_len = source_len;
3473 if(src_len+2 >= MAX_PATH)
3474 return E_FAIL;
3475 memcpy(src, source, src_len*sizeof(WCHAR));
3476 src[src_len++] = '\\';
3477 src[src_len] = '*';
3478 src[src_len+1] = 0;
3479
3480 hr = copy_file(src, src_len+1, dst, dst_len, overwrite);
3481 if(FAILED(hr) && hr!=CTL_E_FILENOTFOUND)
3482 return create_error(GetLastError());
3483
3484 f = FindFirstFileW(src, &ffd);
3485 }else {
3486 src_len = get_parent_folder_name(source, source_len);
3487 if(src_len+2 >= MAX_PATH)
3488 return E_FAIL;
3489 memcpy(src, source, src_len*sizeof(WCHAR));
3490 if(src_len)
3491 src[src_len++] = '\\';
3492
3493 f = FindFirstFileW(source, &ffd);
3494 }
3495 if(f == INVALID_HANDLE_VALUE)
3496 return CTL_E_PATHNOTFOUND;
3497
3498 dst[dst_len++] = '\\';
3499 dst[dst_len] = 0;
3500
3501 do {
3502 if(!(ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
3503 continue;
3504 if(ffd.cFileName[0]=='.' && (ffd.cFileName[1]==0 ||
3505 (ffd.cFileName[1]=='.' && ffd.cFileName[2]==0)))
3506 continue;
3507
3508 name_len = strlenW(ffd.cFileName);
3509 if(dst_len+name_len>=MAX_PATH || src_len+name_len+2>=MAX_PATH) {
3510 FindClose(f);
3511 return E_FAIL;
3512 }
3513 memcpy(dst+dst_len, ffd.cFileName, name_len*sizeof(WCHAR));
3514 dst[dst_len+name_len] = 0;
3515 memcpy(src+src_len, ffd.cFileName, name_len*sizeof(WCHAR));
3516 src[src_len+name_len] = '\\';
3517 src[src_len+name_len+1] = '*';
3518 src[src_len+name_len+2] = 0;
3519
3520 TRACE("copying %s to %s\n", debugstr_w(src), debugstr_w(dst));
3521
3522 if(!CreateDirectoryW(dst, NULL)) {
3523 if(overwrite && GetLastError()==ERROR_ALREADY_EXISTS) {
3524 tmp = GetFileAttributesW(dst);
3525 if(tmp==INVALID_FILE_ATTRIBUTES || !(tmp&FILE_ATTRIBUTE_DIRECTORY)) {
3526 FindClose(f);
3527 return CTL_E_FILEALREADYEXISTS;
3528 }
3529 }
3530
3531 FindClose(f);
3532 return create_error(GetLastError());
3533 }
3534 copied = TRUE;
3535
3536 hr = copy_file(src, src_len+name_len+2, dst, dst_len+name_len, overwrite);
3537 if(FAILED(hr) && hr!=CTL_E_FILENOTFOUND) {
3538 FindClose(f);
3539 return hr;
3540 }
3541
3542 hr = copy_folder(src, src_len+name_len+2, dst, dst_len+name_len, overwrite);
3543 if(FAILED(hr) && hr!=CTL_E_PATHNOTFOUND) {
3544 FindClose(f);
3545 return hr;
3546 }
3547 } while(FindNextFileW(f, &ffd));
3548 FindClose(f);
3549
3550 return copied ? S_OK : CTL_E_PATHNOTFOUND;
3551 }
3552
3553 static HRESULT WINAPI filesys_CopyFolder(IFileSystem3 *iface, BSTR Source,
3554 BSTR Destination, VARIANT_BOOL OverWriteFiles)
3555 {
3556 TRACE("%p %s %s %d\n", iface, debugstr_w(Source), debugstr_w(Destination), OverWriteFiles);
3557
3558 if(!Source || !Destination)
3559 return E_POINTER;
3560
3561 return copy_folder(Source, SysStringLen(Source), Destination,
3562 SysStringLen(Destination), OverWriteFiles);
3563 }
3564
3565 static HRESULT WINAPI filesys_CreateFolder(IFileSystem3 *iface, BSTR path,
3566 IFolder **folder)
3567 {
3568 BOOL ret;
3569
3570 TRACE("(%p)->(%s %p)\n", iface, debugstr_w(path), folder);
3571
3572 ret = CreateDirectoryW(path, NULL);
3573 if (!ret)
3574 {
3575 *folder = NULL;
3576 if (GetLastError() == ERROR_ALREADY_EXISTS) return CTL_E_FILEALREADYEXISTS;
3577 return HRESULT_FROM_WIN32(GetLastError());
3578 }
3579
3580 return create_folder(path, folder);
3581 }
3582
3583 static HRESULT WINAPI filesys_CreateTextFile(IFileSystem3 *iface, BSTR filename,
3584 VARIANT_BOOL overwrite, VARIANT_BOOL unicode,
3585 ITextStream **stream)
3586 {
3587 DWORD disposition;
3588
3589 TRACE("%p %s %d %d %p\n", iface, debugstr_w(filename), overwrite, unicode, stream);
3590
3591 disposition = overwrite == VARIANT_TRUE ? CREATE_ALWAYS : CREATE_NEW;
3592 return create_textstream(filename, disposition, ForWriting, !!unicode, stream);
3593 }
3594
3595 static HRESULT WINAPI filesys_OpenTextFile(IFileSystem3 *iface, BSTR filename,
3596 IOMode mode, VARIANT_BOOL create,
3597 Tristate format, ITextStream **stream)
3598 {
3599 DWORD disposition;
3600
3601 TRACE("(%p)->(%s %d %d %d %p)\n", iface, debugstr_w(filename), mode, create, format, stream);
3602 disposition = create == VARIANT_TRUE ? OPEN_ALWAYS : OPEN_EXISTING;
3603
3604 if (format == TristateUseDefault) {
3605 FIXME("default format not handled, defaulting to unicode\n");
3606 format = TristateTrue;
3607 }
3608
3609 return create_textstream(filename, disposition, mode, format == TristateTrue, stream);
3610 }
3611
3612 static HRESULT WINAPI filesys_GetStandardStream(IFileSystem3 *iface,
3613 StandardStreamTypes StandardStreamType,
3614 VARIANT_BOOL Unicode,
3615 ITextStream **ppts)
3616 {
3617 FIXME("%p %d %d %p\n", iface, StandardStreamType, Unicode, ppts);
3618
3619 return E_NOTIMPL;
3620 }
3621
3622 static void get_versionstring(VS_FIXEDFILEINFO *info, WCHAR *ver)
3623 {
3624 static const WCHAR fmtW[] = {'%','d','.','%','d','.','%','d','.','%','d',0};
3625 DWORDLONG version;
3626 WORD a, b, c, d;
3627
3628 version = (((DWORDLONG)info->dwFileVersionMS) << 32) + info->dwFileVersionLS;
3629 a = (WORD)( version >> 48);
3630 b = (WORD)((version >> 32) & 0xffff);
3631 c = (WORD)((version >> 16) & 0xffff);
3632 d = (WORD)( version & 0xffff);
3633
3634 sprintfW(ver, fmtW, a, b, c, d);
3635 }
3636
3637 static HRESULT WINAPI filesys_GetFileVersion(IFileSystem3 *iface, BSTR name, BSTR *version)
3638 {
3639 static const WCHAR rootW[] = {'\\',0};
3640 VS_FIXEDFILEINFO *info;
3641 WCHAR ver[30];
3642 void *ptr;
3643 DWORD len;
3644 BOOL ret;
3645
3646 TRACE("%p %s %p\n", iface, debugstr_w(name), version);
3647
3648 len = GetFileVersionInfoSizeW(name, NULL);
3649 if (!len)
3650 return HRESULT_FROM_WIN32(GetLastError());
3651
3652 ptr = heap_alloc(len);
3653 if (!GetFileVersionInfoW(name, 0, len, ptr))
3654 {
3655 heap_free(ptr);
3656 return HRESULT_FROM_WIN32(GetLastError());
3657 }
3658
3659 ret = VerQueryValueW(ptr, rootW, (void**)&info, &len);
3660 heap_free(ptr);
3661 if (!ret)
3662 return HRESULT_FROM_WIN32(GetLastError());
3663
3664 get_versionstring(info, ver);
3665 *version = SysAllocString(ver);
3666 TRACE("version=%s\n", debugstr_w(ver));
3667
3668 return S_OK;
3669 }
3670
3671 static const struct IFileSystem3Vtbl filesys_vtbl =
3672 {
3673 filesys_QueryInterface,
3674 filesys_AddRef,
3675 filesys_Release,
3676 filesys_GetTypeInfoCount,
3677 filesys_GetTypeInfo,
3678 filesys_GetIDsOfNames,
3679 filesys_Invoke,
3680 filesys_get_Drives,
3681 filesys_BuildPath,
3682 filesys_GetDriveName,
3683 filesys_GetParentFolderName,
3684 filesys_GetFileName,
3685 filesys_GetBaseName,
3686 filesys_GetExtensionName,
3687 filesys_GetAbsolutePathName,
3688 filesys_GetTempName,
3689 filesys_DriveExists,
3690 filesys_FileExists,
3691 filesys_FolderExists,
3692 filesys_GetDrive,
3693 filesys_GetFile,
3694 filesys_GetFolder,
3695 filesys_GetSpecialFolder,
3696 filesys_DeleteFile,
3697 filesys_DeleteFolder,
3698 filesys_MoveFile,
3699 filesys_MoveFolder,
3700 filesys_CopyFile,
3701 filesys_CopyFolder,
3702 filesys_CreateFolder,
3703 filesys_CreateTextFile,
3704 filesys_OpenTextFile,
3705 filesys_GetStandardStream,
3706 filesys_GetFileVersion
3707 };
3708
3709 static IFileSystem3 filesystem = { &filesys_vtbl };
3710
3711 HRESULT WINAPI FileSystem_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
3712 {
3713 TRACE("(%p %s %p)\n", outer, debugstr_guid(riid), ppv);
3714
3715 return IFileSystem3_QueryInterface(&filesystem, riid, ppv);
3716 }
Windows API implementation