/// <include file='../../../../../../../doc/snippets/Microsoft.Data.SqlTypes/SqlFileStream.xml' path='docs/members[@name="SqlFileStream"]/ctor2/*' />
public SqlFileStream
(
string path,
byte[] transactionContext,
System.IO.FileAccess access,
System.IO.FileOptions options,
Int64 allocationSize
)
{
IntPtr hscp;
Bid.ScopeEnter(out hscp, "<sc.SqlFileStream.ctor|API> %d# access=%d options=%d path='%ls' ", ObjectID, (int)access, (int)options, path);
try
{
//-----------------------------------------------------------------
// precondition validation
if (transactionContext == null)
{
throw ADP.ArgumentNull("transactionContext");
}
if (path == null)
{
throw ADP.ArgumentNull("path");
}
//-----------------------------------------------------------------
m_disposed = false;
m_fs = null;
OpenSqlFileStream(path, transactionContext, access, options, allocationSize);
// only set internal state once the file has actually been successfully opened
this.Name = path;
this.TransactionContext = transactionContext;
}
finally
{
Bid.ScopeLeave(ref hscp);
}
}
/// <include file='../../../../../../../doc/snippets/Microsoft.Data.SqlTypes/SqlFileStream.xml' path='docs/members[@name="SqlFileStream"]/ctor2/*' />
public SqlFileStream
(
string path,
byte[] transactionContext,
System.IO.FileAccess access,
System.IO.FileOptions options,
Int64 allocationSize
)
{
long scopeID = SqlClientEventSource.Log.TryScopeEnterEvent("<sc.SqlFileStream.ctor|API> {0} access={1} options={2} path='{3}'", ObjectID, (int)access, (int)options, path);
try
{
//-----------------------------------------------------------------
// precondition validation
if (transactionContext == null)
{
throw ADP.ArgumentNull("transactionContext");
}
if (path == null)
{
throw ADP.ArgumentNull("path");
}
//-----------------------------------------------------------------
m_disposed = false;
m_fs = null;
OpenSqlFileStream(path, transactionContext, access, options, allocationSize);
// only set internal state once the file has actually been successfully opened
this.Name = path;
this.TransactionContext = transactionContext;
}
finally
{
SqlClientEventSource.Log.TryScopeLeaveEvent(scopeID);
}
}
public NtStatus CreateFile(string filename, FileAccess access, System.IO.FileShare share, System.IO.FileMode mode, System.IO.FileOptions options, System.IO.FileAttributes attributes, DokanFileInfo info)
{
var node = GetNodeFast(filename, info);
if (node == null)
{
if (access == FileAccess.Delete)
{
return(DokanResult.Success); //already gone
}
switch (mode)
{
case FileMode.CreateNew:
case FileMode.Create:
case FileMode.OpenOrCreate:
if (filename.Length == 0)
{
return(NtStatus.Success);
}
string Directory = filename;
if (!info.IsDirectory) //Directory doesn't have a filename that we want to cut off
{
Directory = filename.Substring(0, filename.LastIndexOf('\\'));
if (Directory.Length == 0)
{
Directory = "\\";
}
}
var nodeDirectory = CreateOrFindDirectoryRecursive(Directory);
if (!(nodeDirectory is PboFsRealFolder) && nodeDirectory is PboFsFolder virtualFolder)
{
nodeDirectory = fileTree.MakeDirectoryWriteable(virtualFolder);
}
if (nodeDirectory is PboFsRealFolder folder)
{
if (info.IsDirectory)
{
info.Context = nodeDirectory;
//Nothing else to do as full path is already included in DirectoryPath
}
else
{
//Filename without folder path
var FileNameDirect = filename.Substring(filename.LastIndexOf('\\'));
var FileNameDirectNoLeadingSlash = filename.Substring(filename.LastIndexOf('\\') + 1);
FileStream newStream = null;
try
{
newStream = System.IO.File.Create(folder.path + FileNameDirect);
}
catch (Exception e)
{
Console.WriteLine(e);
return(DokanResult.AccessDenied); //#TODO correct result for exception type
}
var rlFile = new PboFsRealFile(new System.IO.FileInfo(folder.path + FileNameDirect), folder, newStream);
folder.Children[FileNameDirectNoLeadingSlash.ToLower()] = rlFile;
fileTree.AddNode(rlFile);
info.Context = rlFile;
}
return(DokanResult.Success);
}
return(DokanResult.DiskFull);
case FileMode.Open:
case FileMode.Truncate:
case FileMode.Append:
return(DokanResult.FileNotFound);
}
}
info.Context = node;
if (node is PboFsFolder && !info.IsDirectory)
{
info.IsDirectory = true; //Dokan documentation says we need to do that.
}
if (mode == FileMode.CreateNew)
{
return(DokanResult.FileExists);
}
if (access == FileAccess.Delete)
{
NtStatus deleteResult = DokanResult.NotImplemented;
if (node is PboFsRealFile)
{
deleteResult = DeleteFile(filename, info);
}
else if (node is PboFsRealFolder)
{
deleteResult = DeleteDirectory(filename, info);
}
return(deleteResult);
}
bool wantsWrite = (access &
(FileAccess.WriteData | FileAccess.AppendData | FileAccess.Delete | FileAccess.GenericWrite)
) != 0;
bool wantsRead = (access &
(FileAccess.ReadData | FileAccess.GenericRead | FileAccess.Execute | FileAccess.GenericExecute)
) != 0;
if (wantsWrite && !(node is IPboFsRealObject))
{
return(DokanResult.AccessDenied);
}
if (node is IPboFsFile file && (wantsRead || wantsWrite))
{
return(file.Open(wantsWrite, mode));
}
return(DokanResult.Success);
}
public int CreateFile(string filename, System.IO.FileAccess access, System.IO.FileShare share, System.IO.FileMode mode, System.IO.FileOptions options, DokanFileInfo info)
{
int ret = DokanNet.DOKAN_SUCCESS;
filename = CleanFileName(filename);
try
{
Debug("CreateFile {0}", filename);
string Directory = MainForm.In.mNFS.GetDirectoryName(filename);
string FileName = MainForm.In.mNFS.GetFileName(filename);
string FullPath = MainForm.In.mNFS.Combine(FileName, Directory);
if (MainForm.In.mNFS.IsDirectory(FullPath))
{
return(ret);
}
switch (mode)
{
case FileMode.Open:
{
Debug("Open");
if (!MainForm.In.mNFS.FileExists(FullPath))
{
ret = -DokanNet.ERROR_FILE_NOT_FOUND;
}
break;
}
case FileMode.CreateNew:
{
Debug("CreateNew");
if (MainForm.In.mNFS.FileExists(FullPath))
{
ret = -DokanNet.ERROR_ALREADY_EXISTS;
}
else
{
MainForm.In.mNFS.CreateFile(FullPath);
}
break;
}
case FileMode.Create:
{
Debug("Create");
if (MainForm.In.mNFS.FileExists(FullPath))
{
MainForm.In.mNFS.DeleteFile(FullPath);
}
MainForm.In.mNFS.CreateFile(FullPath);
break;
}
case FileMode.OpenOrCreate:
{
Debug("OpenOrCreate");
if (!MainForm.In.mNFS.FileExists(FullPath))
{
MainForm.In.mNFS.CreateFile(FullPath);
}
break;
}
case FileMode.Truncate:
{
Debug("Truncate");
if (!MainForm.In.mNFS.FileExists(FullPath))
{
ret = -DokanNet.ERROR_FILE_NOT_FOUND;
}
else
{
MainForm.In.mNFS.CreateFile(FullPath);
}
break;
}
case FileMode.Append:
{
Debug("Appen");
if (!MainForm.In.mNFS.FileExists(FullPath))
{
ret = -DokanNet.ERROR_FILE_NOT_FOUND;
}
break;
}
default:
{
Debug("Error unknown FileMode {0}", mode);
break;
}
}
}
catch (Exception ex)
{
ret = -DokanNet.DOKAN_ERROR;
Debug("CreateFile file {0} exception {1}", filename, ex.Message);
}
return(ret);
}
public int CreateFile(
string filename,
System.IO.FileAccess access,
System.IO.FileShare share,
System.IO.FileMode mode,
System.IO.FileOptions options,
DokanFileInfo info)
{
Console.WriteLine("Dokan CreateFile, filename is " + filename);
Dokan.DokanNet.DokanResetTimeout(1000 * 30, info);
info.Context = Context++;
string targetPath = filename.Replace("\\", "/");
String name = GetFileName(targetPath);
#region 老方法 - 废弃，参考
//try
//{
// if (filename == "\\")
// {
// //info.IsDirectory = true;
// return DokanNet.DOKAN_SUCCESS;
// }
// if (name == "desktop.ini" || name == "folder.jpg" || name == "folder.gif" || name == @".svn") return -DokanNet.ERROR_FILE_NOT_FOUND;
// #region 通过List<FileElement>查询文件
// FileElement file = allinone.getSingleFileInfo(targetPath);
// if (file == null)
// {
// }
// else if ((access & System.IO.FileAccess.Read) == System.IO.FileAccess.Read)
// {
// if (file.isdir == System.IO.FileAttributes.Directory)
// {
// info.IsDirectory = true;
// return DokanNet.DOKAN_SUCCESS;
// }
// else
// {
// return DokanNet.DOKAN_SUCCESS;
// }
// }
// #endregion
// #region Mem盘的方法 - 废弃
// //FileElement file = allinone.getSingleFileInfo(targetPath);
// //if (file!=null)
// //{
// // //this is a folder?
// // info.IsDirectory = true;
// // if (mode == FileMode.Open || mode == FileMode.OpenOrCreate)
// // {
// // //info.IsDirectory = true;
// // return DokanNet.DOKAN_SUCCESS;
// // }
// // // you can't make a file with the same name as a folder;
// // return -DokanNet.ERROR_ALREADY_EXISTS;
// //}
// #endregion
// // there's no folder with this name, the parent exists;
// // attempt to use the file
// switch (mode)
// {
// // Opens the file if it exists and seeks to the end of the file,
// // or creates a new file
// case FileMode.Append:
// return DokanNet.DOKAN_SUCCESS;
// // Specifies that the operating system should create a new file.
// // If the file already exists, it will be overwritten.
// case FileMode.Create:
// //if (!thisFile.Exists())
// //else
// // thisFile.Content = new Thought.Research.AweBuffer(1024); //MemoryStream();
// return DokanNet.DOKAN_SUCCESS;
// // Specifies that the operating system should create a new file.
// // If the file already exists, an IOException is thrown.
// case FileMode.CreateNew:
// Console.WriteLine("try to create new file, file name is " + name);
// return DokanNet.DOKAN_SUCCESS;
// // Specifies that the operating system should open an existing file.
// // A System.IO.FileNotFoundException is thrown if the file does not exist.
// case FileMode.Open:
// return DokanNet.DOKAN_SUCCESS;
// // Specifies that the operating system should open a file if it exists;
// // otherwise, a new file should be created.
// case FileMode.OpenOrCreate:
// return DokanNet.DOKAN_SUCCESS;
// // Specifies that the operating system should open an existing file.
// // Once opened, the file should be truncated so that its size is zero bytes
// case FileMode.Truncate:
// return DokanNet.DOKAN_SUCCESS;
// }
//}
//catch (Exception e)
//{
// Console.WriteLine(e);
//}
//return DokanNet.DOKAN_SUCCESS;
#endregion
#region 13/11/1添加改用新方法
if (filename == "\\")
{
//info.IsDirectory = true;
return(DokanNet.DOKAN_SUCCESS);
}
if (mode == FileMode.Open || mode == FileMode.OpenOrCreate)
{
FileElement file = allinone.getSingleFileInfo(targetPath);
if (file != null)
{
if (file.isdir == System.IO.FileAttributes.Normal)
{
return(DokanNet.DOKAN_SUCCESS);
}
if (file.isdir == System.IO.FileAttributes.Directory)
{
info.IsDirectory = true;
return(DokanNet.DOKAN_SUCCESS);
}
}
return(-DokanNet.ERROR_FILE_NOT_FOUND);
}
return(DokanNet.DOKAN_SUCCESS);
#endregion
}
private void OpenSqlFileStream
(
string path,
byte[] transactionContext,
System.IO.FileAccess access,
System.IO.FileOptions options,
Int64 allocationSize
)
{
//-----------------------------------------------------------------
// precondition validation
// these should be checked by any caller of this method
// ensure we have validated and normalized the path before
Debug.Assert(path != null);
Debug.Assert(transactionContext != null);
if (access != FileAccess.Read && access != FileAccess.Write && access != FileAccess.ReadWrite)
{
throw ADP.ArgumentOutOfRange("access");
}
// FileOptions is a set of flags, so AND the given value against the set of values we do not support
if ((options & ~(FileOptions.WriteThrough | FileOptions.Asynchronous | FileOptions.RandomAccess | FileOptions.SequentialScan)) != 0)
{
throw ADP.ArgumentOutOfRange("options");
}
//-----------------------------------------------------------------
// normalize the provided path
// * compress path to remove any occurences of '.' or '..'
// * trim whitespace from the beginning and end of the path
// * ensure that the path starts with '\\'
// * ensure that the path does not start with '\\.\'
// * ensure that the path is not longer than Int16.MaxValue
path = GetFullPathInternal(path);
// ensure the running code has permission to read/write the file
DemandAccessPermission(path, access);
FileFullEaInformation eaBuffer = null;
SecurityQualityOfService qos = null;
UnicodeString objectName = null;
Microsoft.Win32.SafeHandles.SafeFileHandle hFile = null;
int nDesiredAccess = UnsafeNativeMethods.FILE_READ_ATTRIBUTES | UnsafeNativeMethods.SYNCHRONIZE;
UInt32 dwCreateOptions = 0;
UInt32 dwCreateDisposition = 0;
System.IO.FileShare shareAccess = System.IO.FileShare.None;
switch (access)
{
case System.IO.FileAccess.Read:
nDesiredAccess |= UnsafeNativeMethods.FILE_READ_DATA;
shareAccess = System.IO.FileShare.Delete | System.IO.FileShare.ReadWrite;
dwCreateDisposition = (uint)UnsafeNativeMethods.CreationDisposition.FILE_OPEN;
break;
case System.IO.FileAccess.Write:
nDesiredAccess |= UnsafeNativeMethods.FILE_WRITE_DATA;
shareAccess = System.IO.FileShare.Delete | System.IO.FileShare.Read;
dwCreateDisposition = (uint)UnsafeNativeMethods.CreationDisposition.FILE_OVERWRITE;
break;
case System.IO.FileAccess.ReadWrite:
default:
// we validate the value of 'access' parameter in the beginning of this method
Debug.Assert(access == System.IO.FileAccess.ReadWrite);
nDesiredAccess |= UnsafeNativeMethods.FILE_READ_DATA | UnsafeNativeMethods.FILE_WRITE_DATA;
shareAccess = System.IO.FileShare.Delete | System.IO.FileShare.Read;
dwCreateDisposition = (uint)UnsafeNativeMethods.CreationDisposition.FILE_OVERWRITE;
break;
}
if ((options & System.IO.FileOptions.WriteThrough) != 0)
{
dwCreateOptions |= (uint)UnsafeNativeMethods.CreateOption.FILE_WRITE_THROUGH;
}
if ((options & System.IO.FileOptions.Asynchronous) == 0)
{
dwCreateOptions |= (uint)UnsafeNativeMethods.CreateOption.FILE_SYNCHRONOUS_IO_NONALERT;
}
if ((options & System.IO.FileOptions.SequentialScan) != 0)
{
dwCreateOptions |= (uint)UnsafeNativeMethods.CreateOption.FILE_SEQUENTIAL_ONLY;
}
if ((options & System.IO.FileOptions.RandomAccess) != 0)
{
dwCreateOptions |= (uint)UnsafeNativeMethods.CreateOption.FILE_RANDOM_ACCESS;
}
try
{
eaBuffer = new FileFullEaInformation(transactionContext);
qos = new SecurityQualityOfService(UnsafeNativeMethods.SecurityImpersonationLevel.SecurityAnonymous,
false, false);
// NOTE: the Name property is intended to reveal the publicly available moniker for the
// FILESTREAM attributed column data. We will not surface the internal processing that
// takes place to create the mappedPath.
string mappedPath = InitializeNtPath(path);
objectName = new UnicodeString(mappedPath);
UnsafeNativeMethods.OBJECT_ATTRIBUTES oa;
oa.length = Marshal.SizeOf(typeof(UnsafeNativeMethods.OBJECT_ATTRIBUTES));
oa.rootDirectory = IntPtr.Zero;
oa.attributes = (int)UnsafeNativeMethods.Attributes.CaseInsensitive;
oa.securityDescriptor = IntPtr.Zero;
oa.securityQualityOfService = qos;
oa.objectName = objectName;
UnsafeNativeMethods.IO_STATUS_BLOCK ioStatusBlock;
uint oldMode;
uint retval = 0;
UnsafeNativeMethods.SetErrorModeWrapper(UnsafeNativeMethods.SEM_FAILCRITICALERRORS, out oldMode);
try
{
Bid.Trace("<sc.SqlFileStream.OpenSqlFileStream|ADV> %d#, desiredAccess=0x%08x, allocationSize=%I64d, fileAttributes=0x%08x, shareAccess=0x%08x, dwCreateDisposition=0x%08x, createOptions=0x%08x\n",
ObjectID, (int)nDesiredAccess, allocationSize, 0, (int)shareAccess, dwCreateDisposition, dwCreateOptions);
retval = UnsafeNativeMethods.NtCreateFile(out hFile, nDesiredAccess,
ref oa, out ioStatusBlock, ref allocationSize,
0, shareAccess, dwCreateDisposition, dwCreateOptions,
eaBuffer, (uint)eaBuffer.Length);
}
finally
{
UnsafeNativeMethods.SetErrorModeWrapper(oldMode, out oldMode);
}
switch (retval)
{
case 0:
break;
case UnsafeNativeMethods.STATUS_SHARING_VIOLATION:
throw ADP.InvalidOperation(Res.GetString(Res.SqlFileStream_FileAlreadyInTransaction));
case UnsafeNativeMethods.STATUS_INVALID_PARAMETER:
throw ADP.Argument(Res.GetString(Res.SqlFileStream_InvalidParameter));
case UnsafeNativeMethods.STATUS_OBJECT_NAME_NOT_FOUND:
{
System.IO.DirectoryNotFoundException e = new System.IO.DirectoryNotFoundException();
ADP.TraceExceptionAsReturnValue(e);
throw e;
}
default:
{
uint error = UnsafeNativeMethods.RtlNtStatusToDosError(retval);
if (error == UnsafeNativeMethods.ERROR_MR_MID_NOT_FOUND)
{
// status code could not be mapped to a Win32 error code
error = retval;
}
System.ComponentModel.Win32Exception e = new System.ComponentModel.Win32Exception(unchecked ((int)error));
ADP.TraceExceptionAsReturnValue(e);
throw e;
}
}
if (hFile.IsInvalid)
{
System.ComponentModel.Win32Exception e = new System.ComponentModel.Win32Exception(UnsafeNativeMethods.ERROR_INVALID_HANDLE);
ADP.TraceExceptionAsReturnValue(e);
throw e;
}
UnsafeNativeMethods.FileType fileType = UnsafeNativeMethods.GetFileType(hFile);
if (fileType != UnsafeNativeMethods.FileType.Disk)
{
hFile.Dispose();
throw ADP.Argument(Res.GetString(Res.SqlFileStream_PathNotValidDiskResource));
}
// if the user is opening the SQL FileStream in read/write mode, we assume that they want to scan
// through current data and then append new data to the end, so we need to tell SQL Server to preserve
// the existing file contents.
if (access == System.IO.FileAccess.ReadWrite)
{
uint ioControlCode = UnsafeNativeMethods.CTL_CODE(UnsafeNativeMethods.FILE_DEVICE_FILE_SYSTEM,
IoControlCodeFunctionCode, (byte)UnsafeNativeMethods.Method.METHOD_BUFFERED,
(byte)UnsafeNativeMethods.Access.FILE_ANY_ACCESS);
uint cbBytesReturned = 0;
if (!UnsafeNativeMethods.DeviceIoControl(hFile, ioControlCode, IntPtr.Zero, 0, IntPtr.Zero, 0, out cbBytesReturned, IntPtr.Zero))
{
System.ComponentModel.Win32Exception e = new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error());
ADP.TraceExceptionAsReturnValue(e);
throw e;
}
}
// now that we've successfully opened a handle on the path and verified that it is a file,
// use the SafeFileHandle to initialize our internal System.IO.FileStream instance
// NOTE: need to assert UnmanagedCode permissions for this constructor. This is relatively benign
// in that we've done much the same validation as in the FileStream(string path, ...) ctor case
// most notably, validating that the handle type corresponds to an on-disk file.
bool bRevertAssert = false;
try
{
SecurityPermission sp = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode);
sp.Assert();
bRevertAssert = true;
System.Diagnostics.Debug.Assert(m_fs == null);
m_fs = new System.IO.FileStream(hFile, access, DefaultBufferSize, ((options & System.IO.FileOptions.Asynchronous) != 0));
}
finally
{
if (bRevertAssert)
{
SecurityPermission.RevertAssert();
}
}
}
catch
{
if (hFile != null && !hFile.IsInvalid)
{
hFile.Dispose();
}
throw;
}
finally
{
if (eaBuffer != null)
{
eaBuffer.Dispose();
eaBuffer = null;
}
if (qos != null)
{
qos.Dispose();
qos = null;
}
if (objectName != null)
{
objectName.Dispose();
objectName = null;
}
}
}
public abstract DokanError CreateFile(string fileName, FileAccess access, System.IO.FileShare share, System.IO.FileMode mode, System.IO.FileOptions options, System.IO.FileAttributes attributes, DokanFileInfo info);
public static SIO.FileStream Create(Hierarchy hierarchy, int bufferSize, SIO.FileOptions options, System.Security.AccessControl.FileSecurity fileSecurity, string fn, params string[] fns)
{
throw new NotImplementedException("KSPe.IO.File.Create");
}
/// <summary>
/// Opens the specified file.
/// </summary>
/// <param name="path">
/// A <see cref="String"/> containing the path of the file to open.
/// </param>
/// <param name="access">
/// One of the <see cref="FileAccess"/> value that specifies the operations that can be
/// performed on the file.
/// </param>
/// <param name="mode">
/// One of the <see cref="FileMode"/> values that specifies whether a file is created
/// if one does not exist, and determines whether the contents of existing files are
/// retained or overwritten.
/// </param>
/// <param name="share">
/// One of the <see cref="FileShare"/> values specifying the type of access other threads
/// have to the file.
/// </param>
/// <param name="bufferSize">
/// An <see cref="Int32"/> containing the number of bytes to buffer for reads and writes
/// to the file, or 0 to specified the default buffer size, 1024.
/// </param>
/// <param name="options">
/// One or more of the <see cref="FileOptions"/> values that describes how to create or
/// overwrite the file.
/// </param>
/// <returns>
/// A <see cref="FileStream"/> that provides access to the file specified in
/// <paramref name="path"/>.
/// </returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="path"/> is <see langword="null"/>.
/// </exception>
/// <exception cref="ArgumentException">
/// <paramref name="path"/> is an empty string (""), contains only white
/// space, or contains one or more invalid characters as defined in
/// <see cref="Path.GetInvalidPathChars()"/>.
/// <para>
/// -or-
/// </para>
/// <paramref name="path"/> contains one or more components that exceed
/// the drive-defined maximum length. For example, on Windows-based
/// platforms, components must not exceed 255 characters.
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">
/// <paramref name="bufferSize"/> is less than 0.
/// </exception>
/// <exception cref="PathTooLongException">
/// <paramref name="path"/> exceeds the system-defined maximum length.
/// For example, on Windows-based platforms, paths must not exceed
/// 255 characters.
/// </exception>
/// <exception cref="DirectoryNotFoundException">
/// One or more directories in <paramref name="path"/> could not be found.
/// </exception>
/// <exception cref="UnauthorizedAccessException">
/// The caller does not have the required access permissions.
/// <para>
/// -or-
/// </para>
/// <paramref name="path"/> refers to a file that is read-only and <paramref name="access"/>
/// is not <see cref="FileAccess.Read"/>.
/// <para>
/// -or-
/// </para>
/// <paramref name="path"/> is a directory.
/// </exception>
/// <exception cref="IOException">
/// <paramref name="path"/> refers to a file that is in use.
/// <para>
/// -or-
/// </para>
/// <paramref name="path"/> specifies a device that is not ready.
/// </exception>
public System.IO.FileStream Open(string path, System.IO.FileMode mode, System.IO.FileAccess access, System.IO.FileShare share, int bufferSize, System.IO.FileOptions options)
{
return(new FileStream(path, mode, access, share, bufferSize, options));
}
/// <summary>
/// <see cref="IFileProvider.Open"/>
/// </summary>
public System.IO.FileStream Open(
string path, System.IO.FileMode mode, System.IO.FileAccess access, System.IO.FileShare share, int bufferSize, System.IO.FileOptions options)
{
if (bufferSize == 0)
{
bufferSize = 1024;
}
var longPath = new LongPath(path);
SafeFileHandle handle = GetFileHandle(longPath, mode, access, share, options);
return(new FileStream(handle, access, bufferSize, (options & FileOptions.Asynchronous) == FileOptions.Asynchronous));
}
public int CreateFile(string filename, System.IO.FileAccess access, System.IO.FileShare share, System.IO.FileMode mode, System.IO.FileOptions options, DokanFileInfo info)
{
if (KeepStats)
{
Stats.count();
}
debug("...create file request for " + filename + " with access " + access + " with mode " + mode);
if (filename.Equals(ROOT_PATH))
{
return(0);
}
else if (filename.StartsWith("\\autorun", StringComparison.CurrentCultureIgnoreCase))
{
return(0);
}
else if (filename.StartsWith(ROOT_PATH) && MySubDirs.ContainsKey(filename.Substring(1)))
{
List <Chunk> lst;
MySubDirs.TryGetValue(filename.Substring(1), out lst);
info.Context = (ulong)this.getNextId();
openChunks.Add((ulong)info.Context, new OpenChunk(filename.Substring(1), lst));
return(0);
}
string fn = (filename.StartsWith("\\")) ? filename.Substring(filename.LastIndexOf("\\") + 1) : filename;
if (this.MyDirectory.ContainsKey(fn))
{
if (mode != FileMode.Open)
{
return(-1);
}
if (access != FileAccess.Read)
{
return(-1);
}
Chunk c;
MyDirectory.TryGetValue(fn, out c);
info.Context = (ulong)this.getNextId();
debug("...create file request ****CTX*** is " + (ulong)info.Context);
//FileStream fs = File.Open(c.ActualPath, FileMode.Open, FileAccess.Read, FileShare.Read);
FileStream fs = new FileStream(c.ActualPath, FileMode.Open, FileAccess.Read, FileShare.Read, BufferSize, FileOptions.SequentialScan);
openChunks.Add((ulong)info.Context, new OpenChunk(c, fs));
return(0);
}
else
{
return(0);
}
}
public System.IO.FileStream Create(string subpath, int bufferSize, System.IO.FileOptions options, System.Security.AccessControl.FileSecurity fileSecurity)
{
return(File.Create(Path.Combine(RootDir, subpath), bufferSize, options, fileSecurity));
}
public System.IO.FileStream Create(string subpath, int bufferSize, System.IO.FileOptions options)
{
return(File.Create(Path.Combine(RootDir, subpath), bufferSize, options));
}
/// <summary>
/// Converts a <strong>System.IO.FileOptions</strong> value to
/// <strong>DigitalRune.Storages.FileOptions</strong>.
/// </summary>
/// <param name="value">The <strong>System.IO.FileOptions</strong> value.</param>
/// <returns>The <strong>DigitalRune.Storages.FileOptions</strong> value.</returns>
public static FileOptions FromSystemIO(System.IO.FileOptions value)
{
return (FileOptions)value;
}
public int CreateFile(string filename, System.IO.FileAccess access, System.IO.FileShare share, System.IO.FileMode mode, System.IO.FileOptions options, Dokan.DokanFileInfo info)
{
try
{
info.Context = FileSystem.OpenFile(filename, mode);
return(0);
}
catch (Exception e)
{
Console.WriteLine(" -- CreateFile Error: " + e.Message);
info.Context = null;
//return -1;
return(0);
}
finally
{
NotImplemented(filename, info.Context);
}
//info.Context = FileSystem.OpenFile(filename, mode);
}
public static SIO.FileStream Create(Hierarchy hierarchy, int bufferSize, SIO.FileOptions options, string fn, params string[] fns)
{
throw new NotImplementedException("KSPe.IO.File.Create");
}
public int CreateFile(string filename, System.IO.FileAccess access, System.IO.FileShare share, System.IO.FileMode mode, System.IO.FileOptions options, DokanFileInfo info)
{
FileInformation fi = new FileInformation();
GetFileInformation(filename, ref fi, info);
switch (mode)
{
case FileMode.Append:
return(DokanNet.DOKAN_SUCCESS);
case FileMode.Create:
AddToFileCache(filename, FillFileCache(filename));
return(DokanNet.DOKAN_SUCCESS);
case FileMode.CreateNew:
AddToFileCache(filename, FillFileCache(filename));
return(DokanNet.DOKAN_SUCCESS);
case FileMode.Open:
return(DokanNet.DOKAN_SUCCESS);
case FileMode.Truncate:
return(DokanNet.DOKAN_SUCCESS);
}
return(DokanNet.DOKAN_ERROR);
}
//Windows System Error Codes @ http://www.hiteksoftware.com/knowledge/articles/049.htm
public int CreateFile(string filename, System.IO.FileAccess access, System.IO.FileShare share, System.IO.FileMode mode, System.IO.FileOptions options, DokanFileInfo info)
{
Console.WriteLine("crFile: " + filename);
info.Context = count++;
if (filename.Trim() == "\\")
{
info.IsDirectory = true;
return(0);
}
else
{
RAFInMemoryFileSystemObject fso = rafManager.ResolveRAFPathTOFSO(filename);
Console.WriteLine("-> FSO NULL? " + (fso == null));
if (fso == null)
{
return(-DokanNet.ERROR_ACCESS_DENIED);
}
else
{
if (fso.GetFSOType() == RAFFSOType.DIRECTORY)
{
info.IsDirectory = true;
}
return(0);
}
}
//return -82;
}
private bool IsFileInUse(System.IO.FileShare fshare = FileShare.Read, System.Security.AccessControl.FileSystemRights fSysRights = FileSystemRights.Read, System.IO.FileAccess fAccess = FileAccess.Read, System.IO.FileMode fMode = FileMode.Open, System.IO.FileOptions fOptions = FileOptions.None)
{
bool inUse = false;
try
{
do
{
this.m_fileHandle = CreateFile(this.m_path, fSysRights, fshare, IntPtr.Zero, fMode, FileOptions.None, IntPtr.Zero);
if (this.m_fileHandle.IsInvalid)
{
int LastErr = Marshal.GetLastWin32Error();
//Console.WriteLine("IsFileInUse LastErr: " & LastErr & ", " & New Win32Exception(LastErr).Message, , , False)
inUse = true;
if (LastErr == ERROR_SHARING_VIOLATION || LastErr == ERROR_LOCK_VIOLATION)
{
if (!this.m_fileHandle.IsClosed)
{
this.m_fileHandle.Close();
}
}
else
{
//Me.m_fileStream = New FileStream(m_fileHandle, fAccess)
}
}
else
{
this.m_fileStream = new FileStream(this.m_fileHandle, fAccess);
}
break;
} while (true);
}
catch (Exception ex)
{
Console.WriteLine("IsFileInUse Error: " + ex.Msg());
inUse = true;
}
finally
{
}
return(inUse);
}
public uint Def_CreateFile(string filename, System.IO.FileAccess access, System.IO.FileShare share, System.IO.FileMode mode, System.IO.FileOptions options, IntPtr info)
{
//return 0;
RegistryFileBlock rb = new RegistryFileBlock(filename);
if (rb.ValueKind > 0)
{
if (mode == FileMode.CreateNew || mode == FileMode.OpenOrCreate)
{
if (rb.level == 2)
{
GetRegistoryEntry(rb).CreateSubKey(rb.KeyPointer.Substring(rb.KeyPointer.LastIndexOf("\\") + 1));
return(0);
}
int check;
if (rb.level == 3 && filename.EndsWith(regtypes[rb.ValueKind], StringComparison.CurrentCultureIgnoreCase))
{
switch (rb.ValueKind)
{
case 1:
GetRegistoryEntry(rb).SetValue(rb.ValueName, 0, RegValueType[rb.ValueKind]);
break;
case 2:
GetRegistoryEntry(rb).SetValue(rb.ValueName, "", RegValueType[rb.ValueKind]);
break;
case 3:
GetRegistoryEntry(rb).SetValue(rb.ValueName, 0, RegValueType[rb.ValueKind]);
break;
case 4:
GetRegistoryEntry(rb).SetValue(rb.ValueName, "", RegValueType[rb.ValueKind]);
break;
default:
return(0xC000000F);
}
return(0);
}
}
}
else
{
if (filename == "\\")
{
return(0);
}
if (filename.EndsWith("dekstop.ini", StringComparison.CurrentCultureIgnoreCase) || filename.EndsWith("autorun.inf", StringComparison.CurrentCultureIgnoreCase))
{
return(0);
}
// else
// Console.WriteLine("Invalid New File {0}",filename);
return(0xC000000F);
}
return(0xC000000F);
}
private async Task <bool> LockFile(System.IO.FileShare fshare = FileShare.Read, System.Security.AccessControl.FileSystemRights fSysRights = FileSystemRights.Read, System.IO.FileAccess fAccess = FileAccess.Read, System.IO.FileMode fMode = FileMode.Open, System.IO.FileOptions fOptions = FileOptions.None)
{
int num = 0;
bool flag = false;
Stopwatch SW = new Stopwatch();
SW.Start();
while (!flag && (num < 2000) && (SW.ElapsedMilliseconds < 30000))
{
//Try
if (!this.IsFileInUse(fshare, fSysRights, fAccess, fMode, fOptions))
{
if (fMode == FileMode.OpenOrCreate || fAccess == FileAccess.ReadWrite || fAccess == FileAccess.Write)
{
try
{
this.m_fileStream.Lock(this.m_fileStream.Length, 0xFFFF);
this.m_WasLocked = true;
this.FileExists = true;
}
catch (Exception ex)
{
Console.WriteLine(" LockFile Error: " + ex.Message);
}
}
}
else
{
num += 1;
await Task.Delay(10); //'Thread.Sleep(10)
continue;
}
//Catch exception1 As Exception
// num += 1
// Thread.Sleep(10)
// Continue Do
//End Try
flag = true;
}
SW.Stop();
if (num > 0)
{
Console.WriteLine(" Lockfile lock time: " + SW.ElapsedMilliseconds + "ms, errcount=" + num);
}
return(flag);
}
private unsafe void OpenSqlFileStream
(
string sPath,
byte[] transactionContext,
System.IO.FileAccess access,
System.IO.FileOptions options,
long allocationSize
)
{
//-----------------------------------------------------------------
// precondition validation
// these should be checked by any caller of this method
// ensure we have validated and normalized the path before
Debug.Assert(sPath != null);
Debug.Assert(transactionContext != null);
if (access != System.IO.FileAccess.Read && access != System.IO.FileAccess.Write && access != System.IO.FileAccess.ReadWrite)
{
throw ADP.ArgumentOutOfRange("access");
}
// FileOptions is a set of flags, so AND the given value against the set of values we do not support
if ((options & ~(System.IO.FileOptions.WriteThrough | System.IO.FileOptions.Asynchronous | System.IO.FileOptions.RandomAccess | System.IO.FileOptions.SequentialScan)) != 0)
{
throw ADP.ArgumentOutOfRange("options");
}
//-----------------------------------------------------------------
// normalize the provided path
// * compress path to remove any occurrences of '.' or '..'
// * trim whitespace from the beginning and end of the path
// * ensure that the path starts with '\\'
// * ensure that the path does not start with '\\.\'
sPath = GetFullPathInternal(sPath);
Microsoft.Win32.SafeHandles.SafeFileHandle hFile = null;
Interop.NtDll.DesiredAccess nDesiredAccess = Interop.NtDll.DesiredAccess.FILE_READ_ATTRIBUTES | Interop.NtDll.DesiredAccess.SYNCHRONIZE;
Interop.NtDll.CreateOptions dwCreateOptions = 0;
Interop.NtDll.CreateDisposition dwCreateDisposition = 0;
System.IO.FileShare nShareAccess = System.IO.FileShare.None;
switch (access)
{
case System.IO.FileAccess.Read:
nDesiredAccess |= Interop.NtDll.DesiredAccess.FILE_READ_DATA;
nShareAccess = System.IO.FileShare.Delete | System.IO.FileShare.ReadWrite;
dwCreateDisposition = Interop.NtDll.CreateDisposition.FILE_OPEN;
break;
case System.IO.FileAccess.Write:
nDesiredAccess |= Interop.NtDll.DesiredAccess.FILE_WRITE_DATA;
nShareAccess = System.IO.FileShare.Delete | System.IO.FileShare.Read;
dwCreateDisposition = Interop.NtDll.CreateDisposition.FILE_OVERWRITE;
break;
case System.IO.FileAccess.ReadWrite:
default:
// we validate the value of 'access' parameter in the beginning of this method
Debug.Assert(access == System.IO.FileAccess.ReadWrite);
nDesiredAccess |= Interop.NtDll.DesiredAccess.FILE_READ_DATA | Interop.NtDll.DesiredAccess.FILE_WRITE_DATA;
nShareAccess = System.IO.FileShare.Delete | System.IO.FileShare.Read;
dwCreateDisposition = Interop.NtDll.CreateDisposition.FILE_OVERWRITE;
break;
}
if ((options & System.IO.FileOptions.WriteThrough) != 0)
{
dwCreateOptions |= Interop.NtDll.CreateOptions.FILE_WRITE_THROUGH;
}
if ((options & System.IO.FileOptions.Asynchronous) == 0)
{
dwCreateOptions |= Interop.NtDll.CreateOptions.FILE_SYNCHRONOUS_IO_NONALERT;
}
if ((options & System.IO.FileOptions.SequentialScan) != 0)
{
dwCreateOptions |= Interop.NtDll.CreateOptions.FILE_SEQUENTIAL_ONLY;
}
if ((options & System.IO.FileOptions.RandomAccess) != 0)
{
dwCreateOptions |= Interop.NtDll.CreateOptions.FILE_RANDOM_ACCESS;
}
try
{
// NOTE: the Name property is intended to reveal the publicly available moniker for the
// FILESTREAM attributed column data. We will not surface the internal processing that
// takes place to create the mappedPath.
string mappedPath = InitializeNtPath(sPath);
int retval = 0;
Interop.Kernel32.SetThreadErrorMode(Interop.Kernel32.SEM_FAILCRITICALERRORS, out uint oldMode);
try
{
if (transactionContext.Length >= ushort.MaxValue)
{
throw ADP.ArgumentOutOfRange("transactionContext");
}
int headerSize = sizeof(Interop.NtDll.FILE_FULL_EA_INFORMATION);
int fullSize = headerSize + transactionContext.Length + s_eaNameString.Length;
byte[] buffer = ArrayPool <byte> .Shared.Rent(fullSize);
fixed(byte *b = buffer)
{
Interop.NtDll.FILE_FULL_EA_INFORMATION *ea = (Interop.NtDll.FILE_FULL_EA_INFORMATION *)b;
ea->NextEntryOffset = 0;
ea->Flags = 0;
ea->EaNameLength = (byte)(s_eaNameString.Length - 1); // Length does not include terminating null character.
ea->EaValueLength = (ushort)transactionContext.Length;
// We could continue to do pointer math here, chose to use Span for convenience to
// make sure we get the other members in the right place.
Span <byte> data = buffer.AsSpan(headerSize);
s_eaNameString.AsSpan().CopyTo(data);
data = data.Slice(s_eaNameString.Length);
transactionContext.AsSpan().CopyTo(data);
(int status, IntPtr handle) = Interop.NtDll.CreateFile(
path: mappedPath.AsSpan(),
rootDirectory: IntPtr.Zero,
createDisposition: dwCreateDisposition,
desiredAccess: nDesiredAccess,
shareAccess: nShareAccess,
fileAttributes: 0,
createOptions: dwCreateOptions,
eaBuffer: b,
eaLength: (uint)fullSize);
retval = status;
hFile = new SafeFileHandle(handle, true);
}
ArrayPool <byte> .Shared.Return(buffer);
}
finally
{
Interop.Kernel32.SetThreadErrorMode(oldMode, out oldMode);
}
switch (retval)
{
case 0:
break;
case Interop.Errors.ERROR_SHARING_VIOLATION:
throw ADP.InvalidOperation(System.SRHelper.GetString(SR.SqlFileStream_FileAlreadyInTransaction));
case Interop.Errors.ERROR_INVALID_PARAMETER:
throw ADP.Argument(System.SRHelper.GetString(SR.SqlFileStream_InvalidParameter));
case Interop.Errors.ERROR_FILE_NOT_FOUND:
{
System.IO.DirectoryNotFoundException e = new System.IO.DirectoryNotFoundException();
ADP.TraceExceptionAsReturnValue(e);
throw e;
}
default:
{
uint error = Interop.NtDll.RtlNtStatusToDosError(retval);
if (error == ERROR_MR_MID_NOT_FOUND)
{
// status code could not be mapped to a Win32 error code
error = (uint)retval;
}
System.ComponentModel.Win32Exception e = new System.ComponentModel.Win32Exception(unchecked ((int)error));
ADP.TraceExceptionAsReturnValue(e);
throw e;
}
}
if (hFile.IsInvalid)
{
System.ComponentModel.Win32Exception e = new System.ComponentModel.Win32Exception(Interop.Errors.ERROR_INVALID_HANDLE);
ADP.TraceExceptionAsReturnValue(e);
throw e;
}
if (Interop.Kernel32.GetFileType(hFile) != Interop.Kernel32.FileTypes.FILE_TYPE_DISK)
{
hFile.Dispose();
throw ADP.Argument(System.SRHelper.GetString(SR.SqlFileStream_PathNotValidDiskResource));
}
// if the user is opening the SQL FileStream in read/write mode, we assume that they want to scan
// through current data and then append new data to the end, so we need to tell SQL Server to preserve
// the existing file contents.
if (access == System.IO.FileAccess.ReadWrite)
{
uint ioControlCode = Interop.Kernel32.CTL_CODE(FILE_DEVICE_FILE_SYSTEM,
IoControlCodeFunctionCode, (byte)Interop.Kernel32.IoControlTransferType.METHOD_BUFFERED,
(byte)Interop.Kernel32.IoControlCodeAccess.FILE_ANY_ACCESS);
if (!Interop.Kernel32.DeviceIoControl(hFile, ioControlCode, IntPtr.Zero, 0, IntPtr.Zero, 0, out uint cbBytesReturned, IntPtr.Zero))
{
System.ComponentModel.Win32Exception e = new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error());
ADP.TraceExceptionAsReturnValue(e);
throw e;
}
}
// now that we've successfully opened a handle on the path and verified that it is a file,
// use the SafeFileHandle to initialize our internal System.IO.FileStream instance
System.Diagnostics.Debug.Assert(_m_fs == null);
_m_fs = new System.IO.FileStream(hFile, access, DefaultBufferSize, ((options & System.IO.FileOptions.Asynchronous) != 0));
}
catch
{
if (hFile != null && !hFile.IsInvalid)
{
hFile.Dispose();
}
throw;
}
}
public int CreateFile(string filename, System.IO.FileAccess access, System.IO.FileShare share, System.IO.FileMode mode, System.IO.FileOptions options, DokanFileInfo info)
{
string webFilename = Normalize(filename);
Console.WriteLine("Open " + webFilename + " " + access);
MemFileContext context = new MemFileContext();
MemFile file;
context.Mode = mode;
context.Access = access;
context.Share = share;
context.Options = options;
info.Context = context;
switch (mode)
{
case FileMode.Append:
if (!memfs.Exists(webFilename))
{
return(-DokanNet.ERROR_FILE_NOT_FOUND);
}
file = memfs.Lookup(webFilename);
break;
case FileMode.Create:
if (memfs.Exists(webFilename))
{
if (!memfs.Delete(webFilename))
{
return(-DokanNet.ERROR_ACCESS_DENIED);
}
}
file = memfs.CreateFile(webFilename);
break;
case FileMode.CreateNew:
if (memfs.Exists(webFilename))
{
return(-DokanNet.ERROR_ALREADY_EXISTS);
}
file = memfs.CreateFile(webFilename);
break;
case FileMode.Open:
if (memfs.Exists(webFilename))
{
file = memfs.Lookup(webFilename);
}
else
{
return(-DokanNet.ERROR_FILE_NOT_FOUND);
}
break;
case FileMode.OpenOrCreate:
if (!memfs.Exists(webFilename))
{
file = memfs.CreateFile(webFilename);
}
else
{
file = memfs.Lookup(webFilename);
}
break;
case FileMode.Truncate:
if (!memfs.Exists(webFilename))
{
return(-DokanNet.ERROR_FILE_NOT_FOUND);
}
if (!memfs.Delete(webFilename))
{
return(-DokanNet.ERROR_ACCESS_DENIED);
}
file = memfs.CreateFile(webFilename, 0);
break;
default:
return(-1);
}
Console.WriteLine("Opened " + webFilename + " " + access + " about to lock");
if (!file.TryLock())
{
Console.WriteLine("NOT NOT NOT " + webFilename + " " + access + " about to lock");
return(DokanNet.ERROR_SHARING_VIOLATION);
}
file.LocallyModified = false;
if (file.LastAccessed.AddMilliseconds(CacheMillis) < DateTime.Now)
{
if (File.Exists(memfs.LocalFilename(webFilename)))
{
File.Delete(memfs.LocalFilename(webFilename));
}
}
return(0);
}