dlls/scrrun/filesystem.c

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