filesystem.c File Reference

#include <stdarg.h>
#include <limits.h>
#include "windef.h"
#include "winbase.h"
#include "ole2.h"
#include "olectl.h"
#include "dispex.h"
#include "ntsecapi.h"
#include "scrrun.h"
#include "scrrun_private.h"
#include "wine/debug.h"
#include "wine/heap.h"

Include dependency graph for filesystem.c:

Go to the source code of this file.

Classes
struct	filesystem
struct	foldercollection
struct	filecollection
struct	drivecollection
struct	enumdata
struct	enumvariant
struct	drive
struct	folder
struct	file
struct	textstream

Macros
#define	COBJMACROS

Enumerations
enum	iotype { IORead , IOWrite }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (scrrun)
static struct filesystem *	impl_from_IFileSystem3 (IFileSystem3 *iface)
static struct drive *	impl_from_IDrive (IDrive *iface)
static struct folder *	impl_from_IFolder (IFolder *iface)
static struct file *	impl_from_IFile (IFile *iface)
static struct textstream *	impl_from_ITextStream (ITextStream *iface)
static struct foldercollection *	impl_from_IFolderCollection (IFolderCollection *iface)
static struct filecollection *	impl_from_IFileCollection (IFileCollection *iface)
static struct drivecollection *	impl_from_IDriveCollection (IDriveCollection *iface)
static struct enumvariant *	impl_from_IEnumVARIANT (IEnumVARIANT *iface)
static HRESULT	create_error (DWORD err)
static HRESULT	create_folder (const WCHAR *, IFolder **)
static HRESULT	create_file (BSTR, IFile **)
static HRESULT	create_foldercoll_enum (struct foldercollection *, IUnknown **)
static HRESULT	create_filecoll_enum (struct filecollection *, IUnknown **)
static HRESULT	create_drivecoll_enum (struct drivecollection *, IUnknown **)
static BOOL	is_dir_data (const WIN32_FIND_DATAW *data)
static BOOL	is_file_data (const WIN32_FIND_DATAW *data)
static BSTR	get_full_path (BSTR path, const WIN32_FIND_DATAW *data)
static BOOL	textstream_check_iomode (struct textstream *This, enum iotype type)
static HRESULT WINAPI	textstream_QueryInterface (ITextStream *iface, REFIID riid, void **obj)
static ULONG WINAPI	textstream_AddRef (ITextStream *iface)
static ULONG WINAPI	textstream_Release (ITextStream *iface)
static HRESULT WINAPI	textstream_GetTypeInfoCount (ITextStream *iface, UINT *pctinfo)
static HRESULT WINAPI	textstream_GetTypeInfo (ITextStream *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	textstream_GetIDsOfNames (ITextStream *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
static HRESULT WINAPI	textstream_Invoke (ITextStream *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
static HRESULT WINAPI	textstream_get_Line (ITextStream *iface, LONG *line)
static HRESULT WINAPI	textstream_get_Column (ITextStream *iface, LONG *column)
static HRESULT WINAPI	textstream_get_AtEndOfStream (ITextStream *iface, VARIANT_BOOL *eos)
static HRESULT WINAPI	textstream_get_AtEndOfLine (ITextStream *iface, VARIANT_BOOL *eol)
static HRESULT	textstream_read (struct textstream *stream, LONG toread, BOOL bof, BSTR *text)
static HRESULT WINAPI	textstream_Read (ITextStream *iface, LONG len, BSTR *text)
static HRESULT WINAPI	textstream_ReadLine (ITextStream *iface, BSTR *text)
static HRESULT WINAPI	textstream_ReadAll (ITextStream *iface, BSTR *text)
static HRESULT	textstream_writestr (struct textstream *stream, BSTR text)
static HRESULT WINAPI	textstream_Write (ITextStream *iface, BSTR text)
static HRESULT	textstream_writecrlf (struct textstream *stream)
static HRESULT WINAPI	textstream_WriteLine (ITextStream *iface, BSTR text)
static HRESULT WINAPI	textstream_WriteBlankLines (ITextStream *iface, LONG lines)
static HRESULT WINAPI	textstream_Skip (ITextStream *iface, LONG count)
static HRESULT WINAPI	textstream_SkipLine (ITextStream *iface)
static HRESULT WINAPI	textstream_Close (ITextStream *iface)
static HRESULT	create_textstream (const WCHAR *filename, DWORD disposition, IOMode mode, Tristate format, ITextStream **ret)
static HRESULT WINAPI	drive_QueryInterface (IDrive *iface, REFIID riid, void **obj)
static ULONG WINAPI	drive_AddRef (IDrive *iface)
static ULONG WINAPI	drive_Release (IDrive *iface)
static HRESULT WINAPI	drive_GetTypeInfoCount (IDrive *iface, UINT *pctinfo)
static HRESULT WINAPI	drive_GetTypeInfo (IDrive *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	drive_GetIDsOfNames (IDrive *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
static HRESULT WINAPI	drive_Invoke (IDrive *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
static HRESULT WINAPI	drive_get_Path (IDrive *iface, BSTR *path)
static HRESULT WINAPI	drive_get_DriveLetter (IDrive *iface, BSTR *letter)
static HRESULT WINAPI	drive_get_ShareName (IDrive *iface, BSTR *share_name)
static HRESULT WINAPI	drive_get_DriveType (IDrive *iface, DriveTypeConst *type)
static HRESULT WINAPI	drive_get_RootFolder (IDrive *iface, IFolder **folder)
static HRESULT	variant_from_largeint (const ULARGE_INTEGER *src, VARIANT *v)
static HRESULT WINAPI	drive_get_AvailableSpace (IDrive *iface, VARIANT *v)
static HRESULT WINAPI	drive_get_FreeSpace (IDrive *iface, VARIANT *v)
static HRESULT WINAPI	drive_get_TotalSize (IDrive *iface, VARIANT *v)
static HRESULT WINAPI	drive_get_VolumeName (IDrive *iface, BSTR *name)
static HRESULT WINAPI	drive_put_VolumeName (IDrive *iface, BSTR name)
static HRESULT WINAPI	drive_get_FileSystem (IDrive *iface, BSTR *fs)
static HRESULT WINAPI	drive_get_SerialNumber (IDrive *iface, LONG *serial)
static HRESULT WINAPI	drive_get_IsReady (IDrive *iface, VARIANT_BOOL *ready)
static HRESULT	create_drive (WCHAR letter, IDrive **drive)
static HRESULT WINAPI	enumvariant_QueryInterface (IEnumVARIANT *iface, REFIID riid, void **obj)
static ULONG WINAPI	enumvariant_AddRef (IEnumVARIANT *iface)
static ULONG WINAPI	foldercoll_enumvariant_Release (IEnumVARIANT *iface)
static HANDLE	start_enumeration (const WCHAR *path, WIN32_FIND_DATAW *data, BOOL file)
static HRESULT WINAPI	foldercoll_enumvariant_Next (IEnumVARIANT *iface, ULONG celt, VARIANT *var, ULONG *fetched)
static HRESULT WINAPI	foldercoll_enumvariant_Skip (IEnumVARIANT *iface, ULONG celt)
static HRESULT WINAPI	foldercoll_enumvariant_Reset (IEnumVARIANT *iface)
static HRESULT WINAPI	foldercoll_enumvariant_Clone (IEnumVARIANT *iface, IEnumVARIANT **pclone)
static ULONG WINAPI	filecoll_enumvariant_Release (IEnumVARIANT *iface)
static HRESULT WINAPI	filecoll_enumvariant_Next (IEnumVARIANT *iface, ULONG celt, VARIANT *var, ULONG *fetched)
static HRESULT WINAPI	filecoll_enumvariant_Skip (IEnumVARIANT *iface, ULONG celt)
static HRESULT WINAPI	filecoll_enumvariant_Reset (IEnumVARIANT *iface)
static HRESULT WINAPI	filecoll_enumvariant_Clone (IEnumVARIANT *iface, IEnumVARIANT **pclone)
static ULONG WINAPI	drivecoll_enumvariant_Release (IEnumVARIANT *iface)
static HRESULT	find_next_drive (struct enumvariant *penum)
static HRESULT WINAPI	drivecoll_enumvariant_Next (IEnumVARIANT *iface, ULONG celt, VARIANT *var, ULONG *fetched)
static HRESULT WINAPI	drivecoll_enumvariant_Skip (IEnumVARIANT *iface, ULONG celt)
static HRESULT WINAPI	drivecoll_enumvariant_Reset (IEnumVARIANT *iface)
static HRESULT WINAPI	drivecoll_enumvariant_Clone (IEnumVARIANT *iface, IEnumVARIANT **pclone)
static HRESULT WINAPI	foldercoll_QueryInterface (IFolderCollection *iface, REFIID riid, void **obj)
static ULONG WINAPI	foldercoll_AddRef (IFolderCollection *iface)
static ULONG WINAPI	foldercoll_Release (IFolderCollection *iface)
static HRESULT WINAPI	foldercoll_GetTypeInfoCount (IFolderCollection *iface, UINT *pctinfo)
static HRESULT WINAPI	foldercoll_GetTypeInfo (IFolderCollection *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	foldercoll_GetIDsOfNames (IFolderCollection *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
static HRESULT WINAPI	foldercoll_Invoke (IFolderCollection *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
static HRESULT WINAPI	foldercoll_Add (IFolderCollection *iface, BSTR name, IFolder **folder)
static HRESULT WINAPI	foldercoll_get_Item (IFolderCollection *iface, VARIANT key, IFolder **folder)
static HRESULT WINAPI	foldercoll_get__NewEnum (IFolderCollection *iface, IUnknown **newenum)
static HRESULT WINAPI	foldercoll_get_Count (IFolderCollection *iface, LONG *count)
static HRESULT	create_foldercoll (BSTR path, IFolderCollection **folders)
static HRESULT WINAPI	filecoll_QueryInterface (IFileCollection *iface, REFIID riid, void **obj)
static ULONG WINAPI	filecoll_AddRef (IFileCollection *iface)
static ULONG WINAPI	filecoll_Release (IFileCollection *iface)
static HRESULT WINAPI	filecoll_GetTypeInfoCount (IFileCollection *iface, UINT *pctinfo)
static HRESULT WINAPI	filecoll_GetTypeInfo (IFileCollection *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	filecoll_GetIDsOfNames (IFileCollection *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
static HRESULT WINAPI	filecoll_Invoke (IFileCollection *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
static HRESULT WINAPI	filecoll_get_Item (IFileCollection *iface, VARIANT Key, IFile **file)
static HRESULT WINAPI	filecoll_get__NewEnum (IFileCollection *iface, IUnknown **ppenum)
static HRESULT WINAPI	filecoll_get_Count (IFileCollection *iface, LONG *count)
static HRESULT	create_filecoll (BSTR path, IFileCollection **files)
static HRESULT WINAPI	drivecoll_QueryInterface (IDriveCollection *iface, REFIID riid, void **obj)
static ULONG WINAPI	drivecoll_AddRef (IDriveCollection *iface)
static ULONG WINAPI	drivecoll_Release (IDriveCollection *iface)
static HRESULT WINAPI	drivecoll_GetTypeInfoCount (IDriveCollection *iface, UINT *pctinfo)
static HRESULT WINAPI	drivecoll_GetTypeInfo (IDriveCollection *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	drivecoll_GetIDsOfNames (IDriveCollection *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
static HRESULT WINAPI	drivecoll_Invoke (IDriveCollection *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
static HRESULT WINAPI	drivecoll_get_Item (IDriveCollection *iface, VARIANT key, IDrive **drive)
static HRESULT WINAPI	drivecoll_get__NewEnum (IDriveCollection *iface, IUnknown **ppenum)
static HRESULT WINAPI	drivecoll_get_Count (IDriveCollection *iface, LONG *count)
static HRESULT	create_drivecoll (IDriveCollection **drives)
static HRESULT WINAPI	folder_QueryInterface (IFolder *iface, REFIID riid, void **obj)
static ULONG WINAPI	folder_AddRef (IFolder *iface)
static ULONG WINAPI	folder_Release (IFolder *iface)
static HRESULT WINAPI	folder_GetTypeInfoCount (IFolder *iface, UINT *pctinfo)
static HRESULT WINAPI	folder_GetTypeInfo (IFolder *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	folder_GetIDsOfNames (IFolder *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
static HRESULT WINAPI	folder_Invoke (IFolder *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
static HRESULT WINAPI	folder_get_Path (IFolder *iface, BSTR *path)
static HRESULT WINAPI	folder_get_Name (IFolder *iface, BSTR *name)
static HRESULT WINAPI	folder_put_Name (IFolder *iface, BSTR name)
static HRESULT WINAPI	folder_get_ShortPath (IFolder *iface, BSTR *path)
static HRESULT WINAPI	folder_get_ShortName (IFolder *iface, BSTR *name)
static HRESULT WINAPI	folder_get_Drive (IFolder *iface, IDrive **drive)
static HRESULT WINAPI	folder_get_ParentFolder (IFolder *iface, IFolder **parent)
static HRESULT WINAPI	folder_get_Attributes (IFolder *iface, FileAttribute *attr)
static HRESULT WINAPI	folder_put_Attributes (IFolder *iface, FileAttribute attr)
static HRESULT WINAPI	folder_get_DateCreated (IFolder *iface, DATE *date)
static HRESULT WINAPI	folder_get_DateLastModified (IFolder *iface, DATE *date)
static HRESULT WINAPI	folder_get_DateLastAccessed (IFolder *iface, DATE *date)
static HRESULT WINAPI	folder_get_Type (IFolder *iface, BSTR *type)
static HRESULT WINAPI	folder_Delete (IFolder *iface, VARIANT_BOOL force)
static HRESULT WINAPI	folder_Copy (IFolder *iface, BSTR dest, VARIANT_BOOL overwrite)
static HRESULT WINAPI	folder_Move (IFolder *iface, BSTR dest)
static HRESULT WINAPI	folder_get_IsRootFolder (IFolder *iface, VARIANT_BOOL *isroot)
static HRESULT WINAPI	folder_get_Size (IFolder *iface, VARIANT *size)
static HRESULT WINAPI	folder_get_SubFolders (IFolder *iface, IFolderCollection **folders)
static HRESULT WINAPI	folder_get_Files (IFolder *iface, IFileCollection **files)
static HRESULT WINAPI	folder_CreateTextFile (IFolder *iface, BSTR filename, VARIANT_BOOL overwrite, VARIANT_BOOL unicode, ITextStream **stream)
static HRESULT WINAPI	file_QueryInterface (IFile *iface, REFIID riid, void **obj)
static ULONG WINAPI	file_AddRef (IFile *iface)
static ULONG WINAPI	file_Release (IFile *iface)
static HRESULT WINAPI	file_GetTypeInfoCount (IFile *iface, UINT *pctinfo)
static HRESULT WINAPI	file_GetTypeInfo (IFile *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	file_GetIDsOfNames (IFile *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
static HRESULT WINAPI	file_Invoke (IFile *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
static HRESULT WINAPI	file_get_Path (IFile *iface, BSTR *path)
static HRESULT WINAPI	file_get_Name (IFile *iface, BSTR *name)
static HRESULT WINAPI	file_put_Name (IFile *iface, BSTR pbstrName)
static HRESULT WINAPI	file_get_ShortPath (IFile *iface, BSTR *pbstrPath)
static HRESULT WINAPI	file_get_ShortName (IFile *iface, BSTR *pbstrName)
static HRESULT WINAPI	file_get_Drive (IFile *iface, IDrive **ppdrive)
static HRESULT WINAPI	file_get_ParentFolder (IFile *iface, IFolder **ppfolder)
static HRESULT WINAPI	file_get_Attributes (IFile *iface, FileAttribute *pfa)
static HRESULT WINAPI	file_put_Attributes (IFile *iface, FileAttribute pfa)
static HRESULT	get_date_from_filetime (const FILETIME *ft, DATE *date)
static HRESULT WINAPI	file_get_DateCreated (IFile *iface, DATE *pdate)
static HRESULT WINAPI	file_get_DateLastModified (IFile *iface, DATE *date)
static HRESULT WINAPI	file_get_DateLastAccessed (IFile *iface, DATE *pdate)
static HRESULT WINAPI	file_get_Size (IFile *iface, VARIANT *pvarSize)
static HRESULT WINAPI	file_get_Type (IFile *iface, BSTR *pbstrType)
static HRESULT WINAPI	file_Delete (IFile *iface, VARIANT_BOOL Force)
static HRESULT WINAPI	file_Copy (IFile *iface, BSTR Destination, VARIANT_BOOL OverWriteFiles)
static HRESULT WINAPI	file_Move (IFile *iface, BSTR Destination)
static HRESULT WINAPI	file_OpenAsTextStream (IFile *iface, IOMode mode, Tristate format, ITextStream **stream)
static HRESULT WINAPI	filesys_QueryInterface (IFileSystem3 *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	filesys_AddRef (IFileSystem3 *iface)
static ULONG WINAPI	filesys_Release (IFileSystem3 *iface)
static HRESULT WINAPI	filesys_GetTypeInfoCount (IFileSystem3 *iface, UINT *pctinfo)
static HRESULT WINAPI	filesys_GetTypeInfo (IFileSystem3 *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	filesys_GetIDsOfNames (IFileSystem3 *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
static HRESULT WINAPI	filesys_Invoke (IFileSystem3 *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
static HRESULT WINAPI	filesys_get_Drives (IFileSystem3 *iface, IDriveCollection **ppdrives)
static HRESULT WINAPI	filesys_BuildPath (IFileSystem3 *iface, BSTR Path, BSTR Name, BSTR *Result)
static HRESULT WINAPI	filesys_GetDriveName (IFileSystem3 *iface, BSTR path, BSTR *drive)
static DWORD	get_parent_folder_name (const WCHAR *path, DWORD len)
static HRESULT WINAPI	filesys_GetParentFolderName (IFileSystem3 *iface, BSTR Path, BSTR *pbstrResult)
static HRESULT WINAPI	filesys_GetFileName (IFileSystem3 *iface, BSTR Path, BSTR *pbstrResult)
static HRESULT WINAPI	filesys_GetBaseName (IFileSystem3 *iface, BSTR Path, BSTR *pbstrResult)
static HRESULT WINAPI	filesys_GetExtensionName (IFileSystem3 *iface, BSTR path, BSTR *ext)
static HRESULT WINAPI	filesys_GetAbsolutePathName (IFileSystem3 *iface, BSTR Path, BSTR *pbstrResult)
static HRESULT WINAPI	filesys_GetTempName (IFileSystem3 *iface, BSTR *pbstrResult)
static HRESULT WINAPI	filesys_DriveExists (IFileSystem3 *iface, BSTR DriveSpec, VARIANT_BOOL *pfExists)
static HRESULT WINAPI	filesys_FileExists (IFileSystem3 *iface, BSTR path, VARIANT_BOOL *ret)
static HRESULT WINAPI	filesys_FolderExists (IFileSystem3 *iface, BSTR path, VARIANT_BOOL *ret)
static HRESULT WINAPI	filesys_GetDrive (IFileSystem3 *iface, BSTR DriveSpec, IDrive **ppdrive)
static HRESULT WINAPI	filesys_GetFile (IFileSystem3 *iface, BSTR FilePath, IFile **ppfile)
static HRESULT WINAPI	filesys_GetFolder (IFileSystem3 *iface, BSTR FolderPath, IFolder **folder)
static HRESULT WINAPI	filesys_GetSpecialFolder (IFileSystem3 *iface, SpecialFolderConst SpecialFolder, IFolder **folder)
static HRESULT	delete_file (const WCHAR *file, DWORD file_len, VARIANT_BOOL force)
static HRESULT WINAPI	filesys_DeleteFile (IFileSystem3 *iface, BSTR FileSpec, VARIANT_BOOL Force)
static HRESULT	delete_folder (const WCHAR *folder, DWORD folder_len, VARIANT_BOOL force)
static HRESULT WINAPI	filesys_DeleteFolder (IFileSystem3 *iface, BSTR FolderSpec, VARIANT_BOOL Force)
static HRESULT WINAPI	filesys_MoveFile (IFileSystem3 *iface, BSTR Source, BSTR Destination)
static HRESULT WINAPI	filesys_MoveFolder (IFileSystem3 *iface, BSTR Source, BSTR Destination)
static HRESULT	copy_file (const WCHAR *source, DWORD source_len, const WCHAR *destination, DWORD destination_len, VARIANT_BOOL overwrite)
static HRESULT WINAPI	filesys_CopyFile (IFileSystem3 *iface, BSTR Source, BSTR Destination, VARIANT_BOOL OverWriteFiles)
static HRESULT	copy_folder (const WCHAR *source, DWORD source_len, const WCHAR *destination, DWORD destination_len, VARIANT_BOOL overwrite)
static HRESULT WINAPI	filesys_CopyFolder (IFileSystem3 *iface, BSTR Source, BSTR Destination, VARIANT_BOOL OverWriteFiles)
static HRESULT WINAPI	filesys_CreateFolder (IFileSystem3 *iface, BSTR path, IFolder **folder)
static HRESULT WINAPI	filesys_CreateTextFile (IFileSystem3 *iface, BSTR filename, VARIANT_BOOL overwrite, VARIANT_BOOL unicode, ITextStream **stream)
static HRESULT WINAPI	filesys_OpenTextFile (IFileSystem3 *iface, BSTR filename, IOMode mode, VARIANT_BOOL create, Tristate format, ITextStream **stream)
static HRESULT WINAPI	filesys_GetStandardStream (IFileSystem3 *iface, StandardStreamTypes StandardStreamType, VARIANT_BOOL Unicode, ITextStream **ppts)
static void	get_versionstring (VS_FIXEDFILEINFO *info, WCHAR *ver)
static HRESULT WINAPI	filesys_GetFileVersion (IFileSystem3 *iface, BSTR name, BSTR *version)
HRESULT WINAPI	FileSystem_CreateInstance (IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)

Variables
static const WCHAR	bsW [] = {'\\',0}
static const WCHAR	utf16bom = 0xfeff
static const ITextStreamVtbl	textstreamvtbl
static const IDriveVtbl	drivevtbl
static const IEnumVARIANTVtbl	foldercollenumvariantvtbl
static const IEnumVARIANTVtbl	filecollenumvariantvtbl
static const IEnumVARIANTVtbl	drivecollenumvariantvtbl
static const IFolderCollectionVtbl	foldercollvtbl
static const IFileCollectionVtbl	filecollectionvtbl
static const IDriveCollectionVtbl	drivecollectionvtbl
static const IFolderVtbl	foldervtbl
static const IFileVtbl	file_vtbl
static const struct IFileSystem3Vtbl	filesys_vtbl
static struct filesystem	filesystem

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 19 of file filesystem.c.

Enumeration Type Documentation

iotype

enum iotype

Enumerator
IORead
IOWrite

Definition at line 137 of file filesystem.c.

            {
    IORead,
    IOWrite
};

Function Documentation

copy_file()

static HRESULT copy_file ( const WCHAR *  source, DWORD  source_len, const WCHAR *  destination, DWORD  destination_len, VARIANT_BOOL  overwrite  )

inlinestatic

Definition at line 3640 of file filesystem.c.

{
    DWORD attrs;
    WCHAR src_path[MAX_PATH], dst_path[MAX_PATH];
    DWORD src_len, dst_len, name_len;
    WIN32_FIND_DATAW ffd;
    HANDLE f;
    HRESULT hr;
 
    if(!source[0] || !destination[0])
        return E_INVALIDARG;
 
    attrs = GetFileAttributesW(destination);
    if(attrs==INVALID_FILE_ATTRIBUTES || !(attrs & FILE_ATTRIBUTE_DIRECTORY)) {
        attrs = GetFileAttributesW(source);
        if(attrs == INVALID_FILE_ATTRIBUTES)
            return create_error(GetLastError());
        else if(attrs & FILE_ATTRIBUTE_DIRECTORY)
            return CTL_E_FILENOTFOUND;
 
        if(!CopyFileW(source, destination, !overwrite))
            return create_error(GetLastError());
        return S_OK;
    }
 
    f = FindFirstFileW(source, &ffd);
    if(f == INVALID_HANDLE_VALUE)
        return CTL_E_FILENOTFOUND;
 
    src_len = get_parent_folder_name(source, source_len);
    if(src_len+1 >= MAX_PATH) {
        FindClose(f);
        return E_FAIL;
    }
    if(src_len) {
        memcpy(src_path, source, src_len*sizeof(WCHAR));
        src_path[src_len++] = '\\';
    }
 
    dst_len = destination_len;
    if(dst_len+1 >= MAX_PATH) {
        FindClose(f);
        return E_FAIL;
    }
    memcpy(dst_path, destination, dst_len*sizeof(WCHAR));
    if(dst_path[dst_len-1]!= '\\' && dst_path[dst_len-1]!='/')
        dst_path[dst_len++] = '\\';
 
    hr = CTL_E_FILENOTFOUND;
    do {
        if(ffd.dwFileAttributes & (FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_DEVICE))
            continue;
 
        name_len = lstrlenW(ffd.cFileName);
        if(src_len+name_len+1>=MAX_PATH || dst_len+name_len+1>=MAX_PATH) {
            FindClose(f);
            return E_FAIL;
        }
        memcpy(src_path+src_len, ffd.cFileName, (name_len+1)*sizeof(WCHAR));
        memcpy(dst_path+dst_len, ffd.cFileName, (name_len+1)*sizeof(WCHAR));
 
        TRACE("copying %s to %s\n", debugstr_w(src_path), debugstr_w(dst_path));
 
        if(!CopyFileW(src_path, dst_path, !overwrite)) {
            FindClose(f);
            return create_error(GetLastError());
        }else {
            hr = S_OK;
        }
    } while(FindNextFileW(f, &ffd));
    FindClose(f);
 
    return hr;
}

Referenced by copy_folder(), and filesys_CopyFile().

copy_folder()

static HRESULT copy_folder ( const WCHAR *  source, DWORD  source_len, const WCHAR *  destination, DWORD  destination_len, VARIANT_BOOL  overwrite  )

static

Definition at line 3728 of file filesystem.c.

{
    DWORD tmp, src_len, dst_len, name_len;
    WCHAR src[MAX_PATH], dst[MAX_PATH];
    WIN32_FIND_DATAW ffd;
    HANDLE f;
    HRESULT hr;
    BOOL copied = FALSE;
 
    if(!source[0] || !destination[0])
        return E_INVALIDARG;
 
    dst_len = destination_len;
    if(dst_len+1 >= MAX_PATH)
        return E_FAIL;
    memcpy(dst, destination, (dst_len+1)*sizeof(WCHAR));
 
    if(dst[dst_len-1]!='\\' && dst[dst_len-1]!='/' &&
            (tmp = GetFileAttributesW(source))!=INVALID_FILE_ATTRIBUTES &&
            tmp&FILE_ATTRIBUTE_DIRECTORY) {
        if(!CreateDirectoryW(dst, NULL)) {
            if(overwrite && GetLastError()==ERROR_ALREADY_EXISTS) {
                tmp = GetFileAttributesW(dst);
                if(tmp==INVALID_FILE_ATTRIBUTES || !(tmp&FILE_ATTRIBUTE_DIRECTORY))
                    return CTL_E_FILEALREADYEXISTS;
            }else {
                return create_error(GetLastError());
            }
        }
        copied = TRUE;
 
        src_len = source_len;
        if(src_len+2 >= MAX_PATH)
            return E_FAIL;
        memcpy(src, source, src_len*sizeof(WCHAR));
        src[src_len++] = '\\';
        src[src_len] = '*';
        src[src_len+1] = 0;
 
        hr = copy_file(src, src_len+1, dst, dst_len, overwrite);
        if(FAILED(hr) && hr!=CTL_E_FILENOTFOUND)
            return create_error(GetLastError());
 
        f = FindFirstFileW(src, &ffd);
    }else {
        src_len = get_parent_folder_name(source, source_len);
        if(src_len+2 >= MAX_PATH)
            return E_FAIL;
        memcpy(src, source, src_len*sizeof(WCHAR));
        if(src_len)
            src[src_len++] = '\\';
 
        f = FindFirstFileW(source, &ffd);
    }
    if(f == INVALID_HANDLE_VALUE)
        return CTL_E_PATHNOTFOUND;
 
    dst[dst_len++] = '\\';
    dst[dst_len] = 0;
 
    do {
        if(!(ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
            continue;
        if(ffd.cFileName[0]=='.' && (ffd.cFileName[1]==0 ||
                    (ffd.cFileName[1]=='.' && ffd.cFileName[2]==0)))
            continue;
 
        name_len = lstrlenW(ffd.cFileName);
        if(dst_len+name_len>=MAX_PATH || src_len+name_len+2>=MAX_PATH) {
            FindClose(f);
            return E_FAIL;
        }
        memcpy(dst+dst_len, ffd.cFileName, name_len*sizeof(WCHAR));
        dst[dst_len+name_len] = 0;
        memcpy(src+src_len, ffd.cFileName, name_len*sizeof(WCHAR));
        src[src_len+name_len] = '\\';
        src[src_len+name_len+1] = '*';
        src[src_len+name_len+2] = 0;
 
        TRACE("copying %s to %s\n", debugstr_w(src), debugstr_w(dst));
 
        if(!CreateDirectoryW(dst, NULL)) {
            if(overwrite && GetLastError()==ERROR_ALREADY_EXISTS) {
                tmp = GetFileAttributesW(dst);
                if(tmp==INVALID_FILE_ATTRIBUTES || !(tmp&FILE_ATTRIBUTE_DIRECTORY)) {
                    FindClose(f);
                    return CTL_E_FILEALREADYEXISTS;
                }
            }
 
            FindClose(f);
            return create_error(GetLastError());
        }
        copied = TRUE;
 
        hr = copy_file(src, src_len+name_len+2, dst, dst_len+name_len, overwrite);
        if(FAILED(hr) && hr!=CTL_E_FILENOTFOUND) {
            FindClose(f);
            return hr;
        }
 
        hr = copy_folder(src, src_len+name_len+2, dst, dst_len+name_len, overwrite);
        if(FAILED(hr) && hr!=CTL_E_PATHNOTFOUND) {
            FindClose(f);
            return hr;
        }
    } while(FindNextFileW(f, &ffd));
    FindClose(f);
 
    return copied ? S_OK : CTL_E_PATHNOTFOUND;
}

Referenced by copy_folder(), and filesys_CopyFolder().

create_drive()

static HRESULT create_drive ( WCHAR  letter, IDrive **  drive  )

static

Definition at line 1118 of file filesystem.c.

{
    struct drive *This;
 
    *drive = NULL;
 
    This = heap_alloc(sizeof(*This));
    if (!This) return E_OUTOFMEMORY;
 
    This->IDrive_iface.lpVtbl = &drivevtbl;
    This->ref = 1;
    This->root = SysAllocStringLen(NULL, 3);
    if (!This->root)
    {
        heap_free(This);
        return E_OUTOFMEMORY;
    }
    This->root[0] = letter;
    This->root[1] = ':';
    This->root[2] = '\\';
    This->root[3] = 0;
 
    init_classinfo(&CLSID_Drive, (IUnknown *)&This->IDrive_iface, &This->classinfo);
    *drive = &This->IDrive_iface;
    return S_OK;
}

Referenced by drivecoll_enumvariant_Next(), and filesys_GetDrive().

create_drivecoll()

static HRESULT create_drivecoll ( IDriveCollection **  drives )

static

Definition at line 2165 of file filesystem.c.

{
    struct drivecollection *This;
    DWORD mask;
 
    *drives = NULL;
 
    This = heap_alloc(sizeof(*This));
    if (!This) return E_OUTOFMEMORY;
 
    This->IDriveCollection_iface.lpVtbl = &drivecollectionvtbl;
    This->ref = 1;
    This->drives = mask = GetLogicalDrives();
    /* count set bits */
    for (This->count = 0; mask; This->count++)
        mask &= mask - 1;
 
    init_classinfo(&CLSID_Drives, (IUnknown *)&This->IDriveCollection_iface, &This->classinfo);
    *drives = &This->IDriveCollection_iface;
    return S_OK;
}

Referenced by filesys_get_Drives().

create_drivecoll_enum()

static HRESULT create_drivecoll_enum ( struct drivecollection *  collection, IUnknown **  newenum  )

static

Definition at line 1602 of file filesystem.c.

{
    struct enumvariant *This;
 
    *newenum = NULL;
 
    This = heap_alloc(sizeof(*This));
    if (!This) return E_OUTOFMEMORY;
 
    This->IEnumVARIANT_iface.lpVtbl = &drivecollenumvariantvtbl;
    This->ref = 1;
    This->data.u.drivecoll.coll = collection;
    This->data.u.drivecoll.cur = -1;
    IDriveCollection_AddRef(&collection->IDriveCollection_iface);
 
    *newenum = (IUnknown*)&This->IEnumVARIANT_iface;
 
    return S_OK;
}

Referenced by drivecoll_enumvariant_Clone(), and drivecoll_get__NewEnum().

create_error()

static HRESULT create_error ( DWORD  err )

inlinestatic

Definition at line 187 of file filesystem.c.

{
    switch(err) {
    case ERROR_FILE_NOT_FOUND: return CTL_E_FILENOTFOUND;
    case ERROR_PATH_NOT_FOUND: return CTL_E_PATHNOTFOUND;
    case ERROR_ACCESS_DENIED: return CTL_E_PERMISSIONDENIED;
    case ERROR_FILE_EXISTS: return CTL_E_FILEALREADYEXISTS;
    case ERROR_ALREADY_EXISTS: return CTL_E_FILEALREADYEXISTS;
    default:
        FIXME("Unsupported error code: %d\n", err);
        return E_FAIL;
    }
}

Referenced by copy_file(), copy_folder(), create_file(), create_textstream(), delete_file(), delete_folder(), file_get_Attributes(), file_get_Size(), file_put_Attributes(), textstream_writecrlf(), and textstream_writestr().

create_file()

static HRESULT create_file ( BSTR  path, IFile **  file  )

static

Definition at line 2876 of file filesystem.c.

{
    struct file *f;
    DWORD len, attrs;
 
    *file = NULL;
 
    f = heap_alloc(sizeof(struct file));
    if(!f)
        return E_OUTOFMEMORY;
 
    f->IFile_iface.lpVtbl = &file_vtbl;
    f->ref = 1;
 
    len = GetFullPathNameW(path, 0, NULL, NULL);
    if(!len) {
        heap_free(f);
        return E_FAIL;
    }
 
    f->path = heap_alloc(len*sizeof(WCHAR));
    if(!f->path) {
        heap_free(f);
        return E_OUTOFMEMORY;
    }
 
    if(!GetFullPathNameW(path, len, f->path, NULL)) {
        heap_free(f->path);
        heap_free(f);
        return E_FAIL;
    }
 
    attrs = GetFileAttributesW(f->path);
    if(attrs==INVALID_FILE_ATTRIBUTES ||
            (attrs&(FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_DEVICE))) {
        heap_free(f->path);
        heap_free(f);
        return create_error(GetLastError());
    }
 
    init_classinfo(&CLSID_File, (IUnknown *)&f->IFile_iface, &f->classinfo);
    *file = &f->IFile_iface;
    return S_OK;
}

create_filecoll()

static HRESULT create_filecoll ( BSTR  path, IFileCollection **  files  )

static

Definition at line 1994 of file filesystem.c.

{
    struct filecollection *This;
 
    *files = NULL;
 
    This = heap_alloc(sizeof(*This));
    if (!This) return E_OUTOFMEMORY;
 
    This->IFileCollection_iface.lpVtbl = &filecollectionvtbl;
    This->ref = 1;
    This->path = SysAllocString(path);
    if (!This->path)
    {
        heap_free(This);
        return E_OUTOFMEMORY;
    }
 
    init_classinfo(&CLSID_Files, (IUnknown *)&This->IFileCollection_iface, &This->classinfo);
    *files = &This->IFileCollection_iface;
    return S_OK;
}

Referenced by folder_get_Files().

create_filecoll_enum()

static HRESULT create_filecoll_enum ( struct filecollection *  collection, IUnknown **  newenum  )

static

Definition at line 1479 of file filesystem.c.

{
    struct enumvariant *This;
 
    *newenum = NULL;
 
    This = heap_alloc(sizeof(*This));
    if (!This) return E_OUTOFMEMORY;
 
    This->IEnumVARIANT_iface.lpVtbl = &filecollenumvariantvtbl;
    This->ref = 1;
    This->data.u.filecoll.find = NULL;
    This->data.u.filecoll.coll = collection;
    IFileCollection_AddRef(&collection->IFileCollection_iface);
 
    *newenum = (IUnknown*)&This->IEnumVARIANT_iface;
 
    return S_OK;
}

Referenced by filecoll_enumvariant_Clone(), and filecoll_get__NewEnum().

create_folder()

HRESULT create_folder ( const WCHAR *  path, IFolder **  folder  )

static

Definition at line 2507 of file filesystem.c.

{
    struct folder *This;
 
    *folder = NULL;
 
    TRACE("%s\n", debugstr_w(path));
 
    This = heap_alloc(sizeof(struct folder));
    if (!This) return E_OUTOFMEMORY;
 
    This->IFolder_iface.lpVtbl = &foldervtbl;
    This->ref = 1;
    This->path = SysAllocString(path);
    if (!This->path)
    {
        heap_free(This);
        return E_OUTOFMEMORY;
    }
 
    init_classinfo(&CLSID_Folder, (IUnknown *)&This->IFolder_iface, &This->classinfo);
    *folder = &This->IFolder_iface;
 
    return S_OK;
}

Referenced by filesys_CreateFolder(), filesys_GetFolder(), filesys_GetSpecialFolder(), and foldercoll_enumvariant_Next().

create_foldercoll()

static HRESULT create_foldercoll ( BSTR  path, IFolderCollection **  folders  )

static

Definition at line 1800 of file filesystem.c.

{
    struct foldercollection *This;
 
    *folders = NULL;
 
    This = heap_alloc(sizeof(struct foldercollection));
    if (!This) return E_OUTOFMEMORY;
 
    This->IFolderCollection_iface.lpVtbl = &foldercollvtbl;
    This->ref = 1;
    This->path = SysAllocString(path);
    if (!This->path)
    {
        heap_free(This);
        return E_OUTOFMEMORY;
    }
 
    init_classinfo(&CLSID_Folders, (IUnknown *)&This->IFolderCollection_iface, &This->classinfo);
    *folders = &This->IFolderCollection_iface;
 
    return S_OK;
}

Referenced by folder_get_SubFolders().

create_foldercoll_enum()

static HRESULT create_foldercoll_enum ( struct foldercollection *  collection, IUnknown **  newenum  )

static

Definition at line 1337 of file filesystem.c.

{
    struct enumvariant *This;
 
    *newenum = NULL;
 
    This = heap_alloc(sizeof(*This));
    if (!This) return E_OUTOFMEMORY;
 
    This->IEnumVARIANT_iface.lpVtbl = &foldercollenumvariantvtbl;
    This->ref = 1;
    This->data.u.foldercoll.find = NULL;
    This->data.u.foldercoll.coll = collection;
    IFolderCollection_AddRef(&collection->IFolderCollection_iface);
 
    *newenum = (IUnknown*)&This->IEnumVARIANT_iface;
 
    return S_OK;
}

Referenced by foldercoll_enumvariant_Clone(), and foldercoll_get__NewEnum().

create_textstream()

static HRESULT create_textstream ( const WCHAR *  filename, DWORD  disposition, IOMode  mode, Tristate  format, ITextStream **  ret  )

static

Definition at line 699 of file filesystem.c.

{
    struct textstream *stream;
    DWORD access = 0;
 
    /* map access mode */
    switch (mode)
    {
    case ForReading:
        access = GENERIC_READ;
        break;
    case ForWriting:
        access = GENERIC_WRITE;
        break;
    case ForAppending:
        access = GENERIC_READ | GENERIC_WRITE;
        break;
    default:
        return E_INVALIDARG;
    }
 
    stream = heap_alloc(sizeof(struct textstream));
    if (!stream) return E_OUTOFMEMORY;
 
    stream->ITextStream_iface.lpVtbl = &textstreamvtbl;
    stream->ref = 1;
    stream->mode = mode;
    stream->first_read = TRUE;
 
    stream->file = CreateFileW(filename, access, 0, NULL, disposition, FILE_ATTRIBUTE_NORMAL, NULL);
    if (stream->file == INVALID_HANDLE_VALUE)
    {
        HRESULT hr = create_error(GetLastError());
        heap_free(stream);
        return hr;
    }
 
    if (mode == ForReading)
        GetFileSizeEx(stream->file, &stream->size);
    else
        stream->size.QuadPart = 0;
 
    if (mode == ForWriting)
    {
        stream->unicode = format == TristateTrue;
        /* Write Unicode BOM */
        if (stream->unicode && (disposition == CREATE_ALWAYS || disposition == CREATE_NEW)) {
            DWORD written = 0;
            BOOL ret = WriteFile(stream->file, &utf16bom, sizeof(utf16bom), &written, NULL);
            if (!ret || written != sizeof(utf16bom)) {
                ITextStream_Release(&stream->ITextStream_iface);
                return create_error(GetLastError());
            }
        }
    }
    else
    {
        if (format == TristateUseDefault)
        {
            BYTE buf[64];
            DWORD read;
            BOOL ret;
 
            ret = ReadFile(stream->file, buf, sizeof(buf), &read, NULL);
            if (!ret) {
                ITextStream_Release(&stream->ITextStream_iface);
                return create_error(GetLastError());
            }
 
            stream->unicode = IsTextUnicode(buf, read, NULL);
            if (mode == ForReading) SetFilePointer(stream->file, 0, 0, FILE_BEGIN);
        }
        else stream->unicode = format != TristateFalse;
 
        if (mode == ForAppending) SetFilePointer(stream->file, 0, 0, FILE_END);
    }
 
    init_classinfo(&CLSID_TextStream, (IUnknown *)&stream->ITextStream_iface, &stream->classinfo);
    *ret = &stream->ITextStream_iface;
    return S_OK;
}

Referenced by file_OpenAsTextStream(), filesys_CreateTextFile(), and filesys_OpenTextFile().

delete_file()

static HRESULT delete_file ( const WCHAR *  file, DWORD  file_len, VARIANT_BOOL  force  )

inlinestatic

Definition at line 3491 of file filesystem.c.

{
    WCHAR path[MAX_PATH];
    DWORD len, name_len;
    WIN32_FIND_DATAW ffd;
    HANDLE f;
 
    f = FindFirstFileW(file, &ffd);
    if(f == INVALID_HANDLE_VALUE)
        return create_error(GetLastError());
 
    len = get_parent_folder_name(file, file_len);
    if(len+1 >= MAX_PATH) {
        FindClose(f);
        return E_FAIL;
    }
    if(len) {
        memcpy(path, file, len*sizeof(WCHAR));
        path[len++] = '\\';
    }
 
    do {
        if(ffd.dwFileAttributes & (FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_DEVICE))
            continue;
 
        name_len = lstrlenW(ffd.cFileName);
        if(len+name_len+1 >= MAX_PATH) {
            FindClose(f);
            return E_FAIL;
        }
        memcpy(path+len, ffd.cFileName, (name_len+1)*sizeof(WCHAR));
 
        TRACE("deleting %s\n", debugstr_w(path));
 
        if(!DeleteFileW(path)) {
            if(!force || !SetFileAttributesW(path, FILE_ATTRIBUTE_NORMAL)
                    || !DeleteFileW(path)) {
                FindClose(f);
                return create_error(GetLastError());
            }
        }
    } while(FindNextFileW(f, &ffd));
    FindClose(f);
 
    return S_OK;
}

delete_folder()

static HRESULT delete_folder ( const WCHAR *  folder, DWORD  folder_len, VARIANT_BOOL  force  )

static

Definition at line 3549 of file filesystem.c.

{
    WCHAR path[MAX_PATH];
    DWORD len, name_len;
    WIN32_FIND_DATAW ffd;
    HANDLE f;
    HRESULT hr;
 
    f = FindFirstFileW(folder, &ffd);
    if(f == INVALID_HANDLE_VALUE)
        return create_error(GetLastError());
 
    len = get_parent_folder_name(folder, folder_len);
    if(len+1 >= MAX_PATH) {
        FindClose(f);
        return E_FAIL;
    }
    if(len) {
        memcpy(path, folder, len*sizeof(WCHAR));
        path[len++] = '\\';
    }
 
    do {
        if(!(ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
            continue;
        if(ffd.cFileName[0]=='.' && (ffd.cFileName[1]==0 ||
                    (ffd.cFileName[1]=='.' && ffd.cFileName[2]==0)))
            continue;
 
        name_len = lstrlenW(ffd.cFileName);
        if(len+name_len+3 >= MAX_PATH) {
            FindClose(f);
            return E_FAIL;
        }
        memcpy(path+len, ffd.cFileName, name_len*sizeof(WCHAR));
        path[len+name_len] = '\\';
        path[len+name_len+1] = '*';
        path[len+name_len+2] = 0;
 
        hr = delete_file(path, len+name_len+2, force);
        if(FAILED(hr)) {
            FindClose(f);
            return hr;
        }
 
        hr = delete_folder(path, len+name_len+2, force);
        if(FAILED(hr)) {
            FindClose(f);
            return hr;
        }
 
        path[len+name_len] = 0;
        TRACE("deleting %s\n", debugstr_w(path));
 
        if(!RemoveDirectoryW(path)) {
            FindClose(f);
            return create_error(GetLastError());
        }
    } while(FindNextFileW(f, &ffd));
    FindClose(f);
 
    return S_OK;
}

Referenced by delete_folder(), and filesys_DeleteFolder().

drive_AddRef()

static ULONG WINAPI drive_AddRef ( IDrive *  iface )

static

Definition at line 806 of file filesystem.c.

{
    struct drive *This = impl_from_IDrive(iface);
    ULONG ref = InterlockedIncrement(&This->ref);
    TRACE("(%p)->(%d)\n", This, ref);
    return ref;
}

drive_get_AvailableSpace()

static HRESULT WINAPI drive_get_AvailableSpace ( IDrive *  iface, VARIANT *  v  )

static

Definition at line 974 of file filesystem.c.

{
    struct drive *This = impl_from_IDrive(iface);
    ULARGE_INTEGER avail;
 
    TRACE("(%p)->(%p)\n", This, v);
 
    if (!v)
        return E_POINTER;
 
    if (!GetDiskFreeSpaceExW(This->root, &avail, NULL, NULL))
        return E_FAIL;
 
    return variant_from_largeint(&avail, v);
}

drive_get_DriveLetter()

static HRESULT WINAPI drive_get_DriveLetter ( IDrive *  iface, BSTR *  letter  )

static

Definition at line 895 of file filesystem.c.

{
    struct drive *This = impl_from_IDrive(iface);
 
    TRACE("(%p)->(%p)\n", This, letter);
 
    if (!letter)
        return E_POINTER;
 
    *letter = SysAllocStringLen(This->root, 1);
    if (!*letter)
        return E_OUTOFMEMORY;
 
    return S_OK;
}

drive_get_DriveType()

static HRESULT WINAPI drive_get_DriveType ( IDrive *  iface, DriveTypeConst *  type  )

static

Definition at line 918 of file filesystem.c.

{
    struct drive *This = impl_from_IDrive(iface);
 
    TRACE("(%p)->(%p)\n", This, type);
 
    switch (GetDriveTypeW(This->root))
    {
    case DRIVE_REMOVABLE:
        *type = Removable;
        break;
    case DRIVE_FIXED:
        *type = Fixed;
        break;
    case DRIVE_REMOTE:
        *type = Remote;
        break;
    case DRIVE_CDROM:
        *type = CDRom;
        break;
    case DRIVE_RAMDISK:
        *type = RamDisk;
        break;
    default:
        *type = UnknownType;
        break;
    }
 
    return S_OK;
}

drive_get_FileSystem()

static HRESULT WINAPI drive_get_FileSystem ( IDrive *  iface, BSTR *  fs  )

static

Definition at line 1047 of file filesystem.c.

{
    struct drive *This = impl_from_IDrive(iface);
    WCHAR nameW[MAX_PATH+1];
    BOOL ret;
 
    TRACE("(%p)->(%p)\n", This, fs);
 
    if (!fs)
        return E_POINTER;
 
    *fs = NULL;
    ret = GetVolumeInformationW(This->root, NULL, 0, NULL, NULL, NULL, nameW, ARRAY_SIZE(nameW));
    if (ret)
        *fs = SysAllocString(nameW);
    return ret ? S_OK : E_FAIL;
}

drive_get_FreeSpace()

static HRESULT WINAPI drive_get_FreeSpace ( IDrive *  iface, VARIANT *  v  )

static

Definition at line 990 of file filesystem.c.

{
    struct drive *This = impl_from_IDrive(iface);
    ULARGE_INTEGER freespace;
 
    TRACE("(%p)->(%p)\n", This, v);
 
    if (!v)
        return E_POINTER;
 
    if (!GetDiskFreeSpaceExW(This->root, &freespace, NULL, NULL))
        return E_FAIL;
 
    return variant_from_largeint(&freespace, v);
}

drive_get_IsReady()

static HRESULT WINAPI drive_get_IsReady ( IDrive *  iface, VARIANT_BOOL *  ready  )

static

Definition at line 1079 of file filesystem.c.

{
    struct drive *This = impl_from_IDrive(iface);
    ULARGE_INTEGER freespace;
    BOOL ret;
 
    TRACE("(%p)->(%p)\n", This, ready);
 
    if (!ready)
        return E_POINTER;
 
    ret = GetDiskFreeSpaceExW(This->root, &freespace, NULL, NULL);
    *ready = ret ? VARIANT_TRUE : VARIANT_FALSE;
    return S_OK;
}

drive_get_Path()

static HRESULT WINAPI drive_get_Path ( IDrive *  iface, BSTR *  path  )

static

Definition at line 888 of file filesystem.c.

{
    struct drive *This = impl_from_IDrive(iface);
    FIXME("(%p)->(%p): stub\n", This, path);
    return E_NOTIMPL;
}

drive_get_RootFolder()

static HRESULT WINAPI drive_get_RootFolder ( IDrive *  iface, IFolder **  folder  )

static

Definition at line 949 of file filesystem.c.

{
    struct drive *This = impl_from_IDrive(iface);
    FIXME("(%p)->(%p): stub\n", This, folder);
    return E_NOTIMPL;
}

drive_get_SerialNumber()

static HRESULT WINAPI drive_get_SerialNumber ( IDrive *  iface, LONG *  serial  )

static

Definition at line 1065 of file filesystem.c.

{
    struct drive *This = impl_from_IDrive(iface);
    BOOL ret;
 
    TRACE("(%p)->(%p)\n", This, serial);
 
    if (!serial)
        return E_POINTER;
 
    ret = GetVolumeInformationW(This->root, NULL, 0, (DWORD*)serial, NULL, NULL, NULL, 0);
    return ret ? S_OK : E_FAIL;
}

drive_get_ShareName()

static HRESULT WINAPI drive_get_ShareName ( IDrive *  iface, BSTR *  share_name  )

static

Definition at line 911 of file filesystem.c.

{
    struct drive *This = impl_from_IDrive(iface);
    FIXME("(%p)->(%p): stub\n", This, share_name);
    return E_NOTIMPL;
}

drive_get_TotalSize()

static HRESULT WINAPI drive_get_TotalSize ( IDrive *  iface, VARIANT *  v  )

static

Definition at line 1006 of file filesystem.c.

{
    struct drive *This = impl_from_IDrive(iface);
    ULARGE_INTEGER total;
 
    TRACE("(%p)->(%p)\n", This, v);
 
    if (!v)
        return E_POINTER;
 
    if (!GetDiskFreeSpaceExW(This->root, NULL, &total, NULL))
        return E_FAIL;
 
    return variant_from_largeint(&total, v);
}

drive_get_VolumeName()

static HRESULT WINAPI drive_get_VolumeName ( IDrive *  iface, BSTR *  name  )

static

Definition at line 1022 of file filesystem.c.

{
    struct drive *This = impl_from_IDrive(iface);
    WCHAR nameW[MAX_PATH+1];
    BOOL ret;
 
    TRACE("(%p)->(%p)\n", This, name);
 
    if (!name)
        return E_POINTER;
 
    *name = NULL;
    ret = GetVolumeInformationW(This->root, nameW, ARRAY_SIZE(nameW), NULL, NULL, NULL, NULL, 0);
    if (ret)
        *name = SysAllocString(nameW);
    return ret ? S_OK : E_FAIL;
}

drive_GetIDsOfNames()

static HRESULT WINAPI drive_GetIDsOfNames ( IDrive *  iface, REFIID  riid, LPOLESTR *  rgszNames, UINT  cNames, LCID  lcid, DISPID *  rgDispId  )

static

Definition at line 845 of file filesystem.c.

{
    struct drive *This = impl_from_IDrive(iface);
    ITypeInfo *typeinfo;
    HRESULT hr;
 
    TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 
    hr = get_typeinfo(IDrive_tid, &typeinfo);
    if(SUCCEEDED(hr))
    {
        hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
        ITypeInfo_Release(typeinfo);
    }
 
    return hr;
}

drive_GetTypeInfo()

static HRESULT WINAPI drive_GetTypeInfo ( IDrive *  iface, UINT  iTInfo, LCID  lcid, ITypeInfo **  ppTInfo  )

static

Definition at line 837 of file filesystem.c.

{
    struct drive *This = impl_from_IDrive(iface);
    TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
    return get_typeinfo(IDrive_tid, ppTInfo);
}

drive_GetTypeInfoCount()

static HRESULT WINAPI drive_GetTypeInfoCount ( IDrive *  iface, UINT *  pctinfo  )

static

Definition at line 829 of file filesystem.c.

{
    struct drive *This = impl_from_IDrive(iface);
    TRACE("(%p)->(%p)\n", This, pctinfo);
    *pctinfo = 1;
    return S_OK;
}

drive_Invoke()

static HRESULT WINAPI drive_Invoke ( IDrive *  iface, DISPID  dispIdMember, REFIID  riid, LCID  lcid, WORD  wFlags, DISPPARAMS *  pDispParams, VARIANT *  pVarResult, EXCEPINFO *  pExcepInfo, UINT *  puArgErr  )

static

Definition at line 865 of file filesystem.c.

{
    struct drive *This = impl_from_IDrive(iface);
    ITypeInfo *typeinfo;
    HRESULT hr;
 
    TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 
    hr = get_typeinfo(IDrive_tid, &typeinfo);
    if(SUCCEEDED(hr))
    {
        hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
                pDispParams, pVarResult, pExcepInfo, puArgErr);
        ITypeInfo_Release(typeinfo);
    }
 
    return hr;
}

drive_put_VolumeName()

static HRESULT WINAPI drive_put_VolumeName ( IDrive *  iface, BSTR  name  )

static

Definition at line 1040 of file filesystem.c.

{
    struct drive *This = impl_from_IDrive(iface);
    FIXME("(%p)->(%s): stub\n", This, debugstr_w(name));
    return E_NOTIMPL;
}

drive_QueryInterface()

static HRESULT WINAPI drive_QueryInterface ( IDrive *  iface, REFIID  riid, void **  obj  )

static

Definition at line 781 of file filesystem.c.

{
    struct drive *This = impl_from_IDrive(iface);
 
    TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
 
    *obj = NULL;
 
    if (IsEqualIID( riid, &IID_IDrive ) ||
        IsEqualIID( riid, &IID_IDispatch ) ||
        IsEqualIID( riid, &IID_IUnknown))
    {
        *obj = &This->IDrive_iface;
    }
    else if (IsEqualIID( riid, &IID_IProvideClassInfo ))
    {
        *obj = &This->classinfo.IProvideClassInfo_iface;
    }
    else
        return E_NOINTERFACE;
 
    IUnknown_AddRef((IUnknown*)*obj);
    return S_OK;
}

drive_Release()

static ULONG WINAPI drive_Release ( IDrive *  iface )

static

Definition at line 814 of file filesystem.c.

{
    struct drive *This = impl_from_IDrive(iface);
    ULONG ref = InterlockedDecrement(&This->ref);
    TRACE("(%p)->(%d)\n", This, ref);
 
    if (!ref)
    {
        SysFreeString(This->root);
        heap_free(This);
    }
 
    return ref;
}

drivecoll_AddRef()

static ULONG WINAPI drivecoll_AddRef ( IDriveCollection *  iface )

static

Definition at line 2042 of file filesystem.c.

{
    struct drivecollection *This = impl_from_IDriveCollection(iface);
    ULONG ref = InterlockedIncrement(&This->ref);
    TRACE("(%p)->(%d)\n", This, ref);
    return ref;
}

drivecoll_enumvariant_Clone()

static HRESULT WINAPI drivecoll_enumvariant_Clone ( IEnumVARIANT *  iface, IEnumVARIANT **  pclone  )

static

Definition at line 1585 of file filesystem.c.

{
    struct enumvariant *This = impl_from_IEnumVARIANT(iface);
    TRACE("(%p)->(%p)\n", This, pclone);
    return create_drivecoll_enum(This->data.u.drivecoll.coll, (IUnknown**)pclone);
}

drivecoll_enumvariant_Next()

static HRESULT WINAPI drivecoll_enumvariant_Next ( IEnumVARIANT *  iface, ULONG  celt, VARIANT *  var, ULONG *  fetched  )

static

Definition at line 1529 of file filesystem.c.

{
    struct enumvariant *This = impl_from_IEnumVARIANT(iface);
    ULONG count = 0;
 
    TRACE("(%p)->(%d %p %p)\n", This, celt, var, fetched);
 
    if (fetched)
        *fetched = 0;
 
    if (!celt) return S_OK;
 
    while (find_next_drive(This) == S_OK)
    {
        IDrive *drive;
        HRESULT hr;
 
        hr = create_drive('A' + This->data.u.drivecoll.cur, &drive);
        if (FAILED(hr)) return hr;
 
        V_VT(&var[count]) = VT_DISPATCH;
        V_DISPATCH(&var[count]) = (IDispatch*)drive;
 
        if (++count >= celt) break;
    }
 
    if (fetched)
        *fetched = count;
 
    return (count < celt) ? S_FALSE : S_OK;
}

drivecoll_enumvariant_Release()

static ULONG WINAPI drivecoll_enumvariant_Release ( IEnumVARIANT *  iface )

static

Definition at line 1499 of file filesystem.c.

{
    struct enumvariant *This = impl_from_IEnumVARIANT(iface);
    ULONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("(%p)->(%d)\n", This, ref);
 
    if (!ref)
    {
        IDriveCollection_Release(&This->data.u.drivecoll.coll->IDriveCollection_iface);
        heap_free(This);
    }
 
    return ref;
}

drivecoll_enumvariant_Reset()

static HRESULT WINAPI drivecoll_enumvariant_Reset ( IEnumVARIANT *  iface )

static

Definition at line 1575 of file filesystem.c.

{
    struct enumvariant *This = impl_from_IEnumVARIANT(iface);
 
    TRACE("(%p)\n", This);
 
    This->data.u.drivecoll.cur = -1;
    return S_OK;
}

drivecoll_enumvariant_Skip()

static HRESULT WINAPI drivecoll_enumvariant_Skip ( IEnumVARIANT *  iface, ULONG  celt  )

static

Definition at line 1561 of file filesystem.c.

{
    struct enumvariant *This = impl_from_IEnumVARIANT(iface);
 
    TRACE("(%p)->(%d)\n", This, celt);
 
    if (!celt) return S_OK;
 
    while (celt && find_next_drive(This) == S_OK)
        celt--;
 
    return celt ? S_FALSE : S_OK;
}

drivecoll_get__NewEnum()

static HRESULT WINAPI drivecoll_get__NewEnum ( IDriveCollection *  iface, IUnknown **  ppenum  )

static

Definition at line 2128 of file filesystem.c.

{
    struct drivecollection *This = impl_from_IDriveCollection(iface);
 
    TRACE("(%p)->(%p)\n", This, ppenum);
 
    if(!ppenum)
        return E_POINTER;
 
    return create_drivecoll_enum(This, ppenum);
}

drivecoll_get_Count()

static HRESULT WINAPI drivecoll_get_Count ( IDriveCollection *  iface, LONG *  count  )

static

Definition at line 2140 of file filesystem.c.

{
    struct drivecollection *This = impl_from_IDriveCollection(iface);
 
    TRACE("(%p)->(%p)\n", This, count);
 
    if (!count) return E_POINTER;
 
    *count = This->count;
    return S_OK;
}

drivecoll_get_Item()

static HRESULT WINAPI drivecoll_get_Item ( IDriveCollection *  iface, VARIANT  key, IDrive **  drive  )

static

Definition at line 2121 of file filesystem.c.

{
    struct drivecollection *This = impl_from_IDriveCollection(iface);
    FIXME("(%p)->(%p): stub\n", This, drive);
    return E_NOTIMPL;
}

drivecoll_GetIDsOfNames()

static HRESULT WINAPI drivecoll_GetIDsOfNames ( IDriveCollection *  iface, REFIID  riid, LPOLESTR *  rgszNames, UINT  cNames, LCID  lcid, DISPID *  rgDispId  )

static

Definition at line 2078 of file filesystem.c.

{
    struct drivecollection *This = impl_from_IDriveCollection(iface);
    ITypeInfo *typeinfo;
    HRESULT hr;
 
    TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 
    hr = get_typeinfo(IDriveCollection_tid, &typeinfo);
    if(SUCCEEDED(hr))
    {
        hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
        ITypeInfo_Release(typeinfo);
    }
 
    return hr;
}

drivecoll_GetTypeInfo()

static HRESULT WINAPI drivecoll_GetTypeInfo ( IDriveCollection *  iface, UINT  iTInfo, LCID  lcid, ITypeInfo **  ppTInfo  )

static

Definition at line 2070 of file filesystem.c.

{
    struct drivecollection *This = impl_from_IDriveCollection(iface);
    TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
    return get_typeinfo(IDriveCollection_tid, ppTInfo);
}

drivecoll_GetTypeInfoCount()

static HRESULT WINAPI drivecoll_GetTypeInfoCount ( IDriveCollection *  iface, UINT *  pctinfo  )

static

Definition at line 2062 of file filesystem.c.

{
    struct drivecollection *This = impl_from_IDriveCollection(iface);
    TRACE("(%p)->(%p)\n", This, pctinfo);
    *pctinfo = 1;
    return S_OK;
}

drivecoll_Invoke()

static HRESULT WINAPI drivecoll_Invoke ( IDriveCollection *  iface, DISPID  dispIdMember, REFIID  riid, LCID  lcid, WORD  wFlags, DISPPARAMS *  pDispParams, VARIANT *  pVarResult, EXCEPINFO *  pExcepInfo, UINT *  puArgErr  )

static

Definition at line 2098 of file filesystem.c.

{
    struct drivecollection *This = impl_from_IDriveCollection(iface);
    ITypeInfo *typeinfo;
    HRESULT hr;
 
    TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 
    hr = get_typeinfo(IDriveCollection_tid, &typeinfo);
    if(SUCCEEDED(hr))
    {
        hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
                pDispParams, pVarResult, pExcepInfo, puArgErr);
        ITypeInfo_Release(typeinfo);
    }
 
    return hr;
}

drivecoll_QueryInterface()

static HRESULT WINAPI drivecoll_QueryInterface ( IDriveCollection *  iface, REFIID  riid, void **  obj  )

static

Definition at line 2017 of file filesystem.c.

{
    struct drivecollection *This = impl_from_IDriveCollection(iface);
 
    TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
 
    *obj = NULL;
 
    if (IsEqualIID( riid, &IID_IDriveCollection ) ||
        IsEqualIID( riid, &IID_IDispatch ) ||
        IsEqualIID( riid, &IID_IUnknown ))
    {
        *obj = &This->IDriveCollection_iface;
    }
    else if (IsEqualIID( riid, &IID_IProvideClassInfo ))
    {
        *obj = &This->classinfo.IProvideClassInfo_iface;
    }
    else
        return E_NOINTERFACE;
 
    IUnknown_AddRef((IUnknown*)*obj);
    return S_OK;
}

drivecoll_Release()

static ULONG WINAPI drivecoll_Release ( IDriveCollection *  iface )

static

Definition at line 2050 of file filesystem.c.

{
    struct drivecollection *This = impl_from_IDriveCollection(iface);
    ULONG ref = InterlockedDecrement(&This->ref);
    TRACE("(%p)->(%d)\n", This, ref);
 
    if (!ref)
        heap_free(This);
 
    return ref;
}

enumvariant_AddRef()

static ULONG WINAPI enumvariant_AddRef ( IEnumVARIANT *  iface )

static

Definition at line 1165 of file filesystem.c.

{
    struct enumvariant *This = impl_from_IEnumVARIANT(iface);
    ULONG ref = InterlockedIncrement(&This->ref);
    TRACE("(%p)->(%d)\n", This, ref);
    return ref;
}

enumvariant_QueryInterface()

static HRESULT WINAPI enumvariant_QueryInterface ( IEnumVARIANT *  iface, REFIID  riid, void **  obj  )

static

Definition at line 1145 of file filesystem.c.

{
    struct enumvariant *This = impl_from_IEnumVARIANT(iface);
 
    TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
 
    *obj = NULL;
 
    if (IsEqualIID( riid, &IID_IEnumVARIANT ) ||
        IsEqualIID( riid, &IID_IUnknown ))
    {
        *obj = iface;
        IEnumVARIANT_AddRef(iface);
    }
    else
        return E_NOINTERFACE;
 
    return S_OK;
}

file_AddRef()

static ULONG WINAPI file_AddRef ( IFile *  iface )

static

Definition at line 2558 of file filesystem.c.

{
    struct file *This = impl_from_IFile(iface);
    LONG ref = InterlockedIncrement(&This->ref);
 
    TRACE("(%p) ref=%d\n", This, ref);
 
    return ref;
}

file_Copy()

static HRESULT WINAPI file_Copy ( IFile *  iface, BSTR  Destination, VARIANT_BOOL  OverWriteFiles  )

static

Definition at line 2825 of file filesystem.c.

{
    struct file *This = impl_from_IFile(iface);
    FIXME("(%p)->(%s %x)\n", This, debugstr_w(Destination), OverWriteFiles);
    return E_NOTIMPL;
}

file_Delete()

static HRESULT WINAPI file_Delete ( IFile *  iface, VARIANT_BOOL  Force  )

static

Definition at line 2818 of file filesystem.c.

{
    struct file *This = impl_from_IFile(iface);
    FIXME("(%p)->(%x)\n", This, Force);
    return E_NOTIMPL;
}

file_get_Attributes()

static HRESULT WINAPI file_get_Attributes ( IFile *  iface, FileAttribute *  pfa  )

static

Definition at line 2717 of file filesystem.c.

{
    struct file *This = impl_from_IFile(iface);
    DWORD fa;
 
    TRACE("(%p)->(%p)\n", This, pfa);
 
    if(!pfa)
        return E_POINTER;
 
    fa = GetFileAttributesW(This->path);
    if(fa == INVALID_FILE_ATTRIBUTES)
        return create_error(GetLastError());
 
    *pfa = fa & (FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN |
            FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_ARCHIVE |
            FILE_ATTRIBUTE_REPARSE_POINT | FILE_ATTRIBUTE_COMPRESSED);
    return S_OK;
}

file_get_DateCreated()

static HRESULT WINAPI file_get_DateCreated ( IFile *  iface, DATE *  pdate  )

static

Definition at line 2761 of file filesystem.c.

{
    struct file *This = impl_from_IFile(iface);
    FIXME("(%p)->(%p)\n", This, pdate);
    return E_NOTIMPL;
}

file_get_DateLastAccessed()

static HRESULT WINAPI file_get_DateLastAccessed ( IFile *  iface, DATE *  pdate  )

static

Definition at line 2781 of file filesystem.c.

{
    struct file *This = impl_from_IFile(iface);
    FIXME("(%p)->(%p)\n", This, pdate);
    return E_NOTIMPL;
}

file_get_DateLastModified()

static HRESULT WINAPI file_get_DateLastModified ( IFile *  iface, DATE *  date  )

static

Definition at line 2768 of file filesystem.c.

{
    struct file *This = impl_from_IFile(iface);
    WIN32_FILE_ATTRIBUTE_DATA attrs;
 
    TRACE("(%p)->(%p)\n", This, date);
 
    if (GetFileAttributesExW(This->path, GetFileExInfoStandard, &attrs))
        return get_date_from_filetime(&attrs.ftLastWriteTime, date);
 
    return E_FAIL;
}

file_get_Drive()

static HRESULT WINAPI file_get_Drive ( IFile *  iface, IDrive **  ppdrive  )

static

Definition at line 2703 of file filesystem.c.

{
    struct file *This = impl_from_IFile(iface);
    FIXME("(%p)->(%p)\n", This, ppdrive);
    return E_NOTIMPL;
}

file_get_Name()

static HRESULT WINAPI file_get_Name ( IFile *  iface, BSTR *  name  )

static

Definition at line 2657 of file filesystem.c.

{
    struct file *This = impl_from_IFile(iface);
    WCHAR *ptr;
 
    TRACE("(%p)->(%p)\n", This, name);
 
    if(!name)
        return E_POINTER;
 
    *name = NULL;
 
    ptr = wcsrchr(This->path, '\\');
    if (ptr)
    {
        *name = SysAllocString(ptr+1);
        TRACE("%s\n", debugstr_w(*name));
        if (!*name) return E_OUTOFMEMORY;
    }
    else
        return E_FAIL;
 
    return S_OK;
}

file_get_ParentFolder()

static HRESULT WINAPI file_get_ParentFolder ( IFile *  iface, IFolder **  ppfolder  )

static

Definition at line 2710 of file filesystem.c.

{
    struct file *This = impl_from_IFile(iface);
    FIXME("(%p)->(%p)\n", This, ppfolder);
    return E_NOTIMPL;
}

file_get_Path()

static HRESULT WINAPI file_get_Path ( IFile *  iface, BSTR *  path  )

static

Definition at line 2641 of file filesystem.c.

{
    struct file *This = impl_from_IFile(iface);
 
    TRACE("(%p)->(%p)\n", This, path);
 
    if (!path)
        return E_POINTER;
 
    *path = SysAllocString(This->path);
    if (!*path)
        return E_OUTOFMEMORY;
 
    return S_OK;
}

file_get_ShortName()

static HRESULT WINAPI file_get_ShortName ( IFile *  iface, BSTR *  pbstrName  )

static

Definition at line 2696 of file filesystem.c.

{
    struct file *This = impl_from_IFile(iface);
    FIXME("(%p)->(%p)\n", This, pbstrName);
    return E_NOTIMPL;
}

file_get_ShortPath()

static HRESULT WINAPI file_get_ShortPath ( IFile *  iface, BSTR *  pbstrPath  )

static

Definition at line 2689 of file filesystem.c.

{
    struct file *This = impl_from_IFile(iface);
    FIXME("(%p)->(%p)\n", This, pbstrPath);
    return E_NOTIMPL;
}

file_get_Size()

static HRESULT WINAPI file_get_Size ( IFile *  iface, VARIANT *  pvarSize  )

static

Definition at line 2788 of file filesystem.c.

{
    struct file *This = impl_from_IFile(iface);
    ULARGE_INTEGER size;
    WIN32_FIND_DATAW fd;
    HANDLE f;
 
    TRACE("(%p)->(%p)\n", This, pvarSize);
 
    if(!pvarSize)
        return E_POINTER;
 
    f = FindFirstFileW(This->path, &fd);
    if(f == INVALID_HANDLE_VALUE)
        return create_error(GetLastError());
    FindClose(f);
 
    size.u.LowPart = fd.nFileSizeLow;
    size.u.HighPart = fd.nFileSizeHigh;
 
    return variant_from_largeint(&size, pvarSize);
}

file_get_Type()

static HRESULT WINAPI file_get_Type ( IFile *  iface, BSTR *  pbstrType  )

static

Definition at line 2811 of file filesystem.c.

{
    struct file *This = impl_from_IFile(iface);
    FIXME("(%p)->(%p)\n", This, pbstrType);
    return E_NOTIMPL;
}

file_GetIDsOfNames()

static HRESULT WINAPI file_GetIDsOfNames ( IFile *  iface, REFIID  riid, LPOLESTR *  rgszNames, UINT  cNames, LCID  lcid, DISPID *  rgDispId  )

static

Definition at line 2604 of file filesystem.c.

{
    struct file *This = impl_from_IFile(iface);
    ITypeInfo *typeinfo;
    HRESULT hr;
 
    TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid),
            rgszNames, cNames, lcid, rgDispId);
 
    hr = get_typeinfo(IFile_tid, &typeinfo);
    if(SUCCEEDED(hr)) {
        hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
        ITypeInfo_Release(typeinfo);
    }
    return hr;
}

file_GetTypeInfo()

static HRESULT WINAPI file_GetTypeInfo ( IFile *  iface, UINT  iTInfo, LCID  lcid, ITypeInfo **  ppTInfo  )

static

Definition at line 2594 of file filesystem.c.

{
    struct file *This = impl_from_IFile(iface);
 
    TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 
    return get_typeinfo(IFile_tid, ppTInfo);
}

file_GetTypeInfoCount()

static HRESULT WINAPI file_GetTypeInfoCount ( IFile *  iface, UINT *  pctinfo  )

static

Definition at line 2584 of file filesystem.c.

{
    struct file *This = impl_from_IFile(iface);
 
    TRACE("(%p)->(%p)\n", This, pctinfo);
 
    *pctinfo = 1;
    return S_OK;
}

file_Invoke()

static HRESULT WINAPI file_Invoke ( IFile *  iface, DISPID  dispIdMember, REFIID  riid, LCID  lcid, WORD  wFlags, DISPPARAMS *  pDispParams, VARIANT *  pVarResult, EXCEPINFO *  pExcepInfo, UINT *  puArgErr  )

static

Definition at line 2622 of file filesystem.c.

{
    struct file *This = impl_from_IFile(iface);
    ITypeInfo *typeinfo;
    HRESULT hr;
 
    TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
            lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 
    hr = get_typeinfo(IFile_tid, &typeinfo);
    if(SUCCEEDED(hr))
    {
        hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
                pDispParams, pVarResult, pExcepInfo, puArgErr);
        ITypeInfo_Release(typeinfo);
    }
    return hr;
}

file_Move()

static HRESULT WINAPI file_Move ( IFile *  iface, BSTR  Destination  )

static

Definition at line 2832 of file filesystem.c.

{
    struct file *This = impl_from_IFile(iface);
    FIXME("(%p)->(%s)\n", This, debugstr_w(Destination));
    return E_NOTIMPL;
}

file_OpenAsTextStream()

static HRESULT WINAPI file_OpenAsTextStream ( IFile *  iface, IOMode  mode, Tristate  format, ITextStream **  stream  )

static

Definition at line 2839 of file filesystem.c.

{
    struct file *This = impl_from_IFile(iface);
 
    TRACE("(%p)->(%d %d %p)\n", This, mode, format, stream);
 
    return create_textstream(This->path, OPEN_EXISTING, mode, format, stream);
}

file_put_Attributes()

static HRESULT WINAPI file_put_Attributes ( IFile *  iface, FileAttribute  pfa  )

static

Definition at line 2737 of file filesystem.c.

{
    struct file *This = impl_from_IFile(iface);
 
    TRACE("(%p)->(%x)\n", This, pfa);
 
    return SetFileAttributesW(This->path, pfa) ? S_OK : create_error(GetLastError());
}

file_put_Name()

static HRESULT WINAPI file_put_Name ( IFile *  iface, BSTR  pbstrName  )

static

Definition at line 2682 of file filesystem.c.

{
    struct file *This = impl_from_IFile(iface);
    FIXME("(%p)->(%s)\n", This, debugstr_w(pbstrName));
    return E_NOTIMPL;
}

file_QueryInterface()

static HRESULT WINAPI file_QueryInterface ( IFile *  iface, REFIID  riid, void **  obj  )

static

Definition at line 2533 of file filesystem.c.

{
    struct file *This = impl_from_IFile(iface);
 
    TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
 
    *obj = NULL;
 
    if (IsEqualIID(riid, &IID_IFile) ||
            IsEqualIID(riid, &IID_IDispatch) ||
            IsEqualIID(riid, &IID_IUnknown))
    {
        *obj = &This->IFile_iface;
    }
    else if (IsEqualIID( riid, &IID_IProvideClassInfo ))
    {
        *obj = &This->classinfo.IProvideClassInfo_iface;
    }
    else
        return E_NOINTERFACE;
 
    IUnknown_AddRef((IUnknown*)*obj);
    return S_OK;
}

file_Release()

static ULONG WINAPI file_Release ( IFile *  iface )

static

Definition at line 2568 of file filesystem.c.

{
    struct file *This = impl_from_IFile(iface);
    LONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("(%p) ref=%d\n", This, ref);
 
    if(!ref)
    {
        heap_free(This->path);
        heap_free(This);
    }
 
    return ref;
}

filecoll_AddRef()

static ULONG WINAPI filecoll_AddRef ( IFileCollection *  iface )

static

Definition at line 1849 of file filesystem.c.

{
    struct filecollection *This = impl_from_IFileCollection(iface);
    ULONG ref = InterlockedIncrement(&This->ref);
    TRACE("(%p)->(%d)\n", This, ref);
    return ref;
}

filecoll_enumvariant_Clone()

static HRESULT WINAPI filecoll_enumvariant_Clone ( IEnumVARIANT *  iface, IEnumVARIANT **  pclone  )

static

Definition at line 1462 of file filesystem.c.

{
    struct enumvariant *This = impl_from_IEnumVARIANT(iface);
    TRACE("(%p)->(%p)\n", This, pclone);
    return create_filecoll_enum(This->data.u.filecoll.coll, (IUnknown**)pclone);
}

filecoll_enumvariant_Next()

static HRESULT WINAPI filecoll_enumvariant_Next ( IEnumVARIANT *  iface, ULONG  celt, VARIANT *  var, ULONG *  fetched  )

static

Definition at line 1374 of file filesystem.c.

{
    struct enumvariant *This = impl_from_IEnumVARIANT(iface);
    HANDLE handle = This->data.u.filecoll.find;
    WIN32_FIND_DATAW data;
    ULONG count = 0;
 
    TRACE("(%p)->(%d %p %p)\n", This, celt, var, fetched);
 
    if (fetched)
        *fetched = 0;
 
    if (!celt) return S_OK;
 
    if (!handle)
    {
        handle = start_enumeration(This->data.u.filecoll.coll->path, &data, TRUE);
        if (!handle) return S_FALSE;
        This->data.u.filecoll.find = handle;
    }
    else if (!FindNextFileW(handle, &data))
        return S_FALSE;
 
    do
    {
        if (is_file_data(&data))
        {
            IFile *file;
            HRESULT hr;
            BSTR str;
 
            str = get_full_path(This->data.u.filecoll.coll->path, &data);
            hr = create_file(str, &file);
            SysFreeString(str);
            if (FAILED(hr)) return hr;
 
            V_VT(&var[count]) = VT_DISPATCH;
            V_DISPATCH(&var[count]) = (IDispatch*)file;
            if (++count >= celt) break;
        }
    } while (FindNextFileW(handle, &data));
 
    if (fetched)
        *fetched = count;
 
    return (count < celt) ? S_FALSE : S_OK;
}

filecoll_enumvariant_Release()

static ULONG WINAPI filecoll_enumvariant_Release ( IEnumVARIANT *  iface )

static

Definition at line 1357 of file filesystem.c.

{
    struct enumvariant *This = impl_from_IEnumVARIANT(iface);
    ULONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("(%p)->(%d)\n", This, ref);
 
    if (!ref)
    {
        IFileCollection_Release(&This->data.u.filecoll.coll->IFileCollection_iface);
        FindClose(This->data.u.filecoll.find);
        heap_free(This);
    }
 
    return ref;
}

filecoll_enumvariant_Reset()

static HRESULT WINAPI filecoll_enumvariant_Reset ( IEnumVARIANT *  iface )

static

Definition at line 1450 of file filesystem.c.

{
    struct enumvariant *This = impl_from_IEnumVARIANT(iface);
 
    TRACE("(%p)\n", This);
 
    FindClose(This->data.u.filecoll.find);
    This->data.u.filecoll.find = NULL;
 
    return S_OK;
}

filecoll_enumvariant_Skip()

static HRESULT WINAPI filecoll_enumvariant_Skip ( IEnumVARIANT *  iface, ULONG  celt  )

static

Definition at line 1422 of file filesystem.c.

{
    struct enumvariant *This = impl_from_IEnumVARIANT(iface);
    HANDLE handle = This->data.u.filecoll.find;
    WIN32_FIND_DATAW data;
 
    TRACE("(%p)->(%d)\n", This, celt);
 
    if (!celt) return S_OK;
 
    if (!handle)
    {
        handle = start_enumeration(This->data.u.filecoll.coll->path, &data, TRUE);
        if (!handle) return S_FALSE;
        This->data.u.filecoll.find = handle;
    }
    else if (!FindNextFileW(handle, &data))
        return S_FALSE;
 
    do
    {
        if (is_file_data(&data))
            --celt;
    } while (celt && FindNextFileW(handle, &data));
 
    return celt ? S_FALSE : S_OK;
}

filecoll_get__NewEnum()

static HRESULT WINAPI filecoll_get__NewEnum ( IFileCollection *  iface, IUnknown **  ppenum  )

static

Definition at line 1938 of file filesystem.c.

{
    struct filecollection *This = impl_from_IFileCollection(iface);
 
    TRACE("(%p)->(%p)\n", This, ppenum);
 
    if(!ppenum)
        return E_POINTER;
 
    return create_filecoll_enum(This, ppenum);
}

filecoll_get_Count()

static HRESULT WINAPI filecoll_get_Count ( IFileCollection *  iface, LONG *  count  )

static

Definition at line 1950 of file filesystem.c.

{
    struct filecollection *This = impl_from_IFileCollection(iface);
    static const WCHAR allW[] = {'\\','*',0};
    WIN32_FIND_DATAW data;
    WCHAR pathW[MAX_PATH];
    HANDLE handle;
 
    TRACE("(%p)->(%p)\n", This, count);
 
    if(!count)
        return E_POINTER;
 
    *count = 0;
 
    lstrcpyW(pathW, This->path);
    lstrcatW(pathW, allW);
    handle = FindFirstFileW(pathW, &data);
    if (handle == INVALID_HANDLE_VALUE)
        return HRESULT_FROM_WIN32(GetLastError());
 
    do
    {
        if (is_file_data(&data))
            *count += 1;
    } while (FindNextFileW(handle, &data));
    FindClose(handle);
 
    return S_OK;
}

filecoll_get_Item()

static HRESULT WINAPI filecoll_get_Item ( IFileCollection *  iface, VARIANT  Key, IFile **  file  )

static

Definition at line 1931 of file filesystem.c.

{
    struct filecollection *This = impl_from_IFileCollection(iface);
    FIXME("(%p)->(%p)\n", This, file);
    return E_NOTIMPL;
}

filecoll_GetIDsOfNames()

static HRESULT WINAPI filecoll_GetIDsOfNames ( IFileCollection *  iface, REFIID  riid, LPOLESTR *  rgszNames, UINT  cNames, LCID  lcid, DISPID *  rgDispId  )

static

Definition at line 1888 of file filesystem.c.

{
    struct filecollection *This = impl_from_IFileCollection(iface);
    ITypeInfo *typeinfo;
    HRESULT hr;
 
    TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 
    hr = get_typeinfo(IFileCollection_tid, &typeinfo);
    if(SUCCEEDED(hr))
    {
        hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
        ITypeInfo_Release(typeinfo);
    }
 
    return hr;
}

filecoll_GetTypeInfo()

static HRESULT WINAPI filecoll_GetTypeInfo ( IFileCollection *  iface, UINT  iTInfo, LCID  lcid, ITypeInfo **  ppTInfo  )

static

Definition at line 1880 of file filesystem.c.

{
    struct filecollection *This = impl_from_IFileCollection(iface);
    TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
    return get_typeinfo(IFileCollection_tid, ppTInfo);
}

filecoll_GetTypeInfoCount()

static HRESULT WINAPI filecoll_GetTypeInfoCount ( IFileCollection *  iface, UINT *  pctinfo  )

static

Definition at line 1872 of file filesystem.c.

{
    struct filecollection *This = impl_from_IFileCollection(iface);
    TRACE("(%p)->(%p)\n", This, pctinfo);
    *pctinfo = 1;
    return S_OK;
}

filecoll_Invoke()

static HRESULT WINAPI filecoll_Invoke ( IFileCollection *  iface, DISPID  dispIdMember, REFIID  riid, LCID  lcid, WORD  wFlags, DISPPARAMS *  pDispParams, VARIANT *  pVarResult, EXCEPINFO *  pExcepInfo, UINT *  puArgErr  )

static

Definition at line 1908 of file filesystem.c.

{
    struct filecollection *This = impl_from_IFileCollection(iface);
    ITypeInfo *typeinfo;
    HRESULT hr;
 
    TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 
    hr = get_typeinfo(IFileCollection_tid, &typeinfo);
    if(SUCCEEDED(hr))
    {
        hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
                pDispParams, pVarResult, pExcepInfo, puArgErr);
        ITypeInfo_Release(typeinfo);
    }
 
    return hr;
}

filecoll_QueryInterface()

static HRESULT WINAPI filecoll_QueryInterface ( IFileCollection *  iface, REFIID  riid, void **  obj  )

static

Definition at line 1824 of file filesystem.c.

{
    struct filecollection *This = impl_from_IFileCollection(iface);
 
    TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
 
    *obj = NULL;
 
    if (IsEqualIID( riid, &IID_IFileCollection ) ||
        IsEqualIID( riid, &IID_IDispatch ) ||
        IsEqualIID( riid, &IID_IUnknown ))
    {
        *obj = &This->IFileCollection_iface;
    }
    else if (IsEqualIID( riid, &IID_IProvideClassInfo ))
    {
        *obj = &This->classinfo.IProvideClassInfo_iface;
    }
    else
        return E_NOINTERFACE;
 
    IUnknown_AddRef((IUnknown*)*obj);
    return S_OK;
}

filecoll_Release()

static ULONG WINAPI filecoll_Release ( IFileCollection *  iface )

static

Definition at line 1857 of file filesystem.c.

{
    struct filecollection *This = impl_from_IFileCollection(iface);
    ULONG ref = InterlockedDecrement(&This->ref);
    TRACE("(%p)->(%d)\n", This, ref);
 
    if (!ref)
    {
        SysFreeString(This->path);
        heap_free(This);
    }
 
    return ref;
}

filesys_AddRef()

static ULONG WINAPI filesys_AddRef ( IFileSystem3 *  iface )

static

Definition at line 2961 of file filesystem.c.

{
    TRACE("%p\n", iface);
 
    return 2;
}

filesys_BuildPath()

static HRESULT WINAPI filesys_BuildPath ( IFileSystem3 *  iface, BSTR  Path, BSTR  Name, BSTR *  Result  )

static

Definition at line 3037 of file filesystem.c.

{
    BSTR ret;
 
    TRACE("%p %s %s %p\n", iface, debugstr_w(Path), debugstr_w(Name), Result);
 
    if (!Result) return E_POINTER;
 
    if (Path && Name)
    {
        int path_len = SysStringLen(Path), name_len = SysStringLen(Name);
 
        /* if both parts have backslashes strip one from Path */
        if (Path[path_len-1] == '\\' && Name[0] == '\\')
        {
            path_len -= 1;
 
            ret = SysAllocStringLen(NULL, path_len + name_len);
            if (ret)
            {
                lstrcpyW(ret, Path);
                ret[path_len] = 0;
                lstrcatW(ret, Name);
            }
        }
        else if (Path[path_len-1] != '\\' && Name[0] != '\\')
        {
            ret = SysAllocStringLen(NULL, path_len + name_len + 1);
            if (ret)
            {
                lstrcpyW(ret, Path);
                if (Path[path_len-1] != ':')
                    lstrcatW(ret, bsW);
                lstrcatW(ret, Name);
            }
        }
        else
        {
            ret = SysAllocStringLen(NULL, path_len + name_len);
            if (ret)
            {
                lstrcpyW(ret, Path);
                lstrcatW(ret, Name);
            }
        }
    }
    else if (Path || Name)
        ret = SysAllocString(Path ? Path : Name);
    else
        ret = SysAllocStringLen(NULL, 0);
 
    if (!ret) return E_OUTOFMEMORY;
    *Result = ret;
 
    return S_OK;
}

filesys_CopyFile()

static HRESULT WINAPI filesys_CopyFile ( IFileSystem3 *  iface, BSTR  Source, BSTR  Destination, VARIANT_BOOL  OverWriteFiles  )

static

Definition at line 3716 of file filesystem.c.

{
    TRACE("%p %s %s %d\n", iface, debugstr_w(Source), debugstr_w(Destination), OverWriteFiles);
 
    if(!Source || !Destination)
        return E_POINTER;
 
    return copy_file(Source, SysStringLen(Source), Destination,
            SysStringLen(Destination), OverWriteFiles);
}

filesys_CopyFolder()

static HRESULT WINAPI filesys_CopyFolder ( IFileSystem3 *  iface, BSTR  Source, BSTR  Destination, VARIANT_BOOL  OverWriteFiles  )

static

Definition at line 3841 of file filesystem.c.

{
    TRACE("%p %s %s %d\n", iface, debugstr_w(Source), debugstr_w(Destination), OverWriteFiles);
 
    if(!Source || !Destination)
        return E_POINTER;
 
    return copy_folder(Source, SysStringLen(Source), Destination,
            SysStringLen(Destination), OverWriteFiles);
}

filesys_CreateFolder()

static HRESULT WINAPI filesys_CreateFolder ( IFileSystem3 *  iface, BSTR  path, IFolder **  folder  )

static

Definition at line 3853 of file filesystem.c.

{
    BOOL ret;
 
    TRACE("(%p)->(%s %p)\n", iface, debugstr_w(path), folder);
 
    ret = CreateDirectoryW(path, NULL);
    if (!ret)
    {
        *folder = NULL;
        if (GetLastError() == ERROR_ALREADY_EXISTS) return CTL_E_FILEALREADYEXISTS;
        return HRESULT_FROM_WIN32(GetLastError());
    }
 
    return create_folder(path, folder);
}

filesys_CreateTextFile()

static HRESULT WINAPI filesys_CreateTextFile ( IFileSystem3 *  iface, BSTR  filename, VARIANT_BOOL  overwrite, VARIANT_BOOL  unicode, ITextStream **  stream  )

static

Definition at line 3871 of file filesystem.c.

{
    DWORD disposition;
 
    TRACE("%p %s %d %d %p\n", iface, debugstr_w(filename), overwrite, unicode, stream);
 
    disposition = overwrite == VARIANT_TRUE ? CREATE_ALWAYS : CREATE_NEW;
    return create_textstream(filename, disposition, ForWriting, unicode ? TristateTrue : TristateFalse, stream);
}

filesys_DeleteFile()

static HRESULT WINAPI filesys_DeleteFile ( IFileSystem3 *  iface, BSTR  FileSpec, VARIANT_BOOL  Force  )

static

Definition at line 3538 of file filesystem.c.

{
    TRACE("%p %s %d\n", iface, debugstr_w(FileSpec), Force);
 
    if(!FileSpec)
        return E_POINTER;
 
    return delete_file(FileSpec, SysStringLen(FileSpec), Force);
}

filesys_DeleteFolder()

static HRESULT WINAPI filesys_DeleteFolder ( IFileSystem3 *  iface, BSTR  FolderSpec, VARIANT_BOOL  Force  )

static

Definition at line 3613 of file filesystem.c.

{
    TRACE("%p %s %d\n", iface, debugstr_w(FolderSpec), Force);
 
    if(!FolderSpec)
        return E_POINTER;
 
    return delete_folder(FolderSpec, SysStringLen(FolderSpec), Force);
}

filesys_DriveExists()

static HRESULT WINAPI filesys_DriveExists ( IFileSystem3 *  iface, BSTR  DriveSpec, VARIANT_BOOL *  pfExists  )

static

Definition at line 3328 of file filesystem.c.

{
    UINT len;
    WCHAR driveletter;
    TRACE("%p %s %p\n", iface, debugstr_w(DriveSpec), pfExists);
 
    if (!pfExists) return E_POINTER;
 
    *pfExists = VARIANT_FALSE;
    len = SysStringLen(DriveSpec);
 
    if (len >= 1) {
        driveletter = towupper(DriveSpec[0]);
        if (driveletter >= 'A' && driveletter <= 'Z'
                && (len < 2 || DriveSpec[1] == ':')
                && (len < 3 || DriveSpec[2] == '\\')) {
            const WCHAR root[] = {driveletter, ':', '\\', 0};
            UINT drivetype = GetDriveTypeW(root);
            *pfExists = drivetype != DRIVE_NO_ROOT_DIR && drivetype != DRIVE_UNKNOWN ? VARIANT_TRUE : VARIANT_FALSE;
        }
    }
 
    return S_OK;
}

filesys_FileExists()

static HRESULT WINAPI filesys_FileExists ( IFileSystem3 *  iface, BSTR  path, VARIANT_BOOL *  ret  )

static

Definition at line 3354 of file filesystem.c.

{
    DWORD attrs;
    TRACE("%p %s %p\n", iface, debugstr_w(path), ret);
 
    if (!ret) return E_POINTER;
 
    attrs = GetFileAttributesW(path);
    *ret = attrs != INVALID_FILE_ATTRIBUTES && !(attrs & FILE_ATTRIBUTE_DIRECTORY) ? VARIANT_TRUE : VARIANT_FALSE;
    return S_OK;
}

filesys_FolderExists()

static HRESULT WINAPI filesys_FolderExists ( IFileSystem3 *  iface, BSTR  path, VARIANT_BOOL *  ret  )

static

Definition at line 3366 of file filesystem.c.

{
    DWORD attrs;
    TRACE("%p %s %p\n", iface, debugstr_w(path), ret);
 
    if (!ret) return E_POINTER;
 
    attrs = GetFileAttributesW(path);
    *ret = attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY) ? VARIANT_TRUE : VARIANT_FALSE;
 
    return S_OK;
}

filesys_get_Drives()

static HRESULT WINAPI filesys_get_Drives ( IFileSystem3 *  iface, IDriveCollection **  ppdrives  )

static

Definition at line 3031 of file filesystem.c.

{
    TRACE("%p %p\n", iface, ppdrives);
    return create_drivecoll(ppdrives);
}

filesys_GetAbsolutePathName()

static HRESULT WINAPI filesys_GetAbsolutePathName ( IFileSystem3 *  iface, BSTR  Path, BSTR *  pbstrResult  )

static

Definition at line 3254 of file filesystem.c.

{
    static const WCHAR cur_path[] = {'.',0};
 
    WCHAR buf[MAX_PATH], ch;
    const WCHAR *path;
    DWORD i, beg, len, exp_len;
    WIN32_FIND_DATAW fdata;
    HANDLE fh;
 
    TRACE("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
 
    if(!pbstrResult)
        return E_POINTER;
 
    if(!Path)
        path = cur_path;
    else
        path = Path;
 
    len = GetFullPathNameW(path, MAX_PATH, buf, NULL);
    if(!len)
        return E_FAIL;
 
    buf[0] = towupper(buf[0]);
    if(len>3 && buf[len-1] == '\\')
        buf[--len] = 0;
 
    for(beg=3, i=3; i<=len; i++) {
        if(buf[i]!='\\' && buf[i])
            continue;
 
        ch = buf[i];
        buf[i] = 0;
        fh = FindFirstFileW(buf, &fdata);
        if(fh == INVALID_HANDLE_VALUE)
            break;
 
        exp_len = lstrlenW(fdata.cFileName);
        if(exp_len == i-beg)
            memcpy(buf+beg, fdata.cFileName, exp_len*sizeof(WCHAR));
        FindClose(fh);
        buf[i] = ch;
        beg = i+1;
    }
 
    *pbstrResult = SysAllocString(buf);
    if(!*pbstrResult)
        return E_OUTOFMEMORY;
    return S_OK;
}

filesys_GetBaseName()

static HRESULT WINAPI filesys_GetBaseName ( IFileSystem3 *  iface, BSTR  Path, BSTR *  pbstrResult  )

static

Definition at line 3194 of file filesystem.c.

{
    int i, end;
 
    TRACE("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
 
    if(!pbstrResult)
        return E_POINTER;
 
    if(!Path) {
        *pbstrResult = NULL;
        return S_OK;
    }
 
    for(end=lstrlenW(Path)-1; end>=0; end--)
        if(Path[end]!='/' && Path[end]!='\\')
            break;
 
    for(i=end; i>=0; i--) {
        if(Path[i]=='.' && Path[end+1]!='.')
            end = i-1;
        if(Path[i]=='/' || Path[i]=='\\')
            break;
    }
    i++;
 
    if((i>end && Path[end+1]!='.') || (i==0 && end==1 && Path[1]==':')) {
        *pbstrResult = NULL;
        return S_OK;
    }
 
    *pbstrResult = SysAllocStringLen(Path+i, end-i+1);
    if(!*pbstrResult)
        return E_OUTOFMEMORY;
    return S_OK;
}

filesys_GetDrive()

static HRESULT WINAPI filesys_GetDrive ( IFileSystem3 *  iface, BSTR  DriveSpec, IDrive **  ppdrive  )

static

Definition at line 3379 of file filesystem.c.

{
    UINT len;
    HRESULT hr;
    WCHAR driveletter;
    VARIANT_BOOL drive_exists;
 
    TRACE("%p %s %p\n", iface, debugstr_w(DriveSpec), ppdrive);
 
    if (!ppdrive)
        return E_POINTER;
 
    *ppdrive = NULL;
 
    /* DriveSpec may be one of: 'x', 'x:', 'x:\', '\\computer\share' */
    len = SysStringLen(DriveSpec);
    if (!len)
        return E_INVALIDARG;
    else if (len <= 3) {
        driveletter = towupper(DriveSpec[0]);
        if (driveletter < 'A' || driveletter > 'Z'
                || (len >= 2 && DriveSpec[1] != ':')
                || (len == 3 && DriveSpec[2] != '\\'))
            return E_INVALIDARG;
        hr = IFileSystem3_DriveExists(iface, DriveSpec, &drive_exists);
        if (FAILED(hr))
            return hr;
        if (drive_exists == VARIANT_FALSE)
            return CTL_E_DEVICEUNAVAILABLE;
        return create_drive(driveletter, ppdrive);
    } else {
        if (DriveSpec[0] != '\\' || DriveSpec[1] != '\\')
            return E_INVALIDARG;
        FIXME("%s not implemented yet\n", debugstr_w(DriveSpec));
        return E_NOTIMPL;
    }
}

filesys_GetDriveName()

static HRESULT WINAPI filesys_GetDriveName ( IFileSystem3 *  iface, BSTR  path, BSTR *  drive  )

static

Definition at line 3095 of file filesystem.c.

{
    TRACE("(%p)->(%s %p)\n", iface, debugstr_w(path), drive);
 
    if (!drive)
        return E_POINTER;
 
    *drive = NULL;
 
    if (path && lstrlenW(path) > 1 && path[1] == ':')
        *drive = SysAllocStringLen(path, 2);
 
    return S_OK;
}

filesys_GetExtensionName()

static HRESULT WINAPI filesys_GetExtensionName ( IFileSystem3 *  iface, BSTR  path, BSTR *  ext  )

static

Definition at line 3232 of file filesystem.c.

{
    INT len;
 
    TRACE("%p %s %p\n", iface, debugstr_w(path), ext);
 
    *ext = NULL;
    len = SysStringLen(path);
    while (len) {
        if (path[len-1] == '.') {
            *ext = SysAllocString(&path[len]);
            if (!*ext)
                return E_OUTOFMEMORY;
            break;
        }
        len--;
    }
 
    return S_OK;
}

filesys_GetFile()

static HRESULT WINAPI filesys_GetFile ( IFileSystem3 *  iface, BSTR  FilePath, IFile **  ppfile  )

static

Definition at line 3418 of file filesystem.c.

{
    TRACE("%p %s %p\n", iface, debugstr_w(FilePath), ppfile);
 
    if(!ppfile)
        return E_POINTER;
    if(!FilePath)
        return E_INVALIDARG;
 
    return create_file(FilePath, ppfile);
}

filesys_GetFileName()

static HRESULT WINAPI filesys_GetFileName ( IFileSystem3 *  iface, BSTR  Path, BSTR *  pbstrResult  )

static

Definition at line 3159 of file filesystem.c.

{
    int i, end;
 
    TRACE("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
 
    if(!pbstrResult)
        return E_POINTER;
 
    if(!Path) {
        *pbstrResult = NULL;
        return S_OK;
    }
 
    for(end=lstrlenW(Path)-1; end>=0; end--)
        if(Path[end]!='/' && Path[end]!='\\')
            break;
 
    for(i=end; i>=0; i--)
        if(Path[i]=='/' || Path[i]=='\\')
            break;
    i++;
 
    if(i>end || (i==0 && end==1 && Path[1]==':')) {
        *pbstrResult = NULL;
        return S_OK;
    }
 
    *pbstrResult = SysAllocStringLen(Path+i, end-i+1);
    if(!*pbstrResult)
        return E_OUTOFMEMORY;
    return S_OK;
}

filesys_GetFileVersion()

static HRESULT WINAPI filesys_GetFileVersion ( IFileSystem3 *  iface, BSTR  name, BSTR *  version  )

static

Definition at line 3920 of file filesystem.c.

{
    static const WCHAR rootW[] = {'\\',0};
    VS_FIXEDFILEINFO *info;
    WCHAR ver[30];
    void *ptr;
    DWORD len;
    BOOL ret;
 
    TRACE("%p %s %p\n", iface, debugstr_w(name), version);
 
    len = GetFileVersionInfoSizeW(name, NULL);
    if (!len)
        return HRESULT_FROM_WIN32(GetLastError());
 
    ptr = heap_alloc(len);
    if (!GetFileVersionInfoW(name, 0, len, ptr))
    {
        heap_free(ptr);
        return HRESULT_FROM_WIN32(GetLastError());
    }
 
    ret = VerQueryValueW(ptr, rootW, (void**)&info, &len);
    if (!ret)
    {
        heap_free(ptr);
        return HRESULT_FROM_WIN32(GetLastError());
    }
 
    get_versionstring(info, ver);
    heap_free(ptr);
 
    *version = SysAllocString(ver);
    TRACE("version=%s\n", debugstr_w(ver));
 
    return S_OK;
}

filesys_GetFolder()

static HRESULT WINAPI filesys_GetFolder ( IFileSystem3 *  iface, BSTR  FolderPath, IFolder **  folder  )

static

Definition at line 3431 of file filesystem.c.

{
    DWORD attrs;
 
    TRACE("%p %s %p\n", iface, debugstr_w(FolderPath), folder);
 
    if(!folder)
        return E_POINTER;
 
    *folder = NULL;
    if(!FolderPath)
        return E_INVALIDARG;
 
    attrs = GetFileAttributesW(FolderPath);
    if((attrs == INVALID_FILE_ATTRIBUTES) || !(attrs & FILE_ATTRIBUTE_DIRECTORY))
        return CTL_E_PATHNOTFOUND;
 
    return create_folder(FolderPath, folder);
}

filesys_GetIDsOfNames()

static HRESULT WINAPI filesys_GetIDsOfNames ( IFileSystem3 *  iface, REFIID  riid, LPOLESTR *  rgszNames, UINT  cNames, LCID  lcid, DISPID *  rgDispId  )

static

Definition at line 2990 of file filesystem.c.

{
    ITypeInfo *typeinfo;
    HRESULT hr;
 
    TRACE("(%p)->(%s %p %u %u %p)\n", iface, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 
    hr = get_typeinfo(IFileSystem3_tid, &typeinfo);
    if(SUCCEEDED(hr))
    {
        hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
        ITypeInfo_Release(typeinfo);
    }
 
    return hr;
}

filesys_GetParentFolderName()

static HRESULT WINAPI filesys_GetParentFolderName ( IFileSystem3 *  iface, BSTR  Path, BSTR *  pbstrResult  )

static

Definition at line 3137 of file filesystem.c.

{
    DWORD len;
 
    TRACE("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
 
    if(!pbstrResult)
        return E_POINTER;
 
    len = get_parent_folder_name(Path, SysStringLen(Path));
    if(!len) {
        *pbstrResult = NULL;
        return S_OK;
    }
 
    *pbstrResult = SysAllocStringLen(Path, len);
    if(!*pbstrResult)
        return E_OUTOFMEMORY;
    return S_OK;
}

filesys_GetSpecialFolder()

static HRESULT WINAPI filesys_GetSpecialFolder ( IFileSystem3 *  iface, SpecialFolderConst  SpecialFolder, IFolder **  folder  )

static

Definition at line 3452 of file filesystem.c.

{
    WCHAR pathW[MAX_PATH];
    DWORD ret;
 
    TRACE("%p %d %p\n", iface, SpecialFolder, folder);
 
    if (!folder)
        return E_POINTER;
 
    *folder = NULL;
 
    switch (SpecialFolder)
    {
    case WindowsFolder:
        ret = GetWindowsDirectoryW(pathW, ARRAY_SIZE(pathW));
        break;
    case SystemFolder:
        ret = GetSystemDirectoryW(pathW, ARRAY_SIZE(pathW));
        break;
    case TemporaryFolder:
        ret = GetTempPathW(ARRAY_SIZE(pathW), pathW);
        /* we don't want trailing backslash */
        if (ret && pathW[ret-1] == '\\')
            pathW[ret-1] = 0;
        break;
    default:
        FIXME("unknown special folder type, %d\n", SpecialFolder);
        return E_INVALIDARG;
    }
 
    if (!ret)
        return HRESULT_FROM_WIN32(GetLastError());
 
    return create_folder(pathW, folder);
}

filesys_GetStandardStream()

static HRESULT WINAPI filesys_GetStandardStream ( IFileSystem3 *  iface, StandardStreamTypes  StandardStreamType, VARIANT_BOOL  Unicode, ITextStream **  ppts  )

static

Definition at line 3895 of file filesystem.c.

{
    FIXME("%p %d %d %p\n", iface, StandardStreamType, Unicode, ppts);
 
    return E_NOTIMPL;
}

filesys_GetTempName()

static HRESULT WINAPI filesys_GetTempName ( IFileSystem3 *  iface, BSTR *  pbstrResult  )

static

Definition at line 3307 of file filesystem.c.

{
    static const WCHAR fmt[] = {'r','a','d','%','0','5','X','.','t','x','t',0};
 
    DWORD random;
 
    TRACE("%p %p\n", iface, pbstrResult);
 
    if(!pbstrResult)
        return E_POINTER;
 
    *pbstrResult = SysAllocStringLen(NULL, 12);
    if(!*pbstrResult)
        return E_OUTOFMEMORY;
 
    if(!RtlGenRandom(&random, sizeof(random)))
        return E_FAIL;
    swprintf(*pbstrResult, fmt, random & 0xfffff);
    return S_OK;
}

filesys_GetTypeInfo()

static HRESULT WINAPI filesys_GetTypeInfo ( IFileSystem3 *  iface, UINT  iTInfo, LCID  lcid, ITypeInfo **  ppTInfo  )

static

Definition at line 2983 of file filesystem.c.

{
    TRACE("(%p)->(%u %u %p)\n", iface, iTInfo, lcid, ppTInfo);
    return get_typeinfo(IFileSystem3_tid, ppTInfo);
}

filesys_GetTypeInfoCount()

static HRESULT WINAPI filesys_GetTypeInfoCount ( IFileSystem3 *  iface, UINT *  pctinfo  )

static

Definition at line 2975 of file filesystem.c.

{
    TRACE("(%p)->(%p)\n", iface, pctinfo);
 
    *pctinfo = 1;
    return S_OK;
}

filesys_Invoke()

static HRESULT WINAPI filesys_Invoke ( IFileSystem3 *  iface, DISPID  dispIdMember, REFIID  riid, LCID  lcid, WORD  wFlags, DISPPARAMS *  pDispParams, VARIANT *  pVarResult, EXCEPINFO *  pExcepInfo, UINT *  puArgErr  )

static

Definition at line 3009 of file filesystem.c.

{
    ITypeInfo *typeinfo;
    HRESULT hr;
 
    TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", iface, dispIdMember, debugstr_guid(riid),
           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 
    hr = get_typeinfo(IFileSystem3_tid, &typeinfo);
    if(SUCCEEDED(hr))
    {
        hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
                pDispParams, pVarResult, pExcepInfo, puArgErr);
        ITypeInfo_Release(typeinfo);
    }
 
    return hr;
}

filesys_MoveFile()

static HRESULT WINAPI filesys_MoveFile ( IFileSystem3 *  iface, BSTR  Source, BSTR  Destination  )

static

Definition at line 3624 of file filesystem.c.

{
    FIXME("%p %s %s\n", iface, debugstr_w(Source), debugstr_w(Destination));
 
    return E_NOTIMPL;
}

filesys_MoveFolder()

static HRESULT WINAPI filesys_MoveFolder ( IFileSystem3 *  iface, BSTR  Source, BSTR  Destination  )

static

Definition at line 3632 of file filesystem.c.

{
    FIXME("%p %s %s\n", iface, debugstr_w(Source), debugstr_w(Destination));
 
    return E_NOTIMPL;
}

filesys_OpenTextFile()

static HRESULT WINAPI filesys_OpenTextFile ( IFileSystem3 *  iface, BSTR  filename, IOMode  mode, VARIANT_BOOL  create, Tristate  format, ITextStream **  stream  )

static

Definition at line 3883 of file filesystem.c.

{
    DWORD disposition;
 
    TRACE("(%p)->(%s %d %d %d %p)\n", iface, debugstr_w(filename), mode, create, format, stream);
 
    disposition = create == VARIANT_TRUE ? OPEN_ALWAYS : OPEN_EXISTING;
    return create_textstream(filename, disposition, mode, format, stream);
}

filesys_QueryInterface()

static HRESULT WINAPI filesys_QueryInterface ( IFileSystem3 *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 2921 of file filesystem.c.

{
    struct filesystem *This = impl_from_IFileSystem3(iface);
 
    TRACE("%p %s %p\n", iface, debugstr_guid(riid), ppvObject);
 
    if ( IsEqualGUID( riid, &IID_IFileSystem3 ) ||
         IsEqualGUID( riid, &IID_IFileSystem ) ||
         IsEqualGUID( riid, &IID_IDispatch ) ||
         IsEqualGUID( riid, &IID_IUnknown ) )
    {
        *ppvObject = &This->IFileSystem3_iface;
    }
    else if (IsEqualGUID( riid, &IID_IProvideClassInfo ))
    {
        *ppvObject = &This->classinfo.IProvideClassInfo_iface;
    }
    else if ( IsEqualGUID( riid, &IID_IDispatchEx ))
    {
        TRACE("Interface IDispatchEx not supported - returning NULL\n");
        *ppvObject = NULL;
        return E_NOINTERFACE;
    }
    else if ( IsEqualGUID( riid, &IID_IObjectWithSite ))
    {
        TRACE("Interface IObjectWithSite not supported - returning NULL\n");
        *ppvObject = NULL;
        return E_NOINTERFACE;
    }
    else
    {
        FIXME("Unsupported interface %s\n", debugstr_guid(riid));
        return E_NOINTERFACE;
    }
 
    IUnknown_AddRef((IUnknown*)*ppvObject);
 
    return S_OK;
}

filesys_Release()

static ULONG WINAPI filesys_Release ( IFileSystem3 *  iface )

static

Definition at line 2968 of file filesystem.c.

{
    TRACE("%p\n", iface);
 
    return 1;
}

FileSystem_CreateInstance()

HRESULT WINAPI FileSystem_CreateInstance	(	IClassFactory *	iface,
		IUnknown *	outer,
		REFIID	riid,
		void **	ppv
	)

Definition at line 3998 of file filesystem.c.

{
    TRACE("(%p %s %p)\n", outer, debugstr_guid(riid), ppv);
 
    filesystem.IFileSystem3_iface.lpVtbl = &filesys_vtbl;
    init_classinfo(&CLSID_FileSystemObject, (IUnknown *)&filesystem.IFileSystem3_iface, &filesystem.classinfo);
    return IFileSystem3_QueryInterface(&filesystem.IFileSystem3_iface, riid, ppv);
}

find_next_drive()

static HRESULT find_next_drive ( struct enumvariant *  penum )

static

Definition at line 1515 of file filesystem.c.

{
    int i = penum->data.u.drivecoll.cur == -1 ? 0 : penum->data.u.drivecoll.cur + 1;
 
    for (; i < 32; i++)
        if (penum->data.u.drivecoll.coll->drives & (1 << i))
        {
            penum->data.u.drivecoll.cur = i;
            return S_OK;
        }
 
    return S_FALSE;
}

Referenced by drivecoll_enumvariant_Next(), and drivecoll_enumvariant_Skip().

folder_AddRef()

static ULONG WINAPI folder_AddRef ( IFolder *  iface )

static

Definition at line 2212 of file filesystem.c.

{
    struct folder *This = impl_from_IFolder(iface);
    ULONG ref = InterlockedIncrement(&This->ref);
    TRACE("(%p)->(%d)\n", This, ref);
    return ref;
}

folder_Copy()

static HRESULT WINAPI folder_Copy ( IFolder *  iface, BSTR  dest, VARIANT_BOOL  overwrite  )

static

Definition at line 2416 of file filesystem.c.

{
    struct folder *This = impl_from_IFolder(iface);
    FIXME("(%p)->(%s %x): stub\n", This, debugstr_w(dest), overwrite);
    return E_NOTIMPL;
}

folder_CreateTextFile()

static HRESULT WINAPI folder_CreateTextFile ( IFolder *  iface, BSTR  filename, VARIANT_BOOL  overwrite, VARIANT_BOOL  unicode, ITextStream **  stream  )

static

Definition at line 2468 of file filesystem.c.

{
    struct folder *This = impl_from_IFolder(iface);
    FIXME("(%p)->(%s %x %x %p): stub\n", This, debugstr_w(filename), overwrite, unicode, stream);
    return E_NOTIMPL;
}

folder_Delete()

static HRESULT WINAPI folder_Delete ( IFolder *  iface, VARIANT_BOOL  force  )

static

Definition at line 2409 of file filesystem.c.

{
    struct folder *This = impl_from_IFolder(iface);
    FIXME("(%p)->(%x): stub\n", This, force);
    return E_NOTIMPL;
}

folder_get_Attributes()