?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
scrrun: Implement Count() property for file collection.
[wine/multimedia.git] / dlls / scrrun / filesystem.c
blobf5afb9174c33d7630e837e31f7ae17d1107b1862
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 static const WCHAR allW[] = {'\\','*',0};
1835 WIN32_FIND_DATAW data;
1836 WCHAR pathW[MAX_PATH];
1837 HANDLE handle;
1838
1839 TRACE("(%p)->(%p)\n", This, count);
1840
1841 if(!count)
1842 return E_POINTER;
1843
1844 *count = 0;
1845
1846 strcpyW(pathW, This->path);
1847 strcatW(pathW, allW);
1848 handle = FindFirstFileW(pathW, &data);
1849 if (handle == INVALID_HANDLE_VALUE)
1850 return HRESULT_FROM_WIN32(GetLastError());
1851
1852 do
1853 {
1854 if (is_file_data(&data))
1855 *count += 1;
1856 } while (FindNextFileW(handle, &data));
1857 FindClose(handle);
1858
1859 return S_OK;
1860 }
1861
1862 static const IFileCollectionVtbl filecollectionvtbl = {
1863 filecoll_QueryInterface,
1864 filecoll_AddRef,
1865 filecoll_Release,
1866 filecoll_GetTypeInfoCount,
1867 filecoll_GetTypeInfo,
1868 filecoll_GetIDsOfNames,
1869 filecoll_Invoke,
1870 filecoll_get_Item,
1871 filecoll_get__NewEnum,
1872 filecoll_get_Count
1873 };
1874
1875 static HRESULT create_filecoll(BSTR path, IFileCollection **files)
1876 {
1877 struct filecollection *This;
1878
1879 *files = NULL;
1880
1881 This = heap_alloc(sizeof(*This));
1882 if (!This) return E_OUTOFMEMORY;
1883
1884 This->IFileCollection_iface.lpVtbl = &filecollectionvtbl;
1885 This->ref = 1;
1886 This->path = SysAllocString(path);
1887 if (!This->path)
1888 {
1889 heap_free(This);
1890 return E_OUTOFMEMORY;
1891 }
1892
1893 *files = &This->IFileCollection_iface;
1894 return S_OK;
1895 }
1896
1897 static HRESULT WINAPI drivecoll_QueryInterface(IDriveCollection *iface, REFIID riid, void **obj)
1898 {
1899 struct drivecollection *This = impl_from_IDriveCollection(iface);
1900
1901 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
1902
1903 *obj = NULL;
1904
1905 if (IsEqualIID( riid, &IID_IDriveCollection ) ||
1906 IsEqualIID( riid, &IID_IDispatch ) ||
1907 IsEqualIID( riid, &IID_IUnknown ))
1908 {
1909 *obj = iface;
1910 IDriveCollection_AddRef(iface);
1911 }
1912 else
1913 return E_NOINTERFACE;
1914
1915 return S_OK;
1916 }
1917
1918 static ULONG WINAPI drivecoll_AddRef(IDriveCollection *iface)
1919 {
1920 struct drivecollection *This = impl_from_IDriveCollection(iface);
1921 ULONG ref = InterlockedIncrement(&This->ref);
1922 TRACE("(%p)->(%d)\n", This, ref);
1923 return ref;
1924 }
1925
1926 static ULONG WINAPI drivecoll_Release(IDriveCollection *iface)
1927 {
1928 struct drivecollection *This = impl_from_IDriveCollection(iface);
1929 ULONG ref = InterlockedDecrement(&This->ref);
1930 TRACE("(%p)->(%d)\n", This, ref);
1931
1932 if (!ref)
1933 heap_free(This);
1934
1935 return ref;
1936 }
1937
1938 static HRESULT WINAPI drivecoll_GetTypeInfoCount(IDriveCollection *iface, UINT *pctinfo)
1939 {
1940 struct drivecollection *This = impl_from_IDriveCollection(iface);
1941 TRACE("(%p)->(%p)\n", This, pctinfo);
1942 *pctinfo = 1;
1943 return S_OK;
1944 }
1945
1946 static HRESULT WINAPI drivecoll_GetTypeInfo(IDriveCollection *iface, UINT iTInfo,
1947 LCID lcid, ITypeInfo **ppTInfo)
1948 {
1949 struct drivecollection *This = impl_from_IDriveCollection(iface);
1950 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1951 return get_typeinfo(IDriveCollection_tid, ppTInfo);
1952 }
1953
1954 static HRESULT WINAPI drivecoll_GetIDsOfNames(IDriveCollection *iface, REFIID riid,
1955 LPOLESTR *rgszNames, UINT cNames,
1956 LCID lcid, DISPID *rgDispId)
1957 {
1958 struct drivecollection *This = impl_from_IDriveCollection(iface);
1959 ITypeInfo *typeinfo;
1960 HRESULT hr;
1961
1962 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
1963
1964 hr = get_typeinfo(IDriveCollection_tid, &typeinfo);
1965 if(SUCCEEDED(hr))
1966 {
1967 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1968 ITypeInfo_Release(typeinfo);
1969 }
1970
1971 return hr;
1972 }
1973
1974 static HRESULT WINAPI drivecoll_Invoke(IDriveCollection *iface, DISPID dispIdMember,
1975 REFIID riid, LCID lcid, WORD wFlags,
1976 DISPPARAMS *pDispParams, VARIANT *pVarResult,
1977 EXCEPINFO *pExcepInfo, UINT *puArgErr)
1978 {
1979 struct drivecollection *This = impl_from_IDriveCollection(iface);
1980 ITypeInfo *typeinfo;
1981 HRESULT hr;
1982
1983 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1984 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1985
1986 hr = get_typeinfo(IDriveCollection_tid, &typeinfo);
1987 if(SUCCEEDED(hr))
1988 {
1989 hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
1990 pDispParams, pVarResult, pExcepInfo, puArgErr);
1991 ITypeInfo_Release(typeinfo);
1992 }
1993
1994 return hr;
1995 }
1996
1997 static HRESULT WINAPI drivecoll_get_Item(IDriveCollection *iface, VARIANT key, IDrive **drive)
1998 {
1999 struct drivecollection *This = impl_from_IDriveCollection(iface);
2000 FIXME("(%p)->(%p): stub\n", This, drive);
2001 return E_NOTIMPL;
2002 }
2003
2004 static HRESULT WINAPI drivecoll_get__NewEnum(IDriveCollection *iface, IUnknown **ppenum)
2005 {
2006 struct drivecollection *This = impl_from_IDriveCollection(iface);
2007
2008 TRACE("(%p)->(%p)\n", This, ppenum);
2009
2010 if(!ppenum)
2011 return E_POINTER;
2012
2013 return create_drivecoll_enum(This, ppenum);
2014 }
2015
2016 static HRESULT WINAPI drivecoll_get_Count(IDriveCollection *iface, LONG *count)
2017 {
2018 struct drivecollection *This = impl_from_IDriveCollection(iface);
2019
2020 TRACE("(%p)->(%p)\n", This, count);
2021
2022 if (!count) return E_POINTER;
2023
2024 *count = This->count;
2025 return S_OK;
2026 }
2027
2028 static const IDriveCollectionVtbl drivecollectionvtbl = {
2029 drivecoll_QueryInterface,
2030 drivecoll_AddRef,
2031 drivecoll_Release,
2032 drivecoll_GetTypeInfoCount,
2033 drivecoll_GetTypeInfo,
2034 drivecoll_GetIDsOfNames,
2035 drivecoll_Invoke,
2036 drivecoll_get_Item,
2037 drivecoll_get__NewEnum,
2038 drivecoll_get_Count
2039 };
2040
2041 static HRESULT create_drivecoll(IDriveCollection **drives)
2042 {
2043 struct drivecollection *This;
2044 DWORD mask;
2045
2046 *drives = NULL;
2047
2048 This = heap_alloc(sizeof(*This));
2049 if (!This) return E_OUTOFMEMORY;
2050
2051 This->IDriveCollection_iface.lpVtbl = &drivecollectionvtbl;
2052 This->ref = 1;
2053 This->drives = mask = GetLogicalDrives();
2054 /* count set bits */
2055 for (This->count = 0; mask; This->count++)
2056 mask &= mask - 1;
2057
2058 *drives = &This->IDriveCollection_iface;
2059 return S_OK;
2060 }
2061
2062 static HRESULT WINAPI folder_QueryInterface(IFolder *iface, REFIID riid, void **obj)
2063 {
2064 struct folder *This = impl_from_IFolder(iface);
2065
2066 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
2067
2068 *obj = NULL;
2069
2070 if (IsEqualIID( riid, &IID_IFolder ) ||
2071 IsEqualIID( riid, &IID_IDispatch ) ||
2072 IsEqualIID( riid, &IID_IUnknown))
2073 {
2074 *obj = iface;
2075 IFolder_AddRef(iface);
2076 }
2077 else
2078 return E_NOINTERFACE;
2079
2080 return S_OK;
2081 }
2082
2083 static ULONG WINAPI folder_AddRef(IFolder *iface)
2084 {
2085 struct folder *This = impl_from_IFolder(iface);
2086 ULONG ref = InterlockedIncrement(&This->ref);
2087 TRACE("(%p)->(%d)\n", This, ref);
2088 return ref;
2089 }
2090
2091 static ULONG WINAPI folder_Release(IFolder *iface)
2092 {
2093 struct folder *This = impl_from_IFolder(iface);
2094 ULONG ref = InterlockedDecrement(&This->ref);
2095 TRACE("(%p)->(%d)\n", This, ref);
2096
2097 if (!ref)
2098 {
2099 SysFreeString(This->path);
2100 heap_free(This);
2101 }
2102
2103 return ref;
2104 }
2105
2106 static HRESULT WINAPI folder_GetTypeInfoCount(IFolder *iface, UINT *pctinfo)
2107 {
2108 struct folder *This = impl_from_IFolder(iface);
2109 TRACE("(%p)->(%p)\n", This, pctinfo);
2110 *pctinfo = 1;
2111 return S_OK;
2112 }
2113
2114 static HRESULT WINAPI folder_GetTypeInfo(IFolder *iface, UINT iTInfo,
2115 LCID lcid, ITypeInfo **ppTInfo)
2116 {
2117 struct folder *This = impl_from_IFolder(iface);
2118 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
2119 return get_typeinfo(IFolder_tid, ppTInfo);
2120 }
2121
2122 static HRESULT WINAPI folder_GetIDsOfNames(IFolder *iface, REFIID riid,
2123 LPOLESTR *rgszNames, UINT cNames,
2124 LCID lcid, DISPID *rgDispId)
2125 {
2126 struct folder *This = impl_from_IFolder(iface);
2127 ITypeInfo *typeinfo;
2128 HRESULT hr;
2129
2130 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
2131
2132 hr = get_typeinfo(IFolder_tid, &typeinfo);
2133 if(SUCCEEDED(hr))
2134 {
2135 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
2136 ITypeInfo_Release(typeinfo);
2137 }
2138
2139 return hr;
2140 }
2141
2142 static HRESULT WINAPI folder_Invoke(IFolder *iface, DISPID dispIdMember,
2143 REFIID riid, LCID lcid, WORD wFlags,
2144 DISPPARAMS *pDispParams, VARIANT *pVarResult,
2145 EXCEPINFO *pExcepInfo, UINT *puArgErr)
2146 {
2147 struct folder *This = impl_from_IFolder(iface);
2148 ITypeInfo *typeinfo;
2149 HRESULT hr;
2150
2151 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
2152 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2153
2154 hr = get_typeinfo(IFolder_tid, &typeinfo);
2155 if(SUCCEEDED(hr))
2156 {
2157 hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
2158 pDispParams, pVarResult, pExcepInfo, puArgErr);
2159 ITypeInfo_Release(typeinfo);
2160 }
2161
2162 return hr;
2163 }
2164
2165 static HRESULT WINAPI folder_get_Path(IFolder *iface, BSTR *path)
2166 {
2167 struct folder *This = impl_from_IFolder(iface);
2168
2169 TRACE("(%p)->(%p)\n", This, path);
2170
2171 if(!path)
2172 return E_POINTER;
2173
2174 *path = SysAllocString(This->path);
2175 return *path ? S_OK : E_OUTOFMEMORY;
2176 }
2177
2178 static HRESULT WINAPI folder_get_Name(IFolder *iface, BSTR *name)
2179 {
2180 struct folder *This = impl_from_IFolder(iface);
2181 WCHAR *ptr;
2182
2183 TRACE("(%p)->(%p)\n", This, name);
2184
2185 if(!name)
2186 return E_POINTER;
2187
2188 *name = NULL;
2189
2190 ptr = strrchrW(This->path, '\\');
2191 if (ptr)
2192 {
2193 *name = SysAllocString(ptr+1);
2194 TRACE("%s\n", debugstr_w(*name));
2195 if (!*name) return E_OUTOFMEMORY;
2196 }
2197 else
2198 return E_FAIL;
2199
2200 return S_OK;
2201 }
2202
2203 static HRESULT WINAPI folder_put_Name(IFolder *iface, BSTR name)
2204 {
2205 struct folder *This = impl_from_IFolder(iface);
2206 FIXME("(%p)->(%s): stub\n", This, debugstr_w(name));
2207 return E_NOTIMPL;
2208 }
2209
2210 static HRESULT WINAPI folder_get_ShortPath(IFolder *iface, BSTR *path)
2211 {
2212 struct folder *This = impl_from_IFolder(iface);
2213 FIXME("(%p)->(%p): stub\n", This, path);
2214 return E_NOTIMPL;
2215 }
2216
2217 static HRESULT WINAPI folder_get_ShortName(IFolder *iface, BSTR *name)
2218 {
2219 struct folder *This = impl_from_IFolder(iface);
2220 FIXME("(%p)->(%p): stub\n", This, name);
2221 return E_NOTIMPL;
2222 }
2223
2224 static HRESULT WINAPI folder_get_Drive(IFolder *iface, IDrive **drive)
2225 {
2226 struct folder *This = impl_from_IFolder(iface);
2227 FIXME("(%p)->(%p): stub\n", This, drive);
2228 return E_NOTIMPL;
2229 }
2230
2231 static HRESULT WINAPI folder_get_ParentFolder(IFolder *iface, IFolder **parent)
2232 {
2233 struct folder *This = impl_from_IFolder(iface);
2234 FIXME("(%p)->(%p): stub\n", This, parent);
2235 return E_NOTIMPL;
2236 }
2237
2238 static HRESULT WINAPI folder_get_Attributes(IFolder *iface, FileAttribute *attr)
2239 {
2240 struct folder *This = impl_from_IFolder(iface);
2241 FIXME("(%p)->(%p): stub\n", This, attr);
2242 return E_NOTIMPL;
2243 }
2244
2245 static HRESULT WINAPI folder_put_Attributes(IFolder *iface, FileAttribute attr)
2246 {
2247 struct folder *This = impl_from_IFolder(iface);
2248 FIXME("(%p)->(0x%x): stub\n", This, attr);
2249 return E_NOTIMPL;
2250 }
2251
2252 static HRESULT WINAPI folder_get_DateCreated(IFolder *iface, DATE *date)
2253 {
2254 struct folder *This = impl_from_IFolder(iface);
2255 FIXME("(%p)->(%p): stub\n", This, date);
2256 return E_NOTIMPL;
2257 }
2258
2259 static HRESULT WINAPI folder_get_DateLastModified(IFolder *iface, DATE *date)
2260 {
2261 struct folder *This = impl_from_IFolder(iface);
2262 FIXME("(%p)->(%p): stub\n", This, date);
2263 return E_NOTIMPL;
2264 }
2265
2266 static HRESULT WINAPI folder_get_DateLastAccessed(IFolder *iface, DATE *date)
2267 {
2268 struct folder *This = impl_from_IFolder(iface);
2269 FIXME("(%p)->(%p): stub\n", This, date);
2270 return E_NOTIMPL;
2271 }
2272
2273 static HRESULT WINAPI folder_get_Type(IFolder *iface, BSTR *type)
2274 {
2275 struct folder *This = impl_from_IFolder(iface);
2276 FIXME("(%p)->(%p): stub\n", This, type);
2277 return E_NOTIMPL;
2278 }
2279
2280 static HRESULT WINAPI folder_Delete(IFolder *iface, VARIANT_BOOL force)
2281 {
2282 struct folder *This = impl_from_IFolder(iface);
2283 FIXME("(%p)->(%x): stub\n", This, force);
2284 return E_NOTIMPL;
2285 }
2286
2287 static HRESULT WINAPI folder_Copy(IFolder *iface, BSTR dest, VARIANT_BOOL overwrite)
2288 {
2289 struct folder *This = impl_from_IFolder(iface);
2290 FIXME("(%p)->(%s %x): stub\n", This, debugstr_w(dest), overwrite);
2291 return E_NOTIMPL;
2292 }
2293
2294 static HRESULT WINAPI folder_Move(IFolder *iface, BSTR dest)
2295 {
2296 struct folder *This = impl_from_IFolder(iface);
2297 FIXME("(%p)->(%s): stub\n", This, debugstr_w(dest));
2298 return E_NOTIMPL;
2299 }
2300
2301 static HRESULT WINAPI folder_get_IsRootFolder(IFolder *iface, VARIANT_BOOL *isroot)
2302 {
2303 struct folder *This = impl_from_IFolder(iface);
2304 FIXME("(%p)->(%p): stub\n", This, isroot);
2305 return E_NOTIMPL;
2306 }
2307
2308 static HRESULT WINAPI folder_get_Size(IFolder *iface, VARIANT *size)
2309 {
2310 struct folder *This = impl_from_IFolder(iface);
2311 FIXME("(%p)->(%p): stub\n", This, size);
2312 return E_NOTIMPL;
2313 }
2314
2315 static HRESULT WINAPI folder_get_SubFolders(IFolder *iface, IFolderCollection **folders)
2316 {
2317 struct folder *This = impl_from_IFolder(iface);
2318
2319 TRACE("(%p)->(%p)\n", This, folders);
2320
2321 if(!folders)
2322 return E_POINTER;
2323
2324 return create_foldercoll(This->path, folders);
2325 }
2326
2327 static HRESULT WINAPI folder_get_Files(IFolder *iface, IFileCollection **files)
2328 {
2329 struct folder *This = impl_from_IFolder(iface);
2330
2331 TRACE("(%p)->(%p)\n", This, files);
2332
2333 if(!files)
2334 return E_POINTER;
2335
2336 return create_filecoll(This->path, files);
2337 }
2338
2339 static HRESULT WINAPI folder_CreateTextFile(IFolder *iface, BSTR filename, VARIANT_BOOL overwrite,
2340 VARIANT_BOOL unicode, ITextStream **stream)
2341 {
2342 struct folder *This = impl_from_IFolder(iface);
2343 FIXME("(%p)->(%s %x %x %p): stub\n", This, debugstr_w(filename), overwrite, unicode, stream);
2344 return E_NOTIMPL;
2345 }
2346
2347 static const IFolderVtbl foldervtbl = {
2348 folder_QueryInterface,
2349 folder_AddRef,
2350 folder_Release,
2351 folder_GetTypeInfoCount,
2352 folder_GetTypeInfo,
2353 folder_GetIDsOfNames,
2354 folder_Invoke,
2355 folder_get_Path,
2356 folder_get_Name,
2357 folder_put_Name,
2358 folder_get_ShortPath,
2359 folder_get_ShortName,
2360 folder_get_Drive,
2361 folder_get_ParentFolder,
2362 folder_get_Attributes,
2363 folder_put_Attributes,
2364 folder_get_DateCreated,
2365 folder_get_DateLastModified,
2366 folder_get_DateLastAccessed,
2367 folder_get_Type,
2368 folder_Delete,
2369 folder_Copy,
2370 folder_Move,
2371 folder_get_IsRootFolder,
2372 folder_get_Size,
2373 folder_get_SubFolders,
2374 folder_get_Files,
2375 folder_CreateTextFile
2376 };
2377
2378 HRESULT create_folder(const WCHAR *path, IFolder **folder)
2379 {
2380 struct folder *This;
2381
2382 *folder = NULL;
2383
2384 TRACE("%s\n", debugstr_w(path));
2385
2386 This = heap_alloc(sizeof(struct folder));
2387 if (!This) return E_OUTOFMEMORY;
2388
2389 This->IFolder_iface.lpVtbl = &foldervtbl;
2390 This->ref = 1;
2391 This->path = SysAllocString(path);
2392 if (!This->path)
2393 {
2394 heap_free(This);
2395 return E_OUTOFMEMORY;
2396 }
2397
2398 *folder = &This->IFolder_iface;
2399
2400 return S_OK;
2401 }
2402
2403 static HRESULT WINAPI file_QueryInterface(IFile *iface, REFIID riid, void **obj)
2404 {
2405 struct file *This = impl_from_IFile(iface);
2406
2407 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
2408
2409 if (IsEqualIID(riid, &IID_IFile) ||
2410 IsEqualIID(riid, &IID_IDispatch) ||
2411 IsEqualIID(riid, &IID_IUnknown))
2412 {
2413 *obj = iface;
2414 IFile_AddRef(iface);
2415 return S_OK;
2416 }
2417
2418 *obj = NULL;
2419 return E_NOINTERFACE;
2420 }
2421
2422 static ULONG WINAPI file_AddRef(IFile *iface)
2423 {
2424 struct file *This = impl_from_IFile(iface);
2425 LONG ref = InterlockedIncrement(&This->ref);
2426
2427 TRACE("(%p) ref=%d\n", This, ref);
2428
2429 return ref;
2430 }
2431
2432 static ULONG WINAPI file_Release(IFile *iface)
2433 {
2434 struct file *This = impl_from_IFile(iface);
2435 LONG ref = InterlockedDecrement(&This->ref);
2436
2437 TRACE("(%p) ref=%d\n", This, ref);
2438
2439 if(!ref)
2440 {
2441 heap_free(This->path);
2442 heap_free(This);
2443 }
2444
2445 return ref;
2446 }
2447
2448 static HRESULT WINAPI file_GetTypeInfoCount(IFile *iface, UINT *pctinfo)
2449 {
2450 struct file *This = impl_from_IFile(iface);
2451
2452 TRACE("(%p)->(%p)\n", This, pctinfo);
2453
2454 *pctinfo = 1;
2455 return S_OK;
2456 }
2457
2458 static HRESULT WINAPI file_GetTypeInfo(IFile *iface,
2459 UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
2460 {
2461 struct file *This = impl_from_IFile(iface);
2462
2463 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
2464
2465 return get_typeinfo(IFile_tid, ppTInfo);
2466 }
2467
2468 static HRESULT WINAPI file_GetIDsOfNames(IFile *iface, REFIID riid,
2469 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
2470 {
2471 struct file *This = impl_from_IFile(iface);
2472 ITypeInfo *typeinfo;
2473 HRESULT hr;
2474
2475 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid),
2476 rgszNames, cNames, lcid, rgDispId);
2477
2478 hr = get_typeinfo(IFile_tid, &typeinfo);
2479 if(SUCCEEDED(hr)) {
2480 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
2481 ITypeInfo_Release(typeinfo);
2482 }
2483 return hr;
2484 }
2485
2486 static HRESULT WINAPI file_Invoke(IFile *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2487 {
2488 struct file *This = impl_from_IFile(iface);
2489 ITypeInfo *typeinfo;
2490 HRESULT hr;
2491
2492 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
2493 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2494
2495 hr = get_typeinfo(IFile_tid, &typeinfo);
2496 if(SUCCEEDED(hr))
2497 {
2498 hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
2499 pDispParams, pVarResult, pExcepInfo, puArgErr);
2500 ITypeInfo_Release(typeinfo);
2501 }
2502 return hr;
2503 }
2504
2505 static HRESULT WINAPI file_get_Path(IFile *iface, BSTR *pbstrPath)
2506 {
2507 struct file *This = impl_from_IFile(iface);
2508 FIXME("(%p)->(%p)\n", This, pbstrPath);
2509 return E_NOTIMPL;
2510 }
2511
2512 static HRESULT WINAPI file_get_Name(IFile *iface, BSTR *name)
2513 {
2514 struct file *This = impl_from_IFile(iface);
2515 WCHAR *ptr;
2516
2517 TRACE("(%p)->(%p)\n", This, name);
2518
2519 if(!name)
2520 return E_POINTER;
2521
2522 *name = NULL;
2523
2524 ptr = strrchrW(This->path, '\\');
2525 if (ptr)
2526 {
2527 *name = SysAllocString(ptr+1);
2528 TRACE("%s\n", debugstr_w(*name));
2529 if (!*name) return E_OUTOFMEMORY;
2530 }
2531 else
2532 return E_FAIL;
2533
2534 return S_OK;
2535 }
2536
2537 static HRESULT WINAPI file_put_Name(IFile *iface, BSTR pbstrName)
2538 {
2539 struct file *This = impl_from_IFile(iface);
2540 FIXME("(%p)->(%s)\n", This, debugstr_w(pbstrName));
2541 return E_NOTIMPL;
2542 }
2543
2544 static HRESULT WINAPI file_get_ShortPath(IFile *iface, BSTR *pbstrPath)
2545 {
2546 struct file *This = impl_from_IFile(iface);
2547 FIXME("(%p)->(%p)\n", This, pbstrPath);
2548 return E_NOTIMPL;
2549 }
2550
2551 static HRESULT WINAPI file_get_ShortName(IFile *iface, BSTR *pbstrName)
2552 {
2553 struct file *This = impl_from_IFile(iface);
2554 FIXME("(%p)->(%p)\n", This, pbstrName);
2555 return E_NOTIMPL;
2556 }
2557
2558 static HRESULT WINAPI file_get_Drive(IFile *iface, IDrive **ppdrive)
2559 {
2560 struct file *This = impl_from_IFile(iface);
2561 FIXME("(%p)->(%p)\n", This, ppdrive);
2562 return E_NOTIMPL;
2563 }
2564
2565 static HRESULT WINAPI file_get_ParentFolder(IFile *iface, IFolder **ppfolder)
2566 {
2567 struct file *This = impl_from_IFile(iface);
2568 FIXME("(%p)->(%p)\n", This, ppfolder);
2569 return E_NOTIMPL;
2570 }
2571
2572 static HRESULT WINAPI file_get_Attributes(IFile *iface, FileAttribute *pfa)
2573 {
2574 struct file *This = impl_from_IFile(iface);
2575 DWORD fa;
2576
2577 TRACE("(%p)->(%p)\n", This, pfa);
2578
2579 if(!pfa)
2580 return E_POINTER;
2581
2582 fa = GetFileAttributesW(This->path);
2583 if(fa == INVALID_FILE_ATTRIBUTES)
2584 return create_error(GetLastError());
2585
2586 *pfa = fa & (FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN |
2587 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_ARCHIVE |
2588 FILE_ATTRIBUTE_REPARSE_POINT | FILE_ATTRIBUTE_COMPRESSED);
2589 return S_OK;
2590 }
2591
2592 static HRESULT WINAPI file_put_Attributes(IFile *iface, FileAttribute pfa)
2593 {
2594 struct file *This = impl_from_IFile(iface);
2595 FIXME("(%p)->(%x)\n", This, pfa);
2596 return E_NOTIMPL;
2597 }
2598
2599 static HRESULT WINAPI file_get_DateCreated(IFile *iface, DATE *pdate)
2600 {
2601 struct file *This = impl_from_IFile(iface);
2602 FIXME("(%p)->(%p)\n", This, pdate);
2603 return E_NOTIMPL;
2604 }
2605
2606 static HRESULT WINAPI file_get_DateLastModified(IFile *iface, DATE *pdate)
2607 {
2608 struct file *This = impl_from_IFile(iface);
2609 FIXME("(%p)->(%p)\n", This, pdate);
2610 return E_NOTIMPL;
2611 }
2612
2613 static HRESULT WINAPI file_get_DateLastAccessed(IFile *iface, DATE *pdate)
2614 {
2615 struct file *This = impl_from_IFile(iface);
2616 FIXME("(%p)->(%p)\n", This, pdate);
2617 return E_NOTIMPL;
2618 }
2619
2620 static HRESULT WINAPI file_get_Size(IFile *iface, VARIANT *pvarSize)
2621 {
2622 struct file *This = impl_from_IFile(iface);
2623 WIN32_FIND_DATAW fd;
2624 HANDLE f;
2625
2626 TRACE("(%p)->(%p)\n", This, pvarSize);
2627
2628 if(!pvarSize)
2629 return E_POINTER;
2630
2631 f = FindFirstFileW(This->path, &fd);
2632 if(f == INVALID_HANDLE_VALUE)
2633 return create_error(GetLastError());
2634 FindClose(f);
2635
2636 if(fd.nFileSizeHigh || fd.nFileSizeLow>INT_MAX) {
2637 V_VT(pvarSize) = VT_R8;
2638 V_R8(pvarSize) = ((ULONGLONG)fd.nFileSizeHigh<<32) + fd.nFileSizeLow;
2639 }else {
2640 V_VT(pvarSize) = VT_I4;
2641 V_I4(pvarSize) = fd.nFileSizeLow;
2642 }
2643 return S_OK;
2644 }
2645
2646 static HRESULT WINAPI file_get_Type(IFile *iface, BSTR *pbstrType)
2647 {
2648 struct file *This = impl_from_IFile(iface);
2649 FIXME("(%p)->(%p)\n", This, pbstrType);
2650 return E_NOTIMPL;
2651 }
2652
2653 static HRESULT WINAPI file_Delete(IFile *iface, VARIANT_BOOL Force)
2654 {
2655 struct file *This = impl_from_IFile(iface);
2656 FIXME("(%p)->(%x)\n", This, Force);
2657 return E_NOTIMPL;
2658 }
2659
2660 static HRESULT WINAPI file_Copy(IFile *iface, BSTR Destination, VARIANT_BOOL OverWriteFiles)
2661 {
2662 struct file *This = impl_from_IFile(iface);
2663 FIXME("(%p)->(%s %x)\n", This, debugstr_w(Destination), OverWriteFiles);
2664 return E_NOTIMPL;
2665 }
2666
2667 static HRESULT WINAPI file_Move(IFile *iface, BSTR Destination)
2668 {
2669 struct file *This = impl_from_IFile(iface);
2670 FIXME("(%p)->(%s)\n", This, debugstr_w(Destination));
2671 return E_NOTIMPL;
2672 }
2673
2674 static HRESULT WINAPI file_OpenAsTextStream(IFile *iface, IOMode mode, Tristate format, ITextStream **stream)
2675 {
2676 struct file *This = impl_from_IFile(iface);
2677
2678 TRACE("(%p)->(%d %d %p)\n", This, mode, format, stream);
2679
2680 if (format == TristateUseDefault) {
2681 FIXME("default format not handled, defaulting to unicode\n");
2682 format = TristateTrue;
2683 }
2684
2685 return create_textstream(This->path, OPEN_EXISTING, mode, format == TristateTrue, stream);
2686 }
2687
2688 static const IFileVtbl file_vtbl = {
2689 file_QueryInterface,
2690 file_AddRef,
2691 file_Release,
2692 file_GetTypeInfoCount,
2693 file_GetTypeInfo,
2694 file_GetIDsOfNames,
2695 file_Invoke,
2696 file_get_Path,
2697 file_get_Name,
2698 file_put_Name,
2699 file_get_ShortPath,
2700 file_get_ShortName,
2701 file_get_Drive,
2702 file_get_ParentFolder,
2703 file_get_Attributes,
2704 file_put_Attributes,
2705 file_get_DateCreated,
2706 file_get_DateLastModified,
2707 file_get_DateLastAccessed,
2708 file_get_Size,
2709 file_get_Type,
2710 file_Delete,
2711 file_Copy,
2712 file_Move,
2713 file_OpenAsTextStream
2714 };
2715
2716 static HRESULT create_file(BSTR path, IFile **file)
2717 {
2718 struct file *f;
2719 DWORD len, attrs;
2720
2721 *file = NULL;
2722
2723 f = heap_alloc(sizeof(struct file));
2724 if(!f)
2725 return E_OUTOFMEMORY;
2726
2727 f->IFile_iface.lpVtbl = &file_vtbl;
2728 f->ref = 1;
2729
2730 len = GetFullPathNameW(path, 0, NULL, NULL);
2731 if(!len) {
2732 heap_free(f);
2733 return E_FAIL;
2734 }
2735
2736 f->path = heap_alloc(len*sizeof(WCHAR));
2737 if(!f->path) {
2738 heap_free(f);
2739 return E_OUTOFMEMORY;
2740 }
2741
2742 if(!GetFullPathNameW(path, len, f->path, NULL)) {
2743 heap_free(f->path);
2744 heap_free(f);
2745 return E_FAIL;
2746 }
2747
2748 attrs = GetFileAttributesW(f->path);
2749 if(attrs==INVALID_FILE_ATTRIBUTES ||
2750 (attrs&(FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_DEVICE))) {
2751 heap_free(f->path);
2752 heap_free(f);
2753 return create_error(GetLastError());
2754 }
2755
2756 *file = &f->IFile_iface;
2757 return S_OK;
2758 }
2759
2760 static HRESULT WINAPI filesys_QueryInterface(IFileSystem3 *iface, REFIID riid, void **ppvObject)
2761 {
2762 TRACE("%p %s %p\n", iface, debugstr_guid(riid), ppvObject);
2763
2764 if ( IsEqualGUID( riid, &IID_IFileSystem3 ) ||
2765 IsEqualGUID( riid, &IID_IFileSystem ) ||
2766 IsEqualGUID( riid, &IID_IDispatch ) ||
2767 IsEqualGUID( riid, &IID_IUnknown ) )
2768 {
2769 *ppvObject = iface;
2770 }
2771 else if ( IsEqualGUID( riid, &IID_IDispatchEx ))
2772 {
2773 TRACE("Interface IDispatchEx not supported - returning NULL\n");
2774 *ppvObject = NULL;
2775 return E_NOINTERFACE;
2776 }
2777 else if ( IsEqualGUID( riid, &IID_IObjectWithSite ))
2778 {
2779 TRACE("Interface IObjectWithSite not supported - returning NULL\n");
2780 *ppvObject = NULL;
2781 return E_NOINTERFACE;
2782 }
2783 else
2784 {
2785 FIXME("Unsupported interface %s\n", debugstr_guid(riid));
2786 return E_NOINTERFACE;
2787 }
2788
2789 IFileSystem3_AddRef(iface);
2790
2791 return S_OK;
2792 }
2793
2794 static ULONG WINAPI filesys_AddRef(IFileSystem3 *iface)
2795 {
2796 TRACE("%p\n", iface);
2797
2798 return 2;
2799 }
2800
2801 static ULONG WINAPI filesys_Release(IFileSystem3 *iface)
2802 {
2803 TRACE("%p\n", iface);
2804
2805 return 1;
2806 }
2807
2808 static HRESULT WINAPI filesys_GetTypeInfoCount(IFileSystem3 *iface, UINT *pctinfo)
2809 {
2810 TRACE("(%p)->(%p)\n", iface, pctinfo);
2811
2812 *pctinfo = 1;
2813 return S_OK;
2814 }
2815
2816 static HRESULT WINAPI filesys_GetTypeInfo(IFileSystem3 *iface, UINT iTInfo,
2817 LCID lcid, ITypeInfo **ppTInfo)
2818 {
2819 TRACE("(%p)->(%u %u %p)\n", iface, iTInfo, lcid, ppTInfo);
2820 return get_typeinfo(IFileSystem3_tid, ppTInfo);
2821 }
2822
2823 static HRESULT WINAPI filesys_GetIDsOfNames(IFileSystem3 *iface, REFIID riid,
2824 LPOLESTR *rgszNames, UINT cNames,
2825 LCID lcid, DISPID *rgDispId)
2826 {
2827 ITypeInfo *typeinfo;
2828 HRESULT hr;
2829
2830 TRACE("(%p)->(%s %p %u %u %p)\n", iface, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
2831
2832 hr = get_typeinfo(IFileSystem3_tid, &typeinfo);
2833 if(SUCCEEDED(hr))
2834 {
2835 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
2836 ITypeInfo_Release(typeinfo);
2837 }
2838
2839 return hr;
2840 }
2841
2842 static HRESULT WINAPI filesys_Invoke(IFileSystem3 *iface, DISPID dispIdMember,
2843 REFIID riid, LCID lcid, WORD wFlags,
2844 DISPPARAMS *pDispParams, VARIANT *pVarResult,
2845 EXCEPINFO *pExcepInfo, UINT *puArgErr)
2846 {
2847 ITypeInfo *typeinfo;
2848 HRESULT hr;
2849
2850 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", iface, dispIdMember, debugstr_guid(riid),
2851 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2852
2853 hr = get_typeinfo(IFileSystem3_tid, &typeinfo);
2854 if(SUCCEEDED(hr))
2855 {
2856 hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
2857 pDispParams, pVarResult, pExcepInfo, puArgErr);
2858 ITypeInfo_Release(typeinfo);
2859 }
2860
2861 return hr;
2862 }
2863
2864 static HRESULT WINAPI filesys_get_Drives(IFileSystem3 *iface, IDriveCollection **ppdrives)
2865 {
2866 TRACE("%p %p\n", iface, ppdrives);
2867 return create_drivecoll(ppdrives);
2868 }
2869
2870 static HRESULT WINAPI filesys_BuildPath(IFileSystem3 *iface, BSTR Path,
2871 BSTR Name, BSTR *Result)
2872 {
2873 BSTR ret;
2874
2875 TRACE("%p %s %s %p\n", iface, debugstr_w(Path), debugstr_w(Name), Result);
2876
2877 if (!Result) return E_POINTER;
2878
2879 if (Path && Name)
2880 {
2881 int path_len = SysStringLen(Path), name_len = SysStringLen(Name);
2882
2883 /* if both parts have backslashes strip one from Path */
2884 if (Path[path_len-1] == '\\' && Name[0] == '\\')
2885 {
2886 path_len -= 1;
2887
2888 ret = SysAllocStringLen(NULL, path_len + name_len);
2889 if (ret)
2890 {
2891 strcpyW(ret, Path);
2892 ret[path_len] = 0;
2893 strcatW(ret, Name);
2894 }
2895 }
2896 else if (Path[path_len-1] != '\\' && Name[0] != '\\')
2897 {
2898 ret = SysAllocStringLen(NULL, path_len + name_len + 1);
2899 if (ret)
2900 {
2901 strcpyW(ret, Path);
2902 if (Path[path_len-1] != ':')
2903 strcatW(ret, bsW);
2904 strcatW(ret, Name);
2905 }
2906 }
2907 else
2908 {
2909 ret = SysAllocStringLen(NULL, path_len + name_len);
2910 if (ret)
2911 {
2912 strcpyW(ret, Path);
2913 strcatW(ret, Name);
2914 }
2915 }
2916 }
2917 else if (Path || Name)
2918 ret = SysAllocString(Path ? Path : Name);
2919 else
2920 ret = SysAllocStringLen(NULL, 0);
2921
2922 if (!ret) return E_OUTOFMEMORY;
2923 *Result = ret;
2924
2925 return S_OK;
2926 }
2927
2928 static HRESULT WINAPI filesys_GetDriveName(IFileSystem3 *iface, BSTR Path,
2929 BSTR *pbstrResult)
2930 {
2931 FIXME("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
2932
2933 return E_NOTIMPL;
2934 }
2935
2936 static inline DWORD get_parent_folder_name(const WCHAR *path, DWORD len)
2937 {
2938 int i;
2939
2940 if(!path)
2941 return 0;
2942
2943 for(i=len-1; i>=0; i--)
2944 if(path[i]!='/' && path[i]!='\\')
2945 break;
2946
2947 for(; i>=0; i--)
2948 if(path[i]=='/' || path[i]=='\\')
2949 break;
2950
2951 for(; i>=0; i--)
2952 if(path[i]!='/' && path[i]!='\\')
2953 break;
2954
2955 if(i < 0)
2956 return 0;
2957
2958 if(path[i]==':' && i==1)
2959 i++;
2960 return i+1;
2961 }
2962
2963 static HRESULT WINAPI filesys_GetParentFolderName(IFileSystem3 *iface, BSTR Path,
2964 BSTR *pbstrResult)
2965 {
2966 DWORD len;
2967
2968 TRACE("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
2969
2970 if(!pbstrResult)
2971 return E_POINTER;
2972
2973 len = get_parent_folder_name(Path, SysStringLen(Path));
2974 if(!len) {
2975 *pbstrResult = NULL;
2976 return S_OK;
2977 }
2978
2979 *pbstrResult = SysAllocStringLen(Path, len);
2980 if(!*pbstrResult)
2981 return E_OUTOFMEMORY;
2982 return S_OK;
2983 }
2984
2985 static HRESULT WINAPI filesys_GetFileName(IFileSystem3 *iface, BSTR Path,
2986 BSTR *pbstrResult)
2987 {
2988 int i, end;
2989
2990 TRACE("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
2991
2992 if(!pbstrResult)
2993 return E_POINTER;
2994
2995 if(!Path) {
2996 *pbstrResult = NULL;
2997 return S_OK;
2998 }
2999
3000 for(end=strlenW(Path)-1; end>=0; end--)
3001 if(Path[end]!='/' && Path[end]!='\\')
3002 break;
3003
3004 for(i=end; i>=0; i--)
3005 if(Path[i]=='/' || Path[i]=='\\')
3006 break;
3007 i++;
3008
3009 if(i>end || (i==0 && end==1 && Path[1]==':')) {
3010 *pbstrResult = NULL;
3011 return S_OK;
3012 }
3013
3014 *pbstrResult = SysAllocStringLen(Path+i, end-i+1);
3015 if(!*pbstrResult)
3016 return E_OUTOFMEMORY;
3017 return S_OK;
3018 }
3019
3020 static HRESULT WINAPI filesys_GetBaseName(IFileSystem3 *iface, BSTR Path,
3021 BSTR *pbstrResult)
3022 {
3023 int i, end;
3024
3025 TRACE("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
3026
3027 if(!pbstrResult)
3028 return E_POINTER;
3029
3030 if(!Path) {
3031 *pbstrResult = NULL;
3032 return S_OK;
3033 }
3034
3035 for(end=strlenW(Path)-1; end>=0; end--)
3036 if(Path[end]!='/' && Path[end]!='\\')
3037 break;
3038
3039 for(i=end; i>=0; i--) {
3040 if(Path[i]=='.' && Path[end+1]!='.')
3041 end = i-1;
3042 if(Path[i]=='/' || Path[i]=='\\')
3043 break;
3044 }
3045 i++;
3046
3047 if((i>end && Path[end+1]!='.') || (i==0 && end==1 && Path[1]==':')) {
3048 *pbstrResult = NULL;
3049 return S_OK;
3050 }
3051
3052 *pbstrResult = SysAllocStringLen(Path+i, end-i+1);
3053 if(!*pbstrResult)
3054 return E_OUTOFMEMORY;
3055 return S_OK;
3056 }
3057
3058 static HRESULT WINAPI filesys_GetExtensionName(IFileSystem3 *iface, BSTR Path,
3059 BSTR *pbstrResult)
3060 {
3061 FIXME("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
3062
3063 return E_NOTIMPL;
3064 }
3065
3066 static HRESULT WINAPI filesys_GetAbsolutePathName(IFileSystem3 *iface, BSTR Path,
3067 BSTR *pbstrResult)
3068 {
3069 static const WCHAR cur_path[] = {'.',0};
3070
3071 WCHAR buf[MAX_PATH], ch;
3072 const WCHAR *path;
3073 DWORD i, beg, len, exp_len;
3074 WIN32_FIND_DATAW fdata;
3075 HANDLE fh;
3076
3077 TRACE("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
3078
3079 if(!pbstrResult)
3080 return E_POINTER;
3081
3082 if(!Path)
3083 path = cur_path;
3084 else
3085 path = Path;
3086
3087 len = GetFullPathNameW(path, MAX_PATH, buf, NULL);
3088 if(!len)
3089 return E_FAIL;
3090
3091 buf[0] = toupperW(buf[0]);
3092 if(len>3 && buf[len-1] == '\\')
3093 buf[--len] = 0;
3094
3095 for(beg=3, i=3; i<=len; i++) {
3096 if(buf[i]!='\\' && buf[i])
3097 continue;
3098
3099 ch = buf[i];
3100 buf[i] = 0;
3101 fh = FindFirstFileW(buf, &fdata);
3102 if(fh == INVALID_HANDLE_VALUE)
3103 break;
3104
3105 exp_len = strlenW(fdata.cFileName);
3106 if(exp_len == i-beg)
3107 memcpy(buf+beg, fdata.cFileName, exp_len*sizeof(WCHAR));
3108 FindClose(fh);
3109 buf[i] = ch;
3110 beg = i+1;
3111 }
3112
3113 *pbstrResult = SysAllocString(buf);
3114 if(!*pbstrResult)
3115 return E_OUTOFMEMORY;
3116 return S_OK;
3117 }
3118
3119 static HRESULT WINAPI filesys_GetTempName(IFileSystem3 *iface, BSTR *pbstrResult)
3120 {
3121 static const WCHAR fmt[] = {'r','a','d','%','0','5','X','.','t','x','t',0};
3122
3123 DWORD random;
3124
3125 TRACE("%p %p\n", iface, pbstrResult);
3126
3127 if(!pbstrResult)
3128 return E_POINTER;
3129
3130 *pbstrResult = SysAllocStringLen(NULL, 12);
3131 if(!*pbstrResult)
3132 return E_OUTOFMEMORY;
3133
3134 if(!RtlGenRandom(&random, sizeof(random)))
3135 return E_FAIL;
3136 sprintfW(*pbstrResult, fmt, random & 0xfffff);
3137 return S_OK;
3138 }
3139
3140 static HRESULT WINAPI filesys_DriveExists(IFileSystem3 *iface, BSTR DriveSpec,
3141 VARIANT_BOOL *pfExists)
3142 {
3143 FIXME("%p %s %p\n", iface, debugstr_w(DriveSpec), pfExists);
3144
3145 return E_NOTIMPL;
3146 }
3147
3148 static HRESULT WINAPI filesys_FileExists(IFileSystem3 *iface, BSTR path, VARIANT_BOOL *ret)
3149 {
3150 DWORD attrs;
3151 TRACE("%p %s %p\n", iface, debugstr_w(path), ret);
3152
3153 if (!ret) return E_POINTER;
3154
3155 attrs = GetFileAttributesW(path);
3156 *ret = attrs != INVALID_FILE_ATTRIBUTES && !(attrs & FILE_ATTRIBUTE_DIRECTORY) ? VARIANT_TRUE : VARIANT_FALSE;
3157 return S_OK;
3158 }
3159
3160 static HRESULT WINAPI filesys_FolderExists(IFileSystem3 *iface, BSTR path, VARIANT_BOOL *ret)
3161 {
3162 DWORD attrs;
3163 TRACE("%p %s %p\n", iface, debugstr_w(path), ret);
3164
3165 if (!ret) return E_POINTER;
3166
3167 attrs = GetFileAttributesW(path);
3168 *ret = attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY) ? VARIANT_TRUE : VARIANT_FALSE;
3169
3170 return S_OK;
3171 }
3172
3173 static HRESULT WINAPI filesys_GetDrive(IFileSystem3 *iface, BSTR DriveSpec,
3174 IDrive **ppdrive)
3175 {
3176 FIXME("%p %s %p\n", iface, debugstr_w(DriveSpec), ppdrive);
3177
3178 return E_NOTIMPL;
3179 }
3180
3181 static HRESULT WINAPI filesys_GetFile(IFileSystem3 *iface, BSTR FilePath,
3182 IFile **ppfile)
3183 {
3184 TRACE("%p %s %p\n", iface, debugstr_w(FilePath), ppfile);
3185
3186 if(!ppfile)
3187 return E_POINTER;
3188 if(!FilePath)
3189 return E_INVALIDARG;
3190
3191 return create_file(FilePath, ppfile);
3192 }
3193
3194 static HRESULT WINAPI filesys_GetFolder(IFileSystem3 *iface, BSTR FolderPath,
3195 IFolder **folder)
3196 {
3197 DWORD attrs;
3198
3199 TRACE("%p %s %p\n", iface, debugstr_w(FolderPath), folder);
3200
3201 if(!folder)
3202 return E_POINTER;
3203
3204 *folder = NULL;
3205 if(!FolderPath)
3206 return E_INVALIDARG;
3207
3208 attrs = GetFileAttributesW(FolderPath);
3209 if((attrs == INVALID_FILE_ATTRIBUTES) || !(attrs & FILE_ATTRIBUTE_DIRECTORY))
3210 return CTL_E_PATHNOTFOUND;
3211
3212 return create_folder(FolderPath, folder);
3213 }
3214
3215 static HRESULT WINAPI filesys_GetSpecialFolder(IFileSystem3 *iface,
3216 SpecialFolderConst SpecialFolder,
3217 IFolder **ppfolder)
3218 {
3219 FIXME("%p %d %p\n", iface, SpecialFolder, ppfolder);
3220
3221 return E_NOTIMPL;
3222 }
3223
3224 static inline HRESULT delete_file(const WCHAR *file, DWORD file_len, VARIANT_BOOL force)
3225 {
3226 WCHAR path[MAX_PATH];
3227 DWORD len, name_len;
3228 WIN32_FIND_DATAW ffd;
3229 HANDLE f;
3230
3231 f = FindFirstFileW(file, &ffd);
3232 if(f == INVALID_HANDLE_VALUE)
3233 return create_error(GetLastError());
3234
3235 len = get_parent_folder_name(file, file_len);
3236 if(len+1 >= MAX_PATH) {
3237 FindClose(f);
3238 return E_FAIL;
3239 }
3240 if(len) {
3241 memcpy(path, file, len*sizeof(WCHAR));
3242 path[len++] = '\\';
3243 }
3244
3245 do {
3246 if(ffd.dwFileAttributes & (FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_DEVICE))
3247 continue;
3248
3249 name_len = strlenW(ffd.cFileName);
3250 if(len+name_len+1 >= MAX_PATH) {
3251 FindClose(f);
3252 return E_FAIL;
3253 }
3254 memcpy(path+len, ffd.cFileName, (name_len+1)*sizeof(WCHAR));
3255
3256 TRACE("deleting %s\n", debugstr_w(path));
3257
3258 if(!DeleteFileW(path)) {
3259 if(!force || !SetFileAttributesW(path, FILE_ATTRIBUTE_NORMAL)
3260 || !DeleteFileW(path)) {
3261 FindClose(f);
3262 return create_error(GetLastError());
3263 }
3264 }
3265 } while(FindNextFileW(f, &ffd));
3266 FindClose(f);
3267
3268 return S_OK;
3269 }
3270
3271 static HRESULT WINAPI filesys_DeleteFile(IFileSystem3 *iface, BSTR FileSpec,
3272 VARIANT_BOOL Force)
3273 {
3274 TRACE("%p %s %d\n", iface, debugstr_w(FileSpec), Force);
3275
3276 if(!FileSpec)
3277 return E_POINTER;
3278
3279 return delete_file(FileSpec, SysStringLen(FileSpec), Force);
3280 }
3281
3282 static HRESULT delete_folder(const WCHAR *folder, DWORD folder_len, VARIANT_BOOL force)
3283 {
3284 WCHAR path[MAX_PATH];
3285 DWORD len, name_len;
3286 WIN32_FIND_DATAW ffd;
3287 HANDLE f;
3288 HRESULT hr;
3289
3290 f = FindFirstFileW(folder, &ffd);
3291 if(f == INVALID_HANDLE_VALUE)
3292 return create_error(GetLastError());
3293
3294 len = get_parent_folder_name(folder, folder_len);
3295 if(len+1 >= MAX_PATH) {
3296 FindClose(f);
3297 return E_FAIL;
3298 }
3299 if(len) {
3300 memcpy(path, folder, len*sizeof(WCHAR));
3301 path[len++] = '\\';
3302 }
3303
3304 do {
3305 if(!(ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
3306 continue;
3307 if(ffd.cFileName[0]=='.' && (ffd.cFileName[1]==0 ||
3308 (ffd.cFileName[1]=='.' && ffd.cFileName[2]==0)))
3309 continue;
3310
3311 name_len = strlenW(ffd.cFileName);
3312 if(len+name_len+3 >= MAX_PATH) {
3313 FindClose(f);
3314 return E_FAIL;
3315 }
3316 memcpy(path+len, ffd.cFileName, name_len*sizeof(WCHAR));
3317 path[len+name_len] = '\\';
3318 path[len+name_len+1] = '*';
3319 path[len+name_len+2] = 0;
3320
3321 hr = delete_file(path, len+name_len+2, force);
3322 if(FAILED(hr)) {
3323 FindClose(f);
3324 return hr;
3325 }
3326
3327 hr = delete_folder(path, len+name_len+2, force);
3328 if(FAILED(hr)) {
3329 FindClose(f);
3330 return hr;
3331 }
3332
3333 path[len+name_len] = 0;
3334 TRACE("deleting %s\n", debugstr_w(path));
3335
3336 if(!RemoveDirectoryW(path)) {
3337 FindClose(f);
3338 return create_error(GetLastError());
3339 }
3340 } while(FindNextFileW(f, &ffd));
3341 FindClose(f);
3342
3343 return S_OK;
3344 }
3345
3346 static HRESULT WINAPI filesys_DeleteFolder(IFileSystem3 *iface, BSTR FolderSpec,
3347 VARIANT_BOOL Force)
3348 {
3349 TRACE("%p %s %d\n", iface, debugstr_w(FolderSpec), Force);
3350
3351 if(!FolderSpec)
3352 return E_POINTER;
3353
3354 return delete_folder(FolderSpec, SysStringLen(FolderSpec), Force);
3355 }
3356
3357 static HRESULT WINAPI filesys_MoveFile(IFileSystem3 *iface, BSTR Source,
3358 BSTR Destination)
3359 {
3360 FIXME("%p %s %s\n", iface, debugstr_w(Source), debugstr_w(Destination));
3361
3362 return E_NOTIMPL;
3363 }
3364
3365 static HRESULT WINAPI filesys_MoveFolder(IFileSystem3 *iface,BSTR Source,
3366 BSTR Destination)
3367 {
3368 FIXME("%p %s %s\n", iface, debugstr_w(Source), debugstr_w(Destination));
3369
3370 return E_NOTIMPL;
3371 }
3372
3373 static inline HRESULT copy_file(const WCHAR *source, DWORD source_len,
3374 const WCHAR *destination, DWORD destination_len, VARIANT_BOOL overwrite)
3375 {
3376 DWORD attrs;
3377 WCHAR src_path[MAX_PATH], dst_path[MAX_PATH];
3378 DWORD src_len, dst_len, name_len;
3379 WIN32_FIND_DATAW ffd;
3380 HANDLE f;
3381 HRESULT hr;
3382
3383 if(!source[0] || !destination[0])
3384 return E_INVALIDARG;
3385
3386 attrs = GetFileAttributesW(destination);
3387 if(attrs==INVALID_FILE_ATTRIBUTES || !(attrs & FILE_ATTRIBUTE_DIRECTORY)) {
3388 attrs = GetFileAttributesW(source);
3389 if(attrs == INVALID_FILE_ATTRIBUTES)
3390 return create_error(GetLastError());
3391 else if(attrs & FILE_ATTRIBUTE_DIRECTORY)
3392 return CTL_E_FILENOTFOUND;
3393
3394 if(!CopyFileW(source, destination, !overwrite))
3395 return create_error(GetLastError());
3396 return S_OK;
3397 }
3398
3399 f = FindFirstFileW(source, &ffd);
3400 if(f == INVALID_HANDLE_VALUE)
3401 return CTL_E_FILENOTFOUND;
3402
3403 src_len = get_parent_folder_name(source, source_len);
3404 if(src_len+1 >= MAX_PATH) {
3405 FindClose(f);
3406 return E_FAIL;
3407 }
3408 if(src_len) {
3409 memcpy(src_path, source, src_len*sizeof(WCHAR));
3410 src_path[src_len++] = '\\';
3411 }
3412
3413 dst_len = destination_len;
3414 if(dst_len+1 >= MAX_PATH) {
3415 FindClose(f);
3416 return E_FAIL;
3417 }
3418 memcpy(dst_path, destination, dst_len*sizeof(WCHAR));
3419 if(dst_path[dst_len-1]!= '\\' && dst_path[dst_len-1]!='/')
3420 dst_path[dst_len++] = '\\';
3421
3422 hr = CTL_E_FILENOTFOUND;
3423 do {
3424 if(ffd.dwFileAttributes & (FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_DEVICE))
3425 continue;
3426
3427 name_len = strlenW(ffd.cFileName);
3428 if(src_len+name_len+1>=MAX_PATH || dst_len+name_len+1>=MAX_PATH) {
3429 FindClose(f);
3430 return E_FAIL;
3431 }
3432 memcpy(src_path+src_len, ffd.cFileName, (name_len+1)*sizeof(WCHAR));
3433 memcpy(dst_path+dst_len, ffd.cFileName, (name_len+1)*sizeof(WCHAR));
3434
3435 TRACE("copying %s to %s\n", debugstr_w(src_path), debugstr_w(dst_path));
3436
3437 if(!CopyFileW(src_path, dst_path, !overwrite)) {
3438 FindClose(f);
3439 return create_error(GetLastError());
3440 }else {
3441 hr = S_OK;
3442 }
3443 } while(FindNextFileW(f, &ffd));
3444 FindClose(f);
3445
3446 return hr;
3447 }
3448
3449 static HRESULT WINAPI filesys_CopyFile(IFileSystem3 *iface, BSTR Source,
3450 BSTR Destination, VARIANT_BOOL OverWriteFiles)
3451 {
3452 TRACE("%p %s %s %d\n", iface, debugstr_w(Source), debugstr_w(Destination), OverWriteFiles);
3453
3454 if(!Source || !Destination)
3455 return E_POINTER;
3456
3457 return copy_file(Source, SysStringLen(Source), Destination,
3458 SysStringLen(Destination), OverWriteFiles);
3459 }
3460
3461 static HRESULT copy_folder(const WCHAR *source, DWORD source_len, const WCHAR *destination,
3462 DWORD destination_len, VARIANT_BOOL overwrite)
3463 {
3464 DWORD tmp, src_len, dst_len, name_len;
3465 WCHAR src[MAX_PATH], dst[MAX_PATH];
3466 WIN32_FIND_DATAW ffd;
3467 HANDLE f;
3468 HRESULT hr;
3469 BOOL copied = FALSE;
3470
3471 if(!source[0] || !destination[0])
3472 return E_INVALIDARG;
3473
3474 dst_len = destination_len;
3475 if(dst_len+1 >= MAX_PATH)
3476 return E_FAIL;
3477 memcpy(dst, destination, (dst_len+1)*sizeof(WCHAR));
3478
3479 if(dst[dst_len-1]!='\\' && dst[dst_len-1]!='/' &&
3480 (tmp = GetFileAttributesW(source))!=INVALID_FILE_ATTRIBUTES &&
3481 tmp&FILE_ATTRIBUTE_DIRECTORY) {
3482 if(!CreateDirectoryW(dst, NULL)) {
3483 if(overwrite && GetLastError()==ERROR_ALREADY_EXISTS) {
3484 tmp = GetFileAttributesW(dst);
3485 if(tmp==INVALID_FILE_ATTRIBUTES || !(tmp&FILE_ATTRIBUTE_DIRECTORY))
3486 return CTL_E_FILEALREADYEXISTS;
3487 }else {
3488 return create_error(GetLastError());
3489 }
3490 }
3491 copied = TRUE;
3492
3493 src_len = source_len;
3494 if(src_len+2 >= MAX_PATH)
3495 return E_FAIL;
3496 memcpy(src, source, src_len*sizeof(WCHAR));
3497 src[src_len++] = '\\';
3498 src[src_len] = '*';
3499 src[src_len+1] = 0;
3500
3501 hr = copy_file(src, src_len+1, dst, dst_len, overwrite);
3502 if(FAILED(hr) && hr!=CTL_E_FILENOTFOUND)
3503 return create_error(GetLastError());
3504
3505 f = FindFirstFileW(src, &ffd);
3506 }else {
3507 src_len = get_parent_folder_name(source, source_len);
3508 if(src_len+2 >= MAX_PATH)
3509 return E_FAIL;
3510 memcpy(src, source, src_len*sizeof(WCHAR));
3511 if(src_len)
3512 src[src_len++] = '\\';
3513
3514 f = FindFirstFileW(source, &ffd);
3515 }
3516 if(f == INVALID_HANDLE_VALUE)
3517 return CTL_E_PATHNOTFOUND;
3518
3519 dst[dst_len++] = '\\';
3520 dst[dst_len] = 0;
3521
3522 do {
3523 if(!(ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
3524 continue;
3525 if(ffd.cFileName[0]=='.' && (ffd.cFileName[1]==0 ||
3526 (ffd.cFileName[1]=='.' && ffd.cFileName[2]==0)))
3527 continue;
3528
3529 name_len = strlenW(ffd.cFileName);
3530 if(dst_len+name_len>=MAX_PATH || src_len+name_len+2>=MAX_PATH) {
3531 FindClose(f);
3532 return E_FAIL;
3533 }
3534 memcpy(dst+dst_len, ffd.cFileName, name_len*sizeof(WCHAR));
3535 dst[dst_len+name_len] = 0;
3536 memcpy(src+src_len, ffd.cFileName, name_len*sizeof(WCHAR));
3537 src[src_len+name_len] = '\\';
3538 src[src_len+name_len+1] = '*';
3539 src[src_len+name_len+2] = 0;
3540
3541 TRACE("copying %s to %s\n", debugstr_w(src), debugstr_w(dst));
3542
3543 if(!CreateDirectoryW(dst, NULL)) {
3544 if(overwrite && GetLastError()==ERROR_ALREADY_EXISTS) {
3545 tmp = GetFileAttributesW(dst);
3546 if(tmp==INVALID_FILE_ATTRIBUTES || !(tmp&FILE_ATTRIBUTE_DIRECTORY)) {
3547 FindClose(f);
3548 return CTL_E_FILEALREADYEXISTS;
3549 }
3550 }
3551
3552 FindClose(f);
3553 return create_error(GetLastError());
3554 }
3555 copied = TRUE;
3556
3557 hr = copy_file(src, src_len+name_len+2, dst, dst_len+name_len, overwrite);
3558 if(FAILED(hr) && hr!=CTL_E_FILENOTFOUND) {
3559 FindClose(f);
3560 return hr;
3561 }
3562
3563 hr = copy_folder(src, src_len+name_len+2, dst, dst_len+name_len, overwrite);
3564 if(FAILED(hr) && hr!=CTL_E_PATHNOTFOUND) {
3565 FindClose(f);
3566 return hr;
3567 }
3568 } while(FindNextFileW(f, &ffd));
3569 FindClose(f);
3570
3571 return copied ? S_OK : CTL_E_PATHNOTFOUND;
3572 }
3573
3574 static HRESULT WINAPI filesys_CopyFolder(IFileSystem3 *iface, BSTR Source,
3575 BSTR Destination, VARIANT_BOOL OverWriteFiles)
3576 {
3577 TRACE("%p %s %s %d\n", iface, debugstr_w(Source), debugstr_w(Destination), OverWriteFiles);
3578
3579 if(!Source || !Destination)
3580 return E_POINTER;
3581
3582 return copy_folder(Source, SysStringLen(Source), Destination,
3583 SysStringLen(Destination), OverWriteFiles);
3584 }
3585
3586 static HRESULT WINAPI filesys_CreateFolder(IFileSystem3 *iface, BSTR path,
3587 IFolder **folder)
3588 {
3589 BOOL ret;
3590
3591 TRACE("(%p)->(%s %p)\n", iface, debugstr_w(path), folder);
3592
3593 ret = CreateDirectoryW(path, NULL);
3594 if (!ret)
3595 {
3596 *folder = NULL;
3597 if (GetLastError() == ERROR_ALREADY_EXISTS) return CTL_E_FILEALREADYEXISTS;
3598 return HRESULT_FROM_WIN32(GetLastError());
3599 }
3600
3601 return create_folder(path, folder);
3602 }
3603
3604 static HRESULT WINAPI filesys_CreateTextFile(IFileSystem3 *iface, BSTR filename,
3605 VARIANT_BOOL overwrite, VARIANT_BOOL unicode,
3606 ITextStream **stream)
3607 {
3608 DWORD disposition;
3609
3610 TRACE("%p %s %d %d %p\n", iface, debugstr_w(filename), overwrite, unicode, stream);
3611
3612 disposition = overwrite == VARIANT_TRUE ? CREATE_ALWAYS : CREATE_NEW;
3613 return create_textstream(filename, disposition, ForWriting, !!unicode, stream);
3614 }
3615
3616 static HRESULT WINAPI filesys_OpenTextFile(IFileSystem3 *iface, BSTR filename,
3617 IOMode mode, VARIANT_BOOL create,
3618 Tristate format, ITextStream **stream)
3619 {
3620 DWORD disposition;
3621
3622 TRACE("(%p)->(%s %d %d %d %p)\n", iface, debugstr_w(filename), mode, create, format, stream);
3623 disposition = create == VARIANT_TRUE ? OPEN_ALWAYS : OPEN_EXISTING;
3624
3625 if (format == TristateUseDefault) {
3626 FIXME("default format not handled, defaulting to unicode\n");
3627 format = TristateTrue;
3628 }
3629
3630 return create_textstream(filename, disposition, mode, format == TristateTrue, stream);
3631 }
3632
3633 static HRESULT WINAPI filesys_GetStandardStream(IFileSystem3 *iface,
3634 StandardStreamTypes StandardStreamType,
3635 VARIANT_BOOL Unicode,
3636 ITextStream **ppts)
3637 {
3638 FIXME("%p %d %d %p\n", iface, StandardStreamType, Unicode, ppts);
3639
3640 return E_NOTIMPL;
3641 }
3642
3643 static void get_versionstring(VS_FIXEDFILEINFO *info, WCHAR *ver)
3644 {
3645 static const WCHAR fmtW[] = {'%','d','.','%','d','.','%','d','.','%','d',0};
3646 DWORDLONG version;
3647 WORD a, b, c, d;
3648
3649 version = (((DWORDLONG)info->dwFileVersionMS) << 32) + info->dwFileVersionLS;
3650 a = (WORD)( version >> 48);
3651 b = (WORD)((version >> 32) & 0xffff);
3652 c = (WORD)((version >> 16) & 0xffff);
3653 d = (WORD)( version & 0xffff);
3654
3655 sprintfW(ver, fmtW, a, b, c, d);
3656 }
3657
3658 static HRESULT WINAPI filesys_GetFileVersion(IFileSystem3 *iface, BSTR name, BSTR *version)
3659 {
3660 static const WCHAR rootW[] = {'\\',0};
3661 VS_FIXEDFILEINFO *info;
3662 WCHAR ver[30];
3663 void *ptr;
3664 DWORD len;
3665 BOOL ret;
3666
3667 TRACE("%p %s %p\n", iface, debugstr_w(name), version);
3668
3669 len = GetFileVersionInfoSizeW(name, NULL);
3670 if (!len)
3671 return HRESULT_FROM_WIN32(GetLastError());
3672
3673 ptr = heap_alloc(len);
3674 if (!GetFileVersionInfoW(name, 0, len, ptr))
3675 {
3676 heap_free(ptr);
3677 return HRESULT_FROM_WIN32(GetLastError());
3678 }
3679
3680 ret = VerQueryValueW(ptr, rootW, (void**)&info, &len);
3681 if (!ret)
3682 {
3683 heap_free(ptr);
3684 return HRESULT_FROM_WIN32(GetLastError());
3685 }
3686
3687 get_versionstring(info, ver);
3688 heap_free(ptr);
3689
3690 *version = SysAllocString(ver);
3691 TRACE("version=%s\n", debugstr_w(ver));
3692
3693 return S_OK;
3694 }
3695
3696 static const struct IFileSystem3Vtbl filesys_vtbl =
3697 {
3698 filesys_QueryInterface,
3699 filesys_AddRef,
3700 filesys_Release,
3701 filesys_GetTypeInfoCount,
3702 filesys_GetTypeInfo,
3703 filesys_GetIDsOfNames,
3704 filesys_Invoke,
3705 filesys_get_Drives,
3706 filesys_BuildPath,
3707 filesys_GetDriveName,
3708 filesys_GetParentFolderName,
3709 filesys_GetFileName,
3710 filesys_GetBaseName,
3711 filesys_GetExtensionName,
3712 filesys_GetAbsolutePathName,
3713 filesys_GetTempName,
3714 filesys_DriveExists,
3715 filesys_FileExists,
3716 filesys_FolderExists,
3717 filesys_GetDrive,
3718 filesys_GetFile,
3719 filesys_GetFolder,
3720 filesys_GetSpecialFolder,
3721 filesys_DeleteFile,
3722 filesys_DeleteFolder,
3723 filesys_MoveFile,
3724 filesys_MoveFolder,
3725 filesys_CopyFile,
3726 filesys_CopyFolder,
3727 filesys_CreateFolder,
3728 filesys_CreateTextFile,
3729 filesys_OpenTextFile,
3730 filesys_GetStandardStream,
3731 filesys_GetFileVersion
3732 };
3733
3734 static IFileSystem3 filesystem = { &filesys_vtbl };
3735
3736 HRESULT WINAPI FileSystem_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
3737 {
3738 TRACE("(%p %s %p)\n", outer, debugstr_guid(riid), ppv);
3739
3740 return IFileSystem3_QueryInterface(&filesystem, riid, ppv);
3741 }
Maarten's multimedia branch