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; }
public int CreateFile( string filename, System.IO.FileAccess access, System.IO.FileShare share, System.IO.FileMode mode, System.IO.FileOptions options, DokanFileInfo info) { Trace.WriteLine(string.Format("CreateFile {0}", filename)); if (mode == FileMode.CreateNew) { var blob = this.GetBlob(filename, false); blobsWriting.TryAdd(filename, blob.OpenWrite()); return(0); } if (GetFileInformation(filename, new FileInformation(), new DokanFileInfo(0)) == 0) { return(0); } else { return(-DokanNet.ERROR_FILE_NOT_FOUND); } }
public static IO.FileStream Open(string filepath, IO.FileMode mode, IO.FileAccess access, IO.FileShare share) { //opened in the specified mode , access and share IO.FileStream fs = null; uint umode = GetMode(mode); uint uaccess = GetAccess(access); uint ushare = GetShare(share); if (mode == IO.FileMode.Append) { uaccess = PathInternal.DllImport.FILE_APPEND_DATA; } SafeFileHandle sh = PathInternal.DllImport.CreateFileW(PathInternal.ConvertToUnicodePath(filepath), uaccess, ushare, IntPtr.Zero, umode, PathInternal.DllImport.FILE_ATTRIBUTE_NORMAL, IntPtr.Zero); int iError = Marshal.GetLastWin32Error(); if ((iError > 0 && !(mode == IO.FileMode.Append && iError != PathInternal.DllImport.ERROR_ALREADY_EXISTS)) || sh.IsInvalid) { throw new Exception("Error opening file Win32 Error:" + iError); } else { fs = new IO.FileStream(sh, access); } // if opened in append mode if (mode == IO.FileMode.Append) { if (!sh.IsInvalid) { PathInternal.DllImport.SetFilePointer(sh, 0, IntPtr.Zero, PathInternal.DllImport.FILE_END); } } return(fs); }
void ValidatePermission(FA mode) { if ((AccessPermissions & mode) == 0) { throw new NotSupportedException("Stream permissions do not support the requested streaming mode"); } }
public static SafeFileHandle CreateFile(String fileName, System.IO.FileAccess fileAccess, System.IO.FileShare fileShare, System.IO.FileMode fileMode) { String prefix = @"\\?\"; String formattedName = fileName; if (!fileName.StartsWith(prefix)) { formattedName = prefix + fileName; } int fileNameIndex = formattedName.LastIndexOf(System.IO.Path.DirectorySeparatorChar); if (fileNameIndex >= 0) { String dirName = formattedName.Substring(0, fileNameIndex); CreateDir(dirName); } SafeFileHandle fileHandle = CreateFile(formattedName, fileAccess, fileShare, null, fileMode, 0, IntPtr.Zero); if (fileHandle.IsInvalid) { int lastWin32Error = Marshal.GetLastWin32Error(); throw new Win32Exception(lastWin32Error); } return(fileHandle); }
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); }
public static extern SafeFileHandle CreateFile( string lpFileName, [MarshalAs(UnmanagedType.U4)] System.IO.FileAccess dwDesiredAccess, [MarshalAs(UnmanagedType.U4)] System.IO.FileShare dwShareMode, IntPtr lpSecurityAttributes, [MarshalAs(UnmanagedType.U4)] FileMode dwCreationDisposition, [MarshalAs(UnmanagedType.U4)] System.IO.FileAttributes dwFlagsAndAttributes, IntPtr hTemplateFile);
public int CreateFile(string filename, System.IO.FileAccess access, FileShare share, FileMode mode, FileOptions options, DokanFileInfo info) { string f = Map(filename); //if(access == FileAccess.ReadWrite) //File.Create(filename, 256, options); return(0); }
public HttpNetworkStream(DirectionType direction, Socket socket, System.IO.FileAccess fileAccess, bool ownsSocket) { Direction = direction; _socket = socket; _stream = new PrependableNetworkStream(socket, fileAccess, ownsSocket); _unknownContentLength = true; }
public File OpenFile(string path, FileMode mode, FileAccess access) { // Resolve the OpenOrCreate file mode. if (mode == FileMode.OpenOrCreate) { mode = FileExists(path) ? FileMode.Open : FileMode.Create; } // Convert the file mode and access to the System.IO types. IO.FileMode fileMode = ConvertMode(mode); IO.FileAccess fileAccess = ConvertAccess(access); // Attempt to open the stream. IO.Stream stream; try { stream = new IO.FileStream(path, fileMode, fileAccess); } catch (NotSupportedException) { throw new IOException("Path refers to a non-file device"); } catch (IO.FileNotFoundException) { throw new FileNotFoundException("File not found"); } catch (IO.DirectoryNotFoundException) { throw new DirectoryNotFoundException("Invalid path"); } catch (IO.IOException) { throw new IOException("Generic IO exception"); } catch (System.Security.SecurityException) { throw new SecurityException("No permission"); } catch (UnauthorizedAccessException) { throw new SecurityException("Requested access denied"); } // Build the file info. FileInfo fileInfo; if (mode == FileMode.Open || (mode == FileMode.Append && FileExists(path))) { fileInfo = GetFileInfo(path); } else { fileInfo = CreateFileInfo(path); } return(new File(fileInfo, stream)); }
public SqlFileStream ( string path, byte[] transactionContext, System.IO.FileAccess access ) : this(path, transactionContext, access, System.IO.FileOptions.None, 0) { }
public HttpNetworkStream(DirectionType direction, ulong contentLength, byte[] prependToStream, Socket socket, System.IO.FileAccess fileAccess, bool ownsSocket) { Direction = direction; _contentLength = contentLength; _socket = socket; _stream = new PrependableNetworkStream(socket, fileAccess, ownsSocket, prependToStream); _unknownContentLength = false; }
public FATXFileStream(int DeviceIndex, System.IO.FileAccess fa, File file) { xFile = file; // Set our position to the beginning of the file long off = VariousFunctions.GetBlockOffset(xFile.BlocksOccupied[0], xFile); Underlying = new FileStream(VariousFunctions.CreateHandle(DeviceIndex), fa); //Underlying.Position = off; Position = 0; }
/// <summary> /// Initializes a new instance of the <see cref="IsolatedStorageFileStream"/> class giving access to the file designated by path, /// in the specified mode, with the specified file access, using the file sharing mode specified by share, /// and in the context of the <see cref="IsolatedStorageFile"/> specified by isf. /// </summary> /// <param name="path">The relative path of the file within isolated storage.</param> /// <param name="mode">One of the <see cref="FileMode"/> values.</param> /// <param name="access">A bitwise combination of the <see cref="FileAccess"/> values.</param> /// <param name="share">A bitwise combination of the <see cref="FileShare"/> values.</param> /// <param name="isf">The <see cref="IsolatedStorageFile"/> in which to open the <see cref="IsolatedStorageFileStream"/>.</param> public IsolatedStorageFileStream(string path, System.IO.FileMode mode, System.IO.FileAccess access, System.IO.FileShare share, IsolatedStorage.IsolatedStorageFile isf) : base(Path.Combine(isf.BasePath, path), mode, access, share) { //also set the hidden attribute (just in case) System.IO.FileInfo fi = new System.IO.FileInfo(System.IO.Path.Combine(isf.BasePath, path)); fi.Attributes |= System.IO.FileAttributes.Hidden; _isolatedStorageFile = isf; }
public static IntPtr CreateFile(string path, System.IO.FileMode mode, System.IO.FileAccess access, System.IO.FileShare share) { SafeFileHandle fileHandle = CreateFileW(path, getAccessFromAccess(access), getShareFromShare(share), IntPtr.Zero, getDispositionFromMode(mode), 0, IntPtr.Zero); int lastWin32Error = Marshal.GetLastWin32Error(); if (fileHandle.IsInvalid) { throw new System.ComponentModel.Win32Exception(lastWin32Error); } return(fileHandle.DangerousGetHandle()); }
/// <summary>Saves the stream's cursor so a new one can be specified, but then later restored to the saved cursor, via <see cref="Dispose()"/></summary> /// <param name="stream">The underlying stream for this bookmark</param> /// <param name="mode"></param> /// <param name="element_name">If null, no bookmarking is actually performed</param> public XmlElementStreamBookmark(XmlElementStream stream, FA mode, string element_name) { Contract.Requires <ArgumentNullException>(stream != null); m_stream = null; m_mode = mode; m_oldCursor = null; if (element_name != null) { (m_stream = stream).StreamElementBegin(mode, element_name, out m_oldCursor); } }
static bool File_Open__String__FileMode__FileAccess(JSVCall vc, int argc) { int len = argc; if (len == 3) { System.String arg0 = (System.String)JSApi.getStringS((int)JSApi.GetType.Arg); System.IO.FileMode arg1 = (System.IO.FileMode)JSApi.getEnum((int)JSApi.GetType.Arg); System.IO.FileAccess arg2 = (System.IO.FileAccess)JSApi.getEnum((int)JSApi.GetType.Arg); JSMgr.datax.setObject((int)JSApi.SetType.Rval, System.IO.File.Open(arg0, arg1, arg2)); } return(true); }
/// <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 FATXFileStream(int DeviceIndex, System.IO.FileAccess fa, File file) { //Underlying.Close(); if (file.Size == 0) { throw new Exception("Null files not supported"); } xFile = file; // Set our position to the beginning of the file long off = VariousFunctions.GetBlockOffset(xFile.BlocksOccupied[0], xFile); Underlying = new FileStream(VariousFunctions.CreateHandle(DeviceIndex), fa); //Underlying.Position = off; Position = 0; }
public bool TryPrepareForWrite(DoesNotExistOptions fileDoesNotExist, ExistOptions fileExist) { if (isPrepared) { return(false); } string newFilePath; GetWriteOptions(FilePath, fileDoesNotExist, fileExist, out newFilePath, out fileMode); FilePath = newFilePath; fileAccess = System.IO.FileAccess.Write; isPrepared = true; return(true); }
private static EFileAccess getAccessFromAccess(System.IO.FileAccess access) { switch (access) { case System.IO.FileAccess.Read: return(EFileAccess.GenericRead); case System.IO.FileAccess.Write: return(EFileAccess.GenericWrite); case System.IO.FileAccess.ReadWrite: return(EFileAccess.GenericRead | EFileAccess.GenericWrite); } throw new NotSupportedException(); }
/// <summary>Returns object content as a stream.</summary> /// <param name="obj">Object info.</param> /// <param name="fileMode">File mode.</param> /// <param name="fileAccess">File access.</param> /// <param name="fileShare">Sharing permissions.</param> /// <param name="bufferSize">Buffer size.</param> public System.IO.Stream GetObjectContent(IS3ObjectInfo obj, System.IO.FileMode fileMode = System.IO.FileMode.Open, System.IO.FileAccess fileAccess = System.IO.FileAccess.Read, System.IO.FileShare fileShare = System.IO.FileShare.ReadWrite, int bufferSize = 4096) { if (!this.ObjectExists(obj)) { return(null); } AutoResetEvent orAdd = mS3ObjectEvents.GetOrAdd(obj.Key, new AutoResetEvent(true)); try { string tempPath = CMS.IO.Path.Combine(PathHelper.TempPath, PathHelper.GetPathFromObjectKey(obj.Key, false)); Directory.CreateDiskDirectoryStructure(tempPath); string cachePath = CMS.IO.Path.Combine(PathHelper.CachePath, PathHelper.GetPathFromObjectKey(obj.Key, false)); string path = $"{cachePath}.etag"; orAdd.WaitOne(); if (CMS.IO.File.Exists(cachePath) && System.IO.File.ReadAllText(path).Trim() == obj.ETag) { orAdd.Set(); System.IO.FileStream fileStream = new System.IO.FileStream(cachePath, fileMode, fileAccess, fileShare, bufferSize); FileDebug.LogFileOperation(PathHelper.GetPathFromObjectKey(obj.Key, true), "GetObjectFromCache", "Custom Amazon"); return(fileStream); } using (GetObjectResponse getObjectResponse = this.S3Client.GetObject(new GetObjectRequest() { BucketName = obj.BucketName, Key = obj.Key })) { getObjectResponse.WriteResponseStreamToFile(tempPath); } FileDebug.LogFileOperation(PathHelper.GetPathFromObjectKey(obj.Key, true), "GetObjectFromS3Storage", "Custom Amazon"); Directory.CreateDiskDirectoryStructure(cachePath); System.IO.File.Copy(tempPath, cachePath, true); System.IO.File.WriteAllText(path, obj.ETag); if (fileMode == System.IO.FileMode.Append && fileAccess != System.IO.FileAccess.Read) { fileMode = System.IO.FileMode.Open; fileAccess = System.IO.FileAccess.ReadWrite; } return(new System.IO.FileStream(tempPath, fileMode, fileAccess, fileShare, bufferSize)); } finally { orAdd.Set(); mS3ObjectEvents.TryRemove(obj.Key, out orAdd); } }
/// <summary> /// Prüft, ob eine Datei im Lesemodus geöffnet werden kann. Rückgabe /// 1 = Datei kann geöffnet werden /// -1 = Datei wurde nicht gefunden /// 0 = Datei ist in verwendung /// </summary> /// <param name="filename"></param> /// <returns></returns> public static int IsFileUnlocked(string filename, System.IO.FileAccess mode) { // If the file can be opened for exclusive access it means that the file // is no longer locked by another process. try { using (FileStream inputStream = File.Open(filename, FileMode.Open, mode, FileShare.None)) { return(1); } } catch (FileNotFoundException fnfe) { return(-1); } catch (IOException ioe) { return(0); } }
public FATXFileStream(SafeFileHandle handle, System.IO.FileAccess fa, FATX.File file) { //Underlying.Close(); if (file.Size == 0) { Close(); throw new Exception("Null files not supported"); } xFile = file; m = new Misc(); // Set our position to the beginning of the file long off = m.GetBlockOffset(xFile.BlocksOccupied[0], xFile); Underlying = new FileStream(handle, fa); Underlying.Position = off; }
public bool TryPrepareForRead() { if (isPrepared) { return(false); } if (!System.IO.File.Exists(FilePath)) { throw new FileNotFoundException(String.Format("File [{0}] does not exist.", FilePath)); } fileMode = FileMode.Open; fileAccess = System.IO.FileAccess.Read; isPrepared = true; return(true); }
public FileInfoLock LockStream(DriveService.Stream stream, string filePath, System.IO.FileMode fileMode, System.IO.FileAccess fileAccess, System.IO.FileShare fileShare) { try { return(LockFile(stream, stream.FileId, filePath, fileMode, fileAccess, fileShare)); } catch (Exception exception) { Log.Error(exception); return(null); } }
internal static IO.FileStream Open(string path, IO.FileAccess access, IO.FileMode mode, IO.FileShare share = IO.FileShare.None, bool throwException = true) { var fileHandle = CreateFile(path, GetFileAccess(access), GetFileShare(share), default(IntPtr), GetFileMode(mode)); if (fileHandle.IsInvalid) { if (throwException) { HandleCOMError(Marshal.GetLastWin32Error()); } else { return(null); } } return(new IO.FileStream(fileHandle, access)); }
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); } }
private void ExtractCodeNamespaces(string filePath) { FileAccess access = new FileAccess(); string fileContent = access.GetFileContent(filePath).ToString(); CodeReader codeReader = new CodeReader(); CodeSections = codeReader.GetAllCodeElements(filePath, fileContent, 0, 0); foreach (CodeSection codeSection in CodeSections) { CodeElement codeElement = codeReader.ConvertToDataModel(codeSection); if (codeSection.BlockType == "namespace") { ElementNamespace elementNamespace = new ElementNamespace(); elementNamespace.ElementName = filePath; //elementNamespace.ElementFile = filePath; ElementProgram.CodeNamespaces.Add(elementNamespace); } } }
// generate the list of all code files in the root folder public void GetFileList() { if (FilePaths != null) { FileAccess access = new FileAccess(); access.GetFileList(FilePaths); } }
// generate the list of all code file paths in the root folder public void GetFilePathList() { FileAccess access = new FileAccess(); FilePaths = access.GetFilePathList(RootPath); }