public int CreateFile(string filename, FileAccess access, FileShare share, FileMode mode, FileOptions options, DokanFileInfo info) { Trace.WriteLine(string.Format("CreateFile FILENAME({0}) ACCESS({1}) SHARE({2}) MODE({3})", filename, access, share, mode)); if (mode == FileMode.Create || mode == FileMode.OpenOrCreate || mode == FileMode.CreateNew) { // we want to write a file var fileRef = Extensions.GetFileReference(root, filename.ToFileString()); fileRef.Create(0); return 0; } if (share == FileShare.Delete) { return DeleteFile(filename, info); } if (GetFileInformation(filename, new FileInformation(), new DokanFileInfo(0)) == 0) { return 0; } else { return -DokanNet.ERROR_FILE_NOT_FOUND; } }
public SqlFileStream(string path, byte[] transactionContext, FileAccess access, FileOptions options, long allocationSize) { IntPtr ptr; this.ObjectID = Interlocked.Increment(ref _objectTypeCount); Bid.ScopeEnter(out ptr, "<sc.SqlFileStream.ctor|API> %d# access=%d options=%d path='%ls' ", this.ObjectID, (int) access, (int) options, path); try { if (transactionContext == null) { throw ADP.ArgumentNull("transactionContext"); } if (path == null) { throw ADP.ArgumentNull("path"); } this.m_disposed = false; this.m_fs = null; this.OpenSqlFileStream(path, transactionContext, access, options, allocationSize); this.Name = path; this.TransactionContext = transactionContext; } finally { Bid.ScopeLeave(ref ptr); } }
private SafeFileHandle OpenHandle(FileMode mode, FileShare share, FileOptions options) { // FileStream performs most of the general argument validation. We can assume here that the arguments // are all checked and consistent (e.g. non-null-or-empty path; valid enums in mode, access, share, and options; etc.) // Store the arguments _mode = mode; _options = options; if (_useAsyncIO) _asyncState = new AsyncState(); // Translate the arguments into arguments for an open call. Interop.Sys.OpenFlags openFlags = PreOpenConfigurationFromOptions(mode, _access, options); // FileShare currently ignored // If the file gets created a new, we'll select the permissions for it. Most Unix utilities by default use 666 (read and // write for all), so we do the same (even though this doesn't match Windows, where by default it's possible to write out // a file and then execute it). No matter what we choose, it'll be subject to the umask applied by the system, such that the // actual permissions will typically be less than what we select here. const Interop.Sys.Permissions OpenPermissions = Interop.Sys.Permissions.S_IRUSR | Interop.Sys.Permissions.S_IWUSR | Interop.Sys.Permissions.S_IRGRP | Interop.Sys.Permissions.S_IWGRP | Interop.Sys.Permissions.S_IROTH | Interop.Sys.Permissions.S_IWOTH; // Open the file and store the safe handle. return SafeFileHandle.Open(_path, openFlags, (int)OpenPermissions); }
/// <summary> /// 文件分块写入流 /// </summary> /// <param name="fileName">文件全名</param> /// <param name="fileOption">附加选项</param> public TmphFileBlockStream(string fileName, FileOptions fileOption = FileOptions.None) : base(fileName, File.Exists(fileName) ? FileMode.Open : FileMode.CreateNew, FileShare.Read, fileOption) { fileReader = new FileStream(FileName, FileMode.Open, FileAccess.Read, FileShare.Read, bufferLength, fileOption); waitHandle = wait; }
public DokanError CreateFile(string fileName, DokanNet.FileAccess access, FileShare share, FileMode mode, FileOptions options, FileAttributes attributes, DokanFileInfo info) { info.DeleteOnClose = (options & FileOptions.DeleteOnClose) != 0; //Console.WriteLine("CreateFile: {0}, mode = {1}", fileName, mode); if (fileName == "\\") { return DokanError.ErrorSuccess; } Directory dir = new Directory(Util.GetPathDirectory(fileName)); if (!dir.Exists()) { return DokanError.ErrorPathNotFound; } String name = Util.GetPathFileName(fileName); if (name.Length == 0) { return DokanError.ErrorInvalidName; } if (name.IndexOfAny(Path.GetInvalidFileNameChars()) > -1) { return DokanError.ErrorInvalidName; } // dokan API 要求在目标文件是目录时候,设置 info.IsDirectory = true if (dir.Contains(name) && (dir.GetItemInfo(name).attribute & FileAttributes.Directory) != 0) { info.IsDirectory = true; return DokanError.ErrorSuccess; } try { File f = new File(fileName, mode); f.flagDeleteOnClose = info.DeleteOnClose; info.Context = f; } catch (FileNotFoundException) { return DokanError.ErrorFileNotFound; } catch (IOException) { return DokanError.ErrorAlreadyExists; } catch (NotImplementedException) { return DokanError.ErrorAccessDenied; } catch (Exception) { return DokanError.ErrorError; } return DokanError.ErrorSuccess; }
private void Init(String path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options) { if (path == null) throw new ArgumentNullException("path", SR.ArgumentNull_Path); if (path.Length == 0) throw new ArgumentException(SR.Argument_EmptyPath, "path"); // don't include inheritable in our bounds check for share FileShare tempshare = share & ~FileShare.Inheritable; String badArg = null; if (mode < FileMode.CreateNew || mode > FileMode.Append) badArg = "mode"; else if (access < FileAccess.Read || access > FileAccess.ReadWrite) badArg = "access"; else if (tempshare < FileShare.None || tempshare > (FileShare.ReadWrite | FileShare.Delete)) badArg = "share"; if (badArg != null) throw new ArgumentOutOfRangeException(badArg, SR.ArgumentOutOfRange_Enum); // NOTE: any change to FileOptions enum needs to be matched here in the error validation if (options != FileOptions.None && (options & ~(FileOptions.WriteThrough | FileOptions.Asynchronous | FileOptions.RandomAccess | FileOptions.DeleteOnClose | FileOptions.SequentialScan | FileOptions.Encrypted | (FileOptions)0x20000000 /* NoBuffering */)) != 0) throw new ArgumentOutOfRangeException("options", SR.ArgumentOutOfRange_Enum); if (bufferSize <= 0) throw new ArgumentOutOfRangeException("bufferSize", SR.ArgumentOutOfRange_NeedPosNum); // Write access validation if ((access & FileAccess.Write) == 0) { if (mode == FileMode.Truncate || mode == FileMode.CreateNew || mode == FileMode.Create || mode == FileMode.Append) { // No write access throw new ArgumentException(SR.Format(SR.Argument_InvalidFileModeAndAccessCombo, mode, access)); } } string fullPath = PathHelpers.GetFullPathInternal(path); // Prevent access to your disk drives as raw block devices. if (fullPath.StartsWith("\\\\.\\", StringComparison.Ordinal)) throw new ArgumentException(SR.Arg_DevicesNotSupported); #if !PLATFORM_UNIX // Check for additional invalid characters. Most invalid characters were checked above // in our call to Path.GetFullPath(path); if (HasAdditionalInvalidCharacters(fullPath)) throw new ArgumentException(SR.Argument_InvalidPathChars); if (fullPath.IndexOf(':', 2) != -1) throw new NotSupportedException(SR.Argument_PathFormatNotSupported); #endif if ((access & FileAccess.Read) != 0 && mode == FileMode.Append) throw new ArgumentException(SR.Argument_InvalidAppendMode); this._innerStream = FileSystem.Current.Open(fullPath, mode, access, share, bufferSize, options, this); }
public CreateFileOperation( string path, int bufferSize, FileOptions options, FileSecurity fileSecurity ) { this.path = path; this.bufferSize = bufferSize; this.options = options; this.fileSecurity = fileSecurity; tempFilePath = Path.Combine( Path.GetTempPath(), Path.GetRandomFileName() ); }
public virtual int CreateFile(string filename, FileAccess access, FileShare share, FileMode mode, FileOptions options, DokanFileInfo info) { try { return -1; } catch { return -1; } }
public Stream OpenFile( string path, FileMode fileMode, FileAccess fileAccess, FileShare fileShare, int bufferSize, FileOptions fileOptions) { return new FileStream(path, fileMode, fileAccess, fileShare, bufferSize, fileOptions); }
public int CreateFile(string filename, FileAccess access, FileShare share, FileMode mode, FileOptions options, DokanFileInfo info) { int result = _fileSystem.CreateFile(filename, access, share, mode, options, info); if (this._logging) { Console.WriteLine("CreateFile: " + filename); Console.WriteLine("Result: " + result); } return result; }
public void DeleteOnClose_FileDeletedAfterClose(FileOptions options) { string path = GetTestFilePath(); Assert.False(File.Exists(path)); using (CreateFileStream(path, FileMode.Create, FileAccess.ReadWrite, FileShare.None, 0x1000, options)) { Assert.True(File.Exists(path)); } Assert.False(File.Exists(path)); }
public int CreateFile(string filename, FileAccess access, FileShare share, FileMode mode, FileOptions options, DokanFileInfo info) { Console.WriteLine("Create File : " + filename); var response = MakeComplexRequest(Path + CREATE_FILE_REQUEST_STRING, SecurityElement.Escape(filename), (int)access, (int)share, (int)mode, (int)options, info.ProcessId); if (response.ContainsKey("message")) Console.WriteLine("Create File Message : " + response["message"]); return int.Parse(response["response_code"]); }
private AtomicFileStream(string path, string tempPath, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options) : base(tempPath, mode, access, share, bufferSize, options) { if (path == null) throw new ArgumentNullException("path"); if (tempPath == null) throw new ArgumentNullException("tempPath"); this.path = path; this.tempPath = tempPath; }
private NtStatus Trace(string method, string fileName, DokanFileInfo info, FileAccess access, FileShare share, FileMode mode, FileOptions options, FileAttributes attributes, NtStatus result) { #if TRACE Console.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0}('{1}', {2}, [{3}], [{4}], [{5}], [{6}], [{7}]) -> {8}", method, fileName, ToTrace(info), access, share, mode, options, attributes, result)); #endif return result; }
internal WinRTFileStream(Stream innerStream, StorageFile file, FileAccess access, FileOptions options, FileStream parent) : base(parent) { Debug.Assert(innerStream != null); Debug.Assert(file != null); this._access = access; this._disposed = false; this._file = file; this._innerStream = innerStream; this._options = options; }
private NtStatus Trace(string method, string fileName, DokanFileInfo info, FileAccess access, FileShare share, FileMode mode, FileOptions options, FileAttributes attributes, NtStatus result) { #if TRACE logger.Debug( DokanFormat( $"{method}('{fileName}', {info}, [{access}], [{share}], [{mode}], [{options}], [{attributes}]) -> {result}")); #endif return result; }
private FileStreamCompletionSource _currentOverlappedOwner; // async op currently using the preallocated overlapped private SafeFileHandle OpenHandle(FileMode mode, FileShare share, FileOptions options) { Interop.Kernel32.SECURITY_ATTRIBUTES secAttrs = GetSecAttrs(share); int fAccess = ((_access & FileAccess.Read) == FileAccess.Read ? GENERIC_READ : 0) | ((_access & FileAccess.Write) == FileAccess.Write ? GENERIC_WRITE : 0); // Our Inheritable bit was stolen from Windows, but should be set in // the security attributes class. Don't leave this bit set. share &= ~FileShare.Inheritable; // Must use a valid Win32 constant here... if (mode == FileMode.Append) mode = FileMode.OpenOrCreate; int flagsAndAttributes = (int)options; // For mitigating local elevation of privilege attack through named pipes // make sure we always call CreateFile with SECURITY_ANONYMOUS so that the // named pipe server can't impersonate a high privileged client security context flagsAndAttributes |= (Interop.Kernel32.SecurityOptions.SECURITY_SQOS_PRESENT | Interop.Kernel32.SecurityOptions.SECURITY_ANONYMOUS); // Don't pop up a dialog for reading from an empty floppy drive uint oldMode = Interop.Kernel32.SetErrorMode(Interop.Kernel32.SEM_FAILCRITICALERRORS); try { SafeFileHandle fileHandle = Interop.Kernel32.SafeCreateFile(_path, fAccess, share, ref secAttrs, mode, flagsAndAttributes, IntPtr.Zero); fileHandle.IsAsync = _useAsyncIO; if (fileHandle.IsInvalid) { // Return a meaningful exception with the full path. // NT5 oddity - when trying to open "C:\" as a Win32FileStream, // we usually get ERROR_PATH_NOT_FOUND from the OS. We should // probably be consistent w/ every other directory. int errorCode = Marshal.GetLastWin32Error(); if (errorCode == Interop.Errors.ERROR_PATH_NOT_FOUND && _path.Equals(Directory.InternalGetDirectoryRoot(_path))) errorCode = Interop.Errors.ERROR_ACCESS_DENIED; throw Win32Marshal.GetExceptionForWin32Error(errorCode, _path); } return fileHandle; } finally { Interop.Kernel32.SetErrorMode(oldMode); } }
public NtStatus CreateFile( string filename, FileAccess access, FileShare share, FileMode mode, FileOptions options, FileAttributes attributes, DokanFileInfo info) { if (info.IsDirectory && mode == FileMode.CreateNew) return DokanResult.AccessDenied; return DokanResult.Success; }
public static AtomicFileStream Open(string path, string tempPath, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options) { if (access == FileAccess.Read) throw new ArgumentException("If you're just opening the file for reading, AtomicFileStream won't help you at all"); if (File.Exists(tempPath)) File.Delete(tempPath); if (File.Exists(path) && (mode == FileMode.Append || mode == FileMode.Open || mode == FileMode.OpenOrCreate)) File.Copy(path, tempPath); return new AtomicFileStream(path, tempPath, mode, access, share, bufferSize, options); }
public static FileMap FromFile(string path, FileMapProtect prot, int offset, int length, FileOptions options) { FileStream stream; FileMap map; try { stream = new FileStream(path, FileMode.Open, (prot == FileMapProtect.ReadWrite) ? FileAccess.ReadWrite : FileAccess.Read, FileShare.Read, 8, options); } catch //File is currently in use, but we can copy it to a temp location and read that { string tempPath = Path.GetTempFileName(); File.Copy(path, tempPath, true); stream = new FileStream(tempPath, FileMode.Open, FileAccess.ReadWrite, FileShare.Read, 8, options | FileOptions.DeleteOnClose); } try { map = FromStreamInternal(stream, prot, offset, length); } catch (Exception x) { stream.Dispose(); throw x; } map._path = path; //In case we're using a temp file return map; }
private void Init(String path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options) { if (path == null) throw new ArgumentNullException("path", SR.ArgumentNull_Path); if (path.Length == 0) throw new ArgumentException(SR.Argument_EmptyPath, "path"); // don't include inheritable in our bounds check for share FileShare tempshare = share & ~FileShare.Inheritable; String badArg = null; if (mode < FileMode.CreateNew || mode > FileMode.Append) badArg = "mode"; else if (access < FileAccess.Read || access > FileAccess.ReadWrite) badArg = "access"; else if (tempshare < FileShare.None || tempshare > (FileShare.ReadWrite | FileShare.Delete)) badArg = "share"; if (badArg != null) throw new ArgumentOutOfRangeException(badArg, SR.ArgumentOutOfRange_Enum); // NOTE: any change to FileOptions enum needs to be matched here in the error validation if (options != FileOptions.None && (options & ~(FileOptions.WriteThrough | FileOptions.Asynchronous | FileOptions.RandomAccess | FileOptions.DeleteOnClose | FileOptions.SequentialScan | FileOptions.Encrypted | (FileOptions)0x20000000 /* NoBuffering */)) != 0) throw new ArgumentOutOfRangeException("options", SR.ArgumentOutOfRange_Enum); if (bufferSize <= 0) throw new ArgumentOutOfRangeException("bufferSize", SR.ArgumentOutOfRange_NeedPosNum); // Write access validation if ((access & FileAccess.Write) == 0) { if (mode == FileMode.Truncate || mode == FileMode.CreateNew || mode == FileMode.Create || mode == FileMode.Append) { // No write access, mode and access disagree but flag access since mode comes first throw new ArgumentException(SR.Format(SR.Argument_InvalidFileModeAndAccessCombo, mode, access), "access"); } } string fullPath = PathHelpers.GetFullPathInternal(path); ValidatePath(fullPath, "path"); if ((access & FileAccess.Read) != 0 && mode == FileMode.Append) throw new ArgumentException(SR.Argument_InvalidAppendMode, "access"); this._innerStream = FileSystem.Current.Open(fullPath, mode, access, share, bufferSize, options, this); }
// file apis public int CreateFile(string filename, FileAccess access, FileShare share, FileMode mode, FileOptions options, DokanFileInfo info) { info.IsDirectory = flacFs_.IsDirectory(filename); if (info.IsDirectory) { return 0; } long handle = flacFs_.OpenFile(filename); if (handle != FlacFs.INVALID_HANDLE) { info.Context = handle; return 0; } return -DokanNet.ERROR_FILE_NOT_FOUND; }
public int CreateFile(String filename, FileAccess access, FileShare share, FileMode mode, FileOptions options, DokanFileInfo info) { string path = GetPath(filename); info.Context = count_++; if (File.Exists(path)) { return 0; } else if(Directory.Exists(path)) { info.IsDirectory = true; return 0; } else { return -DokanNet.ERROR_FILE_NOT_FOUND; } }
public FileStream(string file, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options) { try { this.fileOptions = options; this.name = file; this.CheckAccess(mode, access); StorageFile storageFile; switch (mode) { case FileMode.CreateNew: case FileMode.Create: case FileMode.OpenOrCreate: case FileMode.Append: storageFile = FileStream.CreateFile(file, mode, access); break; case FileMode.Open: case FileMode.Truncate: storageFile = FileStream.OpenFile(file, mode, access); break; default: throw new ArgumentException("Unknown file mode"); } IAsyncOperation<IRandomAccessStream> source = storageFile.OpenAsync(FileStream.GetAccessMode(access)); WindowsRuntimeSystemExtensions.AsTask<IRandomAccessStream>(source).Wait(); this.backend = (FileRandomAccessStream)source.GetResults(); if (mode == FileMode.Truncate) { this.backend.Size = 0UL; } else { if (mode != FileMode.Append) return; this.backend.Seek(this.backend.Size); } } catch (Exception ex) { throw FileStream.RethrowException(ex); } }
public IFile CreateFile(string file, FileMode fileMode, FileAccess fileAccess, FileShare fileShare, FileSystemRights fileSystemRights, FileOptions fileOptions, FileSecurity fileSecurity) { using (var tranHandle = GetKtmTransactionHandle()) { int dwFlagsAndAttributes = (int) fileOptions; dwFlagsAndAttributes |= 0x100000; NativeMethods.FileAccess faccess = NativeFileEnums.TranslateFileAccess(fileAccess); NativeMethods.FileShare fshare = NativeFileEnums.TranslateFileShare(fileShare); NativeMethods.FileMode fmode = NativeFileEnums.TranslateFileMode(fileMode); using (SafeFileHandle fileHandle = NativeMethods.CreateFileTransacted(file, faccess, fshare, IntPtr.Zero, fmode, dwFlagsAndAttributes, IntPtr.Zero, tranHandle, IntPtr.Zero, IntPtr.Zero)) { if (fileHandle.IsInvalid) throw new InvalidOperationException(); } return GetFile(file); } }
public void ValidFileOptions(FileOptions option) { byte[] data = new byte[c_DefaultBufferSize]; new Random(1).NextBytes(data); using (FileStream fs = CreateFileStream(GetTestFilePath(), FileMode.Create, FileAccess.ReadWrite, FileShare.Read, c_DefaultBufferSize, option)) { // make sure we can write, seek, and read data with this option set fs.Write(data, 0, data.Length); fs.Position = 0; byte[] tmp = new byte[data.Length]; int totalRead = 0; while (true) { int numRead = fs.Read(tmp, totalRead, tmp.Length - totalRead); Assert.InRange(numRead, 0, tmp.Length); if (numRead == 0) break; totalRead += numRead; } } }
public UnbufferedFileStream(string path, FileMode mode, FileAccess access, FileShare share, FileOptions options, BufferManager bufferManager) { _path = path; _bufferManager = bufferManager; { const FileOptions FileFlagNoBuffering = (FileOptions)0x20000000; _stream = new FileStream(path, mode, access, share, 8, options | FileFlagNoBuffering); } _blockInfo = new BlockInfo(); { _blockInfo.IsUpdated = false; _blockInfo.Position = -1; _blockInfo.Offset = 0; _blockInfo.Count = 0; _blockInfo.Value = _bufferManager.TakeBuffer(SectorSize); } _position = _stream.Position; _length = _stream.Length; }
internal OSFileStreamStrategy(string path, FileMode mode, FileAccess access, FileShare share, FileOptions options, long preallocationSize) { string fullPath = Path.GetFullPath(path); _access = access; _fileHandle = SafeFileHandle.Open(fullPath, mode, access, share, options, preallocationSize); try { if (mode == FileMode.Append && CanSeek) { _appendStart = _filePosition = Length; } else { _appendStart = -1; } } catch { // If anything goes wrong while setting up the stream, make sure we deterministically dispose // of the opened handle. _fileHandle.Dispose(); _fileHandle = null !; throw; } }
public override FileStreamBase Open(string fullPath, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options, FileStream parent) { EnsureBackgroundThread(); return(SynchronousResultOf(OpenAsync(fullPath, mode, access, share, bufferSize, options, parent))); }
/// <summary> /// Create new file stream for <paramref name="targetFileInfo"/>. /// </summary> /// <param name="targetFileInfo">Target file info</param> /// <param name="mode">mode of the stream</param> /// <param name="access">Access permission</param> /// <param name="share">File share type</param> /// <param name="bufferSize">Buffer size</param> /// <param name="options">File options</param> public static FileStream CreateStream(this FileInfo targetFileInfo, FileMode mode, FileAccess access = FileAccess.ReadWrite, FileShare share = FileShare.Read, int bufferSize = StdLookUps.DefaultFileBufferSize, FileOptions options = FileOptions.Asynchronous) { return(new FileStream(targetFileInfo.FullName, mode, access, share, bufferSize, options)); }
public static FileMap FromFile(string path, FileMapProtect prot, uint offset, int length, FileOptions options) { FileStream stream; FileMap map; try { stream = new FileStream(path, FileMode.Open, (prot == FileMapProtect.ReadWrite) ? FileAccess.ReadWrite : FileAccess.Read, FileShare.Read, 8, options); } catch //File is currently in use, but we can copy it to a temp location and read that { string tempPath = Path.GetTempFileName(); File.Copy(path, tempPath, true); stream = new FileStream(tempPath, FileMode.Open, FileAccess.ReadWrite, FileShare.Read, 8, options | FileOptions.DeleteOnClose); } try { map = FromStreamInternal(stream, prot, offset, length); } catch (Exception) { stream.Dispose(); throw; } map._path = path; //In case we're using a temp file stream.Dispose(); return(map); }
public Task <Stream> OpenAsync(AbsolutePath path, FileAccess fileAccess, FileMode fileMode, FileShare share, FileOptions options, int bufferSize) { throw new NotImplementedException(); }
protected virtual FileStream CreateFileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options) { return(new FileStream(path, mode, access, share, bufferSize, options)); }
=> share & ~FileShare.Inheritable; // FileShare.Inheritable is handled in GetObjectAttributes private static FileAttributes GetFileAttributes(FileOptions options) => (options & FileOptions.Encrypted) != 0 ? FileAttributes.Encrypted : 0;
#pragma warning restore IDE0060 private static FileStreamStrategy ChooseStrategyCore(string path, FileMode mode, FileAccess access, FileShare share, FileOptions options, long preallocationSize, UnixFileMode?unixCreateMode) => new UnixFileStreamStrategy(path, mode, access, share, options, preallocationSize, unixCreateMode);
public override NtStatus Open(string fileName, FileAccess access, FileShare share, bool create, bool append, FileOptions options, FileAttributes attributes, DokanFileInfo fileInfo) { return(DokanResult.Success); }
public static FileStream Create(string path, int bufferSize, FileOptions options) => new FileStream(path, FileMode.Create, FileAccess.ReadWrite, FileShare.None, bufferSize, options);
public Stream OpenFile(string path, FileMode fileMode, FileAccess fileAccess, FileShare fileShare, int bufferSize, FileOptions fileOptions) { throw new NotImplementedException(); }
public NtStatus CreateFile(string fileName, FileAccess access, FileShare share, FileMode mode, FileOptions options, FileAttributes attributes, DokanFileInfo info) { var path = GetPath(fileName); bool pathExists = true; bool pathIsDirectory = false; bool readWriteAttributes = (access & DataAccess) == 0; bool readAccess = (access & DataWriteAccess) == 0; try { pathIsDirectory = File.GetAttributes(path).HasFlag(FileAttributes.Directory); } catch (IOException) { pathExists = false; } switch (mode) { case FileMode.Open: if (pathExists) { if (readWriteAttributes || pathIsDirectory) // check if driver only wants to read attributes, security info, or open directory { info.IsDirectory = pathIsDirectory; info.Context = new object(); // must set it to someting if you return DokanError.Success return Trace("CreateFile", fileName, info, access, share, mode, options, attributes, DokanResult.Success); } } else { return Trace("CreateFile", fileName, info, access, share, mode, options, attributes, DokanResult.FileNotFound); } break; case FileMode.CreateNew: if (pathExists) return Trace("CreateFile", fileName, info, access, share, mode, options, attributes, DokanResult.FileExists); break; case FileMode.Truncate: if (!pathExists) return Trace("CreateFile", fileName, info, access, share, mode, options, attributes, DokanResult.FileNotFound); break; default: break; } try { info.Context = new FileStream(path, mode, readAccess ? System.IO.FileAccess.Read : System.IO.FileAccess.ReadWrite, share, 4096, options); } catch (UnauthorizedAccessException) // don't have access rights { return Trace("CreateFile", fileName, info, access, share, mode, options, attributes, DokanResult.AccessDenied); } return Trace("CreateFile", fileName, info, access, share, mode, options, attributes, DokanResult.Success); }
/// <include file='../../../../../../../doc/snippets/Microsoft.Data.SqlTypes/SqlFileStream.xml' path='docs/members[@name="SqlFileStream"]/ctor2/*' /> public SqlFileStream(string path, byte[] transactionContext, FileAccess access, FileOptions options, long allocationSize) { using (TryEventScope.Create(SqlClientEventSource.Log.TryScopeEnterEvent("SqlFileStream.ctor | API | Object Id {0} | Access {1} | Options {2} | Path '{3}'", ObjectID, (int)access, (int)options, path))) { //----------------------------------------------------------------- // 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 Name = path; TransactionContext = transactionContext; } }
public FileStream Create(string path, int bufferSize, FileOptions options) { return(File.Create(path, bufferSize, options)); }
/// <summary> /// Create new stream writer for <paramref name="targetFileInfo"/>. /// </summary> /// <param name="targetFileInfo">Target file info</param> /// <param name="enc">Text encoding to use. If null, then <seealso cref="Encoding.UTF8"/> is used.</param> /// <param name="appendToFile">If true, existing file is appended or new file is created. If false, existing file is /// truncated or new file is created.</param> /// <param name="share">File share type</param> /// <param name="bufferSize">Buffer size</param> /// <param name="options">File options</param> /// <param name="autoFlush">True to enable auto-flushing else false</param> public static StreamWriter CreateStreamWriter(this FileInfo targetFileInfo, Encoding enc = null, bool appendToFile = false, FileShare share = FileShare.Read, int bufferSize = StdLookUps.DefaultFileBufferSize, FileOptions options = FileOptions.Asynchronous, bool autoFlush = false) { return(targetFileInfo.CreateStream(appendToFile ? FileMode.Append : FileMode.Create, FileAccess.ReadWrite, share, bufferSize, options).CreateWriter(enc, bufferSize, true, autoFlush)); }
public override NtStatus Create(string fileName, FileAccess access, FileShare share, bool overwrite, FileOptions options, FileAttributes attributes, DokanFileInfo info) { return(DokanResult.Success); }
private static DesiredAccess GetDesiredAccess(FileAccess access, FileMode fileMode, FileOptions options) { DesiredAccess result = DesiredAccess.FILE_READ_ATTRIBUTES | DesiredAccess.SYNCHRONIZE; // default values used by CreateFileW if ((access & FileAccess.Read) != 0) { result |= DesiredAccess.FILE_GENERIC_READ; } if ((access & FileAccess.Write) != 0) { result |= DesiredAccess.FILE_GENERIC_WRITE; } if (fileMode == FileMode.Append) { result |= DesiredAccess.FILE_APPEND_DATA; } if ((options & FileOptions.DeleteOnClose) != 0) { result |= DesiredAccess.DELETE; // required by FILE_DELETE_ON_CLOSE } return(result); }
/// <summary>Translates the FileMode, FileAccess, and FileOptions values into flags to be passed when opening the file.</summary> /// <param name="mode">The FileMode provided to the stream's constructor.</param> /// <param name="access">The FileAccess provided to the stream's constructor</param> /// <param name="options">The FileOptions provided to the stream's constructor</param> /// <returns>The flags value to be passed to the open system call.</returns> private static Interop.Sys.OpenFlags PreOpenConfigurationFromOptions(FileMode mode, FileAccess access, FileOptions options) { // Translate FileMode. Most of the values map cleanly to one or more options for open. Interop.Sys.OpenFlags flags = default(Interop.Sys.OpenFlags); switch (mode) { default: case FileMode.Open: // Open maps to the default behavior for open(...). No flags needed. break; case FileMode.Append: // Append is the same as OpenOrCreate, except that we'll also separately jump to the end later case FileMode.OpenOrCreate: flags |= Interop.Sys.OpenFlags.O_CREAT; break; case FileMode.Create: flags |= (Interop.Sys.OpenFlags.O_CREAT | Interop.Sys.OpenFlags.O_TRUNC); break; case FileMode.CreateNew: flags |= (Interop.Sys.OpenFlags.O_CREAT | Interop.Sys.OpenFlags.O_EXCL); break; case FileMode.Truncate: flags |= Interop.Sys.OpenFlags.O_TRUNC; break; } // Translate FileAccess. All possible values map cleanly to corresponding values for open. switch (access) { case FileAccess.Read: flags |= Interop.Sys.OpenFlags.O_RDONLY; break; case FileAccess.ReadWrite: flags |= Interop.Sys.OpenFlags.O_RDWR; break; case FileAccess.Write: flags |= Interop.Sys.OpenFlags.O_WRONLY; break; } // Translate some FileOptions; some just aren't supported, and others will be handled after calling open. switch (options) { case FileOptions.Asynchronous: // Handled in ctor, setting _useAsync and SafeFileHandle.IsAsync to true case FileOptions.DeleteOnClose: // DeleteOnClose doesn't have a Unix equivalent, but we approximate it in Dispose case FileOptions.Encrypted: // Encrypted does not have an equivalent on Unix and is ignored. case FileOptions.RandomAccess: // Implemented after open if posix_fadvise is available case FileOptions.SequentialScan: // Implemented after open if posix_fadvise is available break; case FileOptions.WriteThrough: flags |= Interop.Sys.OpenFlags.O_SYNC; break; } return(flags); }
/// <summary>Initializes a stream for reading or writing a Unix file.</summary> /// <param name="path">The path to the file.</param> /// <param name="mode">How the file should be opened.</param> /// <param name="access">Whether the file will be read, written, or both.</param> /// <param name="share">What other access to the file should be allowed. This is currently ignored.</param> /// <param name="bufferSize">The size of the buffer to use when buffering.</param> /// <param name="options">Additional options for working with the file.</param> internal UnixFileStream(String path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options, FileStream parent) : base(parent) { // FileStream performs most of the general argument validation. We can assume here that the arguments // are all checked and consistent (e.g. non-null-or-empty path; valid enums in mode, access, share, and options; etc.) // Store the arguments _path = path; _access = access; _mode = mode; _options = options; _bufferLength = bufferSize; _useAsyncIO = (options & FileOptions.Asynchronous) != 0; // Translate the arguments into arguments for an open call Interop.Sys.OpenFlags openFlags = PreOpenConfigurationFromOptions(mode, access, options); // FileShare currently ignored Interop.libc.Permissions openPermissions = Interop.libc.Permissions.S_IRWXU; // creator has read/write/execute permissions; no permissions for anyone else // Open the file and store the safe handle. Subsequent code in this method expects the safe handle to be initialized. _fileHandle = SafeFileHandle.Open(path, openFlags, (int)openPermissions); _fileHandle.IsAsync = _useAsyncIO; // Lock the file if requested via FileShare. This is only advisory locking. FileShare.None implies an exclusive // lock on the file and all other modes use a shared lock. While this is not as granular as Windows, not mandatory, // and not atomic with file opening, it's better than nothing. try { Interop.libc.LockOperations lockOperation = (share == FileShare.None) ? Interop.libc.LockOperations.LOCK_EX : Interop.libc.LockOperations.LOCK_SH; SysCall <Interop.libc.LockOperations, int>((fd, op, _) => Interop.libc.flock(fd, op), lockOperation | Interop.libc.LockOperations.LOCK_NB); } catch { _fileHandle.Dispose(); throw; } // Perform additional configurations on the stream based on the provided FileOptions PostOpenConfigureStreamFromOptions(); // Jump to the end of the file if opened as Append. if (_mode == FileMode.Append) { _appendStart = SeekCore(0, SeekOrigin.End); } }
DokanError IDokanOperations.CreateFile(string fileName, FileAccess access, FileShare share, FileMode mode, FileOptions options, FileAttributes attributes, DokanFileInfo info) { if (fileName.EndsWith("desktop.ini", StringComparison.OrdinalIgnoreCase) || fileName.EndsWith("autorun.inf", StringComparison.OrdinalIgnoreCase)) //.... { return(DokanError.ErrorFileNotFound); } string path = GetUnixPath(fileName); // var sftpFileAttributes = GetAttributes(path); var sftpFileAttributes = _cache.Get(path) as SftpFileAttributes; if (sftpFileAttributes == null) { Log("cache miss"); sftpFileAttributes = GetAttributes(path); if (sftpFileAttributes != null) { _cache.Add(path, sftpFileAttributes, DateTimeOffset.UtcNow.AddSeconds(_attributeCacheTimeout)); } } Log("Open| Name:{0},\n Mode:{1},\n Share{2},\n Disp:{3},\n Flags{4},\n Attr:{5}\n", fileName, access, share, mode, options, attributes); // Check if FILE_FLAG_DELETE_ON_CLOSE is set if ((options &= FileOptions.DeleteOnClose) != 0) { _deleteOnCloseFiles.Add(fileName); } switch (mode) { case FileMode.Open: if (sftpFileAttributes != null) { if (((uint)access & 0xe0000027) == 0 || sftpFileAttributes.IsDirectory) //check if only wants to read attributes,security info or open directory { Log("JustInfo:{0},{1}", fileName, sftpFileAttributes.IsDirectory); info.IsDirectory = sftpFileAttributes.IsDirectory; info.Context = new SftpContext(sftpFileAttributes); return(DokanError.ErrorSuccess); } } else { return(DokanError.ErrorFileNotFound); } break; case FileMode.CreateNew: if (sftpFileAttributes != null) { return(DokanError.ErrorAlreadyExists); } InvalidateParentCache(fileName); // cache invalidate break; case FileMode.Truncate: if (sftpFileAttributes == null) { return(DokanError.ErrorFileNotFound); } InvalidateParentCache(fileName); _cache.Remove(path); break; default: InvalidateParentCache(fileName); break; } Log("NotJustInfo:{0}-{1}", info.Context, mode); try { info.Context = new SftpContext(_sftpSession, path, mode, ((ulong)access & 0x40010006) == 0 ? System.IO.FileAccess.Read : System.IO.FileAccess.ReadWrite, sftpFileAttributes); } catch (SshException) // Don't have access rights or try to read broken symlink { return(DokanError.ErrorAccessDenied); } return(DokanError.ErrorSuccess); }
/// <summary> /// Create new JSON writer for <paramref name="targetFileInfo"/> with custom properties. /// </summary> /// <param name="targetFileInfo">Target file info</param> /// <param name="enc">Text encoding to use. If null, then <seealso cref="Encoding.UTF8"/> is used.</param> /// <param name="appendToFile">If true, existing file is appended or new file is created. If false, existing file is /// truncated or new file is created.</param> /// <param name="share">File share type</param> /// <param name="bufferSize">Buffer size</param> /// <param name="options">File options</param> /// <param name="autoFlush">True to enable auto-flushing else false</param> public static JsonTextWriter CreateJsonWriter(this FileInfo targetFileInfo, Encoding enc = null, bool appendToFile = false, FileShare share = FileShare.Read, int bufferSize = StdLookUps.DefaultFileBufferSize, FileOptions options = FileOptions.Asynchronous, bool autoFlush = false) { return(targetFileInfo.CreateStreamWriter(enc, appendToFile, share, bufferSize, options, autoFlush) .CreateJsonWriter()); }
public override NtStatus CreateFile(string fileName, DokanNet.FileAccess access, FileShare share, FileMode mode, FileOptions options, FileAttributes attributes, IDokanFileInfo info) { if (IsBadName(fileName)) { return(NtStatus.ObjectNameInvalid); } if ((access & ModificationAttributes) != 0) { return(NtStatus.DiskFull); } var item = GetFile(fileName); if (item == null) { return(DokanResult.FileNotFound); } if (item.Info.Key != null && !item.Info.IsDirectory) { if ((access & (DokanNet.FileAccess.ReadData | DokanNet.FileAccess.GenericRead)) != 0) { LastAccessed = DateTime.Now; Console.WriteLine("SharpCompressFs ReadData: " + fileName); lock (this) { var entry = extractor.Entries.First(a => a.Key.EndsWith(fileName)); if (((SharpCompress.Common.Rar.Headers.FileHeader)entry.RarParts.First().FileHeader).IsStored) { // stored info.Context = new RarStoreStream(entry); } else { // 5mb if (entry.CompressedSize <= 1024 * 1024 * 5) { info.Context = new MemoryStream(); entry.OpenEntryStream().CopyTo((MemoryStream)info.Context); return(NtStatus.Success); } //info.Context = new MemoryStream(entry.OpenEntryStream()); return(NtStatus.AccessDenied); } } } return(NtStatus.Success); } else { info.IsDirectory = true; return(NtStatus.Success); } }
private SafeFileHandle OpenHandle(FileMode mode, FileShare share, FileOptions options) { throw new NotImplementedException(); }
internal static void ValidateArguments(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options, long preallocationSize) { if (path == null) { throw new ArgumentNullException(nameof(path), SR.ArgumentNull_Path); } else if (path.Length == 0) { throw new ArgumentException(SR.Argument_EmptyPath, nameof(path)); } // don't include inheritable in our bounds check for share FileShare tempshare = share & ~FileShare.Inheritable; string? badArg = null; if (mode < FileMode.CreateNew || mode > FileMode.Append) { badArg = nameof(mode); } else if (access < FileAccess.Read || access > FileAccess.ReadWrite) { badArg = nameof(access); } else if (tempshare < FileShare.None || tempshare > (FileShare.ReadWrite | FileShare.Delete)) { badArg = nameof(share); } if (badArg != null) { throw new ArgumentOutOfRangeException(badArg, SR.ArgumentOutOfRange_Enum); } // NOTE: any change to FileOptions enum needs to be matched here in the error validation if (options != FileOptions.None && (options & ~(FileOptions.WriteThrough | FileOptions.Asynchronous | FileOptions.RandomAccess | FileOptions.DeleteOnClose | FileOptions.SequentialScan | FileOptions.Encrypted | (FileOptions)0x20000000 /* NoBuffering */)) != 0) { throw new ArgumentOutOfRangeException(nameof(options), SR.ArgumentOutOfRange_Enum); } else if (bufferSize < 0) { ThrowHelper.ThrowArgumentOutOfRangeException_NeedNonNegNum(nameof(bufferSize)); } else if (preallocationSize < 0) { ThrowHelper.ThrowArgumentOutOfRangeException_NeedNonNegNum(nameof(preallocationSize)); } // Write access validation if ((access & FileAccess.Write) == 0) { if (mode == FileMode.Truncate || mode == FileMode.CreateNew || mode == FileMode.Create || mode == FileMode.Append) { // No write access, mode and access disagree but flag access since mode comes first throw new ArgumentException(SR.Format(SR.Argument_InvalidFileModeAndAccessCombo, mode, access), nameof(access)); } } if ((access & FileAccess.Read) != 0 && mode == FileMode.Append) { throw new ArgumentException(SR.Argument_InvalidAppendMode, nameof(access)); } if (preallocationSize > 0) { ValidateArgumentsForPreallocation(mode, access); } SerializationGuard(access); }
private async Task <FileStreamBase> OpenAsync(string fullPath, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options, FileStream parent) { // When trying to open the root directory, we need to throw an Access Denied if (PathInternal.GetRootLength(fullPath) == fullPath.Length) { throw Win32Marshal.GetExceptionForWin32Error(Interop.mincore.Errors.ERROR_ACCESS_DENIED, fullPath); } // Win32 CreateFile returns ERROR_PATH_NOT_FOUND when given a path that ends with '\' if (PathHelpers.EndsInDirectorySeparator(fullPath)) { throw Win32Marshal.GetExceptionForWin32Error(Interop.mincore.Errors.ERROR_PATH_NOT_FOUND, fullPath); } StorageFile file = null; // FileMode if (mode == FileMode.Open || mode == FileMode.Truncate) { file = await StorageFile.GetFileFromPathAsync(fullPath).TranslateWinRTTask(fullPath); } else { CreationCollisionOption collisionOptions; switch (mode) { case FileMode.Create: collisionOptions = CreationCollisionOption.ReplaceExisting; break; case FileMode.CreateNew: collisionOptions = CreationCollisionOption.FailIfExists; break; case FileMode.Append: case FileMode.OpenOrCreate: default: collisionOptions = CreationCollisionOption.OpenIfExists; break; } string directoryPath, fileName; PathHelpers.SplitDirectoryFile(fullPath, out directoryPath, out fileName); StorageFolder directory = await StorageFolder.GetFolderFromPathAsync(directoryPath).TranslateWinRTTask(directoryPath, isDirectory: true); file = await directory.CreateFileAsync(fileName, collisionOptions).TranslateWinRTTask(fullPath); } // FileAccess: WinRT doesn't support FileAccessMode.Write so we upgrade to ReadWrite FileAccessMode accessMode = ((access & FileAccess.Write) != 0) ? FileAccessMode.ReadWrite : FileAccessMode.Read; // FileShare: cannot translate StorageFile uses a different sharing model (oplocks) that is controlled via FileAccessMode // FileOptions: ignore most values of FileOptions as they are hints and are not supported by WinRT. // FileOptions.Encrypted is not a hint, and not supported by WinRT, but there is precedent for ignoring this (FAT). // FileOptions.DeleteOnClose should result in an UnauthorizedAccessException when // opening a file that can only be read, but we cannot safely reproduce that behavior // in WinRT without actually deleting the file. // Instead the failure will occur in the finalizer for WinRTFileStream and be ignored. // open our stream Stream stream = (await file.OpenAsync(accessMode).TranslateWinRTTask(fullPath)).AsStream(bufferSize); if (mode == FileMode.Append) { // seek to end. stream.Seek(0, SeekOrigin.End); } else if (mode == FileMode.Truncate) { // truncate stream to 0 stream.SetLength(0); } return(new WinRTFileStream(stream, file, access, options, parent)); }
public NtStatus CreateFile(string fileName, FileAccess access, FileShare share, FileMode mode, FileOptions options, FileAttributes attributes, DokanFileInfo info) { if (info == null) { throw new ArgumentNullException(nameof(info)); } // HACK: Fix for Bug in Dokany related to a missing trailing slash for directory names if (string.IsNullOrEmpty(fileName)) { fileName = @"\"; } // HACK: Fix for Bug in Dokany related to a call to CreateFile with a fileName of '\*' else if (fileName == @"\*" && access == FileAccess.ReadAttributes) { return(Trace(nameof(CreateFile), fileName, info, access, share, mode, options, attributes, DokanResult.Success)); } if (fileName == @"\") { info.IsDirectory = true; return(Trace(nameof(CreateFile), fileName, info, access, share, mode, options, attributes, DokanResult.Success)); } fileName = fileName.TrimEnd(Path.DirectorySeparatorChar); var parent = GetItem(Path.GetDirectoryName(fileName)) as CloudDirectoryNode; if (parent == null) { return(Trace(nameof(CreateFile), fileName, info, access, share, mode, options, attributes, DokanResult.PathNotFound)); } var itemName = Path.GetFileName(fileName); var item = parent.GetChildItemByName(drive, itemName); var fileItem = default(CloudFileNode); switch (mode) { case FileMode.Create: fileItem = item as CloudFileNode; if (fileItem != null) { fileItem.Truncate(drive); } else { fileItem = parent.NewFileItem(drive, itemName); } info.Context = new StreamContext(fileItem, FileAccess.WriteData); return(Trace(nameof(CreateFile), fileName, info, access, share, mode, options, attributes, DokanResult.Success)); case FileMode.Open: fileItem = item as CloudFileNode; if (fileItem != null) { if (access.HasFlag(FileAccess.ReadData)) { info.Context = new StreamContext(fileItem, FileAccess.ReadData); } else if (access.HasFlag(FileAccess.WriteData)) { info.Context = new StreamContext(fileItem, FileAccess.WriteData); } else if (access.HasFlag(FileAccess.Delete)) { info.Context = new StreamContext(fileItem, FileAccess.Delete); } else if (!access.HasFlag(FileAccess.ReadAttributes)) { return(Trace(nameof(CreateFile), fileName, info, access, share, mode, options, attributes, DokanResult.NotImplemented)); } } else { info.IsDirectory = item != null; } return(Trace(nameof(CreateFile), fileName, info, access, share, mode, options, attributes, item != null ? DokanResult.Success : DokanResult.FileNotFound)); case FileMode.OpenOrCreate: fileItem = item as CloudFileNode ?? parent.NewFileItem(drive, itemName); if (access.HasFlag(FileAccess.ReadData) && !access.HasFlag(FileAccess.WriteData)) { info.Context = new StreamContext(fileItem, FileAccess.ReadData); } else { info.Context = new StreamContext(fileItem, FileAccess.WriteData); } return(Trace(nameof(CreateFile), fileName, info, access, share, mode, options, attributes, DokanResult.Success)); case FileMode.CreateNew: if (item != null) { return(Trace(nameof(CreateFile), fileName, info, access, share, mode, options, attributes, info.IsDirectory ? DokanResult.AlreadyExists : DokanResult.FileExists)); } if (info.IsDirectory) { parent.NewDirectoryItem(drive, itemName); } else { fileItem = parent.NewFileItem(drive, itemName); info.Context = new StreamContext(fileItem, FileAccess.WriteData); } return(Trace(nameof(CreateFile), fileName, info, access, share, mode, options, attributes, DokanResult.Success)); case FileMode.Append: return(Trace(nameof(CreateFile), fileName, info, access, share, mode, options, attributes, DokanResult.NotImplemented)); case FileMode.Truncate: //fileItem = item as CloudFileNode; //if (fileItem == null) // return Trace(nameof(CreateFile), fileName, info, access, share, mode, options, attributes, DokanResult.FileNotFound); //fileItem.Truncate(drive); //info.Context = new StreamContext(fileItem, FileAccess.WriteData); //return Trace(nameof(CreateFile), fileName, info, access, share, mode, options, attributes, DokanResult.Success); return(Trace(nameof(CreateFile), fileName, info, access, share, mode, options, attributes, DokanResult.NotImplemented)); default: return(Trace(nameof(CreateFile), fileName, info, access, share, mode, options, attributes, DokanResult.NotImplemented)); } }
public static void SetFileOptions(FileOptions options) { fileOptions = options; }
internal static unsafe (uint status, IntPtr handle) NtCreateFile(ReadOnlySpan <char> path, FileMode mode, FileAccess access, FileShare share, FileOptions options, long preallocationSize) { // For mitigating local elevation of privilege attack through named pipes // make sure we always call NtCreateFile with SECURITY_ANONYMOUS so that the // named pipe server can't impersonate a high privileged client security context SECURITY_QUALITY_OF_SERVICE securityQualityOfService = new SECURITY_QUALITY_OF_SERVICE( ImpersonationLevel.Anonymous, // SECURITY_ANONYMOUS ContextTrackingMode.Static, effectiveOnly: false); return(CreateFile( path: path, rootDirectory: IntPtr.Zero, createDisposition: GetCreateDisposition(mode), desiredAccess: GetDesiredAccess(access, mode, options), shareAccess: GetShareAccess(share), fileAttributes: GetFileAttributes(options), createOptions: GetCreateOptions(options), objectAttributes: GetObjectAttributes(share), preallocationSize: &preallocationSize, securityQualityOfService: &securityQualityOfService)); }
internal static FileStreamStrategy ChooseStrategy(FileStream fileStream, string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options, long preallocationSize) { FileStreamStrategy strategy = EnableBufferingIfNeeded(ChooseStrategyCore(path, mode, access, share, options, preallocationSize), bufferSize); return(WrapIfDerivedType(fileStream, strategy)); }
/// <summary>Initializes a stream for reading or writing a Unix file.</summary> /// <param name="path">The path to the file.</param> /// <param name="mode">How the file should be opened.</param> /// <param name="access">Whether the file will be read, written, or both.</param> /// <param name="share">What other access to the file should be allowed. This is currently ignored.</param> /// <param name="bufferSize">The size of the buffer to use when buffering.</param> /// <param name="options">Additional options for working with the file.</param> internal UnixFileStream(String path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options, FileStream parent) : base(parent) { // FileStream performs most of the general argument validation. We can assume here that the arguments // are all checked and consistent (e.g. non-null-or-empty path; valid enums in mode, access, share, and options; etc.) // Store the arguments _path = path; _access = access; _mode = mode; _options = options; _bufferLength = bufferSize; if ((options & FileOptions.Asynchronous) != 0) { _useAsyncIO = true; _asyncState = new AsyncState(); } // Translate the arguments into arguments for an open call. Interop.Sys.OpenFlags openFlags = PreOpenConfigurationFromOptions(mode, access, options); // FileShare currently ignored // If the file gets created a new, we'll select the permissions for it. Most utilities by default use 666 (read and // write for all). However, on Windows it's possible to write out a file and then execute it. To maintain that similarity, // we use 766, so that in addition the user has execute privileges. No matter what we choose, it'll be subject to the umask // applied by the system, such that the actual permissions will typically be less than what we select here. const Interop.Sys.Permissions openPermissions = Interop.Sys.Permissions.S_IRWXU | Interop.Sys.Permissions.S_IRGRP | Interop.Sys.Permissions.S_IWGRP | Interop.Sys.Permissions.S_IROTH | Interop.Sys.Permissions.S_IWOTH; // Open the file and store the safe handle. Subsequent code in this method expects the safe handle to be initialized. _fileHandle = SafeFileHandle.Open(path, openFlags, (int)openPermissions); try { _fileHandle.IsAsync = _useAsyncIO; // Lock the file if requested via FileShare. This is only advisory locking. FileShare.None implies an exclusive // lock on the file and all other modes use a shared lock. While this is not as granular as Windows, not mandatory, // and not atomic with file opening, it's better than nothing. Some kinds of files, e.g. FIFOs, don't support // locking on some platforms, e.g. OSX, and so if flock returns ENOTSUP, we similarly treat it as a hint and ignore it, // as we don't want to entirely prevent usage of a particular file simply because locking isn't supported. Interop.Sys.LockOperations lockOperation = (share == FileShare.None) ? Interop.Sys.LockOperations.LOCK_EX : Interop.Sys.LockOperations.LOCK_SH; CheckFileCall(Interop.Sys.FLock(_fileHandle, lockOperation | Interop.Sys.LockOperations.LOCK_NB), ignoreNotSupported: true); // These provide hints around how the file will be accessed. Specifying both RandomAccess // and Sequential together doesn't make sense as they are two competing options on the same spectrum, // so if both are specified, we prefer RandomAccess (behavior on Windows is unspecified if both are provided). Interop.Sys.FileAdvice fadv = (_options & FileOptions.RandomAccess) != 0 ? Interop.Sys.FileAdvice.POSIX_FADV_RANDOM : (_options & FileOptions.SequentialScan) != 0 ? Interop.Sys.FileAdvice.POSIX_FADV_SEQUENTIAL : 0; if (fadv != 0) { CheckFileCall(Interop.Sys.PosixFAdvise(_fileHandle, 0, 0, fadv), ignoreNotSupported: true); // just a hint. } // Jump to the end of the file if opened as Append. if (_mode == FileMode.Append) { _appendStart = SeekCore(0, SeekOrigin.End); } } catch { // If anything goes wrong while setting up the stream, make sure we deterministically dispose // of the opened handle. _fileHandle.Dispose(); _fileHandle = null; throw; } }
public static NativeFileOptions ToNative(this FileOptions fileOptions) { return((NativeFileOptions)(uint)fileOptions); }
public static FileStream Create(String path, int bufferSize, FileOptions options) { return new FileStream(path, FileMode.Create, FileAccess.ReadWrite, FileShare.None, bufferSize, options); }
private NtStatus Trace(string method, string fileName, DokanFileInfo info, FileAccess access, FileShare share, FileMode mode, FileOptions options, FileAttributes attributes, NtStatus result) { logger?.Trace($"{System.Threading.Thread.CurrentThread.ManagedThreadId:D2} / {drive.DisplayRoot} {method}({fileName}, {info.ToTrace()}, [{access}], [{share}], [{mode}], [{options}], [{attributes}]) -> {result}".ToString(CultureInfo.CurrentCulture)); return(result); }