Beispiel #1
0
        public static bool DokanResetTimeout(uint timeout, DokanFileInfo fileinfo)
        {
            DOKAN_FILE_INFO rawFileInfo = new DOKAN_FILE_INFO();

            rawFileInfo.DokanContext = fileinfo.DokanContext;
            return(Dokan.DokanResetTimeout(timeout, ref rawFileInfo));
        }
Beispiel #2
0
        public static int DokanMain(DokanOptions options, DokanOperations operations)
        {
            if (options == null)
            {
                return;
            }

            DOKAN_OPTIONS dokanOptions = new DOKAN_OPTIONS();

            if (dokanOptions.Version == 0)
            {
                dokanOptions.Version = DOKAN_VERSION;
            }

            if (options.VolumeLabel == null)
            {
                options.VolumeLabel = "DOKAN-NET";
            }

            dokanOptions.Version = options.Version;
            Proxy proxy = new Proxy(options, operations);

            dokanOptions.MountPoint  = options.MountPoint;
            dokanOptions.ThreadCount = options.ThreadCount;
            dokanOptions.Options    |= options.DebugMode ? DOKAN_OPTION_DEBUG : 0;
            dokanOptions.Options    |= options.UseStdErr ? DOKAN_OPTION_STDERR : 0;
            dokanOptions.Options    |= options.UseAltStream ? DOKAN_OPTION_ALT_STREAM : 0;
            dokanOptions.Options    |= options.UseKeepAlive ? DOKAN_OPTION_KEEP_ALIVE : 0;
            dokanOptions.Options    |= options.NetworkDrive ? DOKAN_OPTION_NETWORK : 0;
            dokanOptions.Options    |= options.RemovableDrive ? DOKAN_OPTION_REMOVABLE : 0;

            DOKAN_OPERATIONS dokanOperations = new DOKAN_OPERATIONS();

            dokanOperations.CreateFile           = proxy.CreateFileProxy;
            dokanOperations.OpenDirectory        = proxy.OpenDirectoryProxy;
            dokanOperations.CreateDirectory      = proxy.CreateDirectoryProxy;
            dokanOperations.Cleanup              = proxy.CleanupProxy;
            dokanOperations.CloseFile            = proxy.CloseFileProxy;
            dokanOperations.ReadFile             = proxy.ReadFileProxy;
            dokanOperations.WriteFile            = proxy.WriteFileProxy;
            dokanOperations.FlushFileBuffers     = proxy.FlushFileBuffersProxy;
            dokanOperations.FindFiles            = proxy.FindFilesProxy;
            dokanOperations.SetFileAttributes    = proxy.SetFileAttributesProxy;
            dokanOperations.SetFileTime          = proxy.SetFileTimeProxy;
            dokanOperations.DeleteFile           = proxy.DeleteFileProxy;
            dokanOperations.DeleteDirectory      = proxy.DeleteDirectoryProxy;
            dokanOperations.MoveFile             = proxy.MoveFileProxy;
            dokanOperations.SetEndOfFile         = proxy.SetEndOfFileProxy;
            dokanOperations.SetAllocationSize    = proxy.SetAllocationSizeProxy;
            dokanOperations.LockFile             = proxy.LockFileProxy;
            dokanOperations.UnlockFile           = proxy.UnlockFileProxy;
            dokanOperations.GetDiskFreeSpace     = proxy.GetDiskFreeSpaceProxy;
            dokanOperations.GetVolumeInformation = proxy.GetVolumeInformationProxy;
            dokanOperations.Unmount              = proxy.UnmountProxy;

            return(Dokan.DokanMain(ref dokanOptions, ref dokanOperations));
        }
 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 int CloseFile(string filename, Dokan.DokanFileInfo info)
 {
     try
     {
         ((FileSystemFileStream)info.Context).Close();
         return 0;
     }
     catch (Exception e)
     {
         Console.WriteLine(" -- CloseFile Error: " + e.Message);
         return 0;
     }
     finally
     {
         NotImplemented(filename, info.Context);
     }
     //((FileSystemFileStream)info.Context).Close();
     //return 0;
     //NotImplemented();
 }
 public int Cleanup(string filename, Dokan.DokanFileInfo info)
 {
     info.Context = null;
     //NotImplemented();
     return 0;
 }
 public int WriteFile(string filename, byte[] buffer, ref uint writtenBytes, long offset, Dokan.DokanFileInfo info)
 {
     NotImplemented(filename, info);
     return -1;
 }
 public int GetDiskFreeSpace(ref ulong freeBytesAvailable, ref ulong totalBytes, ref ulong totalFreeBytes, Dokan.DokanFileInfo info)
 {
     freeBytesAvailable = 512 * 1024 * 1024;
     totalBytes = 1024 * 1024 * 1024;
     totalFreeBytes = 512 * 1024 * 1024;
     return 0;
 }
Beispiel #8
0
 public static uint DokanDriverVersion()
 {
     return(Dokan.DokanDriveVersion());
 }
Beispiel #9
0
 public static int DokanUnmount(char driveLetter)
 {
     return(Dokan.DokanUnmount(driveLetter));
 }
 public int DeleteFile(string filename, Dokan.DokanFileInfo info)
 {
     NotImplemented();
     return -1;
 }
 public int SetEndOfFile(string filename, long length, Dokan.DokanFileInfo info)
 {
     NotImplemented();
     return -1;
 }
 public int SetAllocationSize(string filename, long length, Dokan.DokanFileInfo info)
 {
     NotImplemented();
     return -1;
 }
 public int ReadFile(string filename, byte[] buffer, ref uint readBytes, long offset, Dokan.DokanFileInfo info)
 {
     try
     {
         var FileSystemFileStream = (FileSystemFileStream)info.Context;
         FileSystemFileStream.Position = offset;
         readBytes = (uint)FileSystemFileStream.Read(buffer, 0, (int)readBytes);
         return 0;
     }
     catch (Exception e)
     {
         Console.WriteLine(" -- ReadFile Error: " + e.Message);
         return -1;
     }
     finally
     {
         NotImplemented(filename, info);
     }
 }
 public int OpenDirectory(string filename, Dokan.DokanFileInfo info)
 {
     NotImplemented(filename);
     return 0;
 }
 public int MoveFile(string filename, string newname, bool replace, Dokan.DokanFileInfo info)
 {
     NotImplemented();
     return -1;
 }
 public int GetFileInformation(string filename, Dokan.FileInformation fileinfo, Dokan.DokanFileInfo info)
 {
     NotImplemented(filename, info.Context);
     try
     {
         var FileSystemEntry = FileSystem.GetFileInfo(filename);
         FillFileInformationFromFileSystemEntry(fileinfo, FileSystemEntry);
         return 0;
     }
     catch (Exception)
     {
         return -1;
         //return 0;
     }
 }
 public int CreateDirectory(string filename, Dokan.DokanFileInfo info)
 {
     NotImplemented(filename, info.Context);
     return -1;
 }
 public int SetFileAttributes(string filename, System.IO.FileAttributes attr, Dokan.DokanFileInfo info)
 {
     NotImplemented();
     return -1;
 }
 public int SetFileTime(string filename, DateTime ctime, DateTime atime, DateTime mtime, Dokan.DokanFileInfo info)
 {
     NotImplemented();
     return -1;
 }
Beispiel #20
0
 public static int DokanRemoveMountPoint(string mountPoint)
 {
     return(Dokan.DokanRemoveMountPoint(mountPoint));
 }
Beispiel #21
0
        public int GetFileInformation(string path, Dokan.FileInformation realFileInfo, Dokan.DokanFileInfo info)
        {
            Trace.TraceInformation("Entering GetFileInformation for path " + path);
            PathInformation pathInfo = this.getPathInformation(path);
            if (pathInfo == null)
            {
                Trace.TraceInformation(String.Format("The path {0} does not exist, cannot get file information", path));
                return -DokanNet.ERROR_PATH_NOT_FOUND;
            }

            GenericPathInformationOperationDelegate operation = delegate(PathInformation pInfo)
            {
                FileSystemInfo objectInfo = AufsImpl.getFileSystemInfoForPathInfo(pInfo);

                if (pInfo.ObjectKind == FileSystemObjectKind.File)
                {
                    realFileInfo.Length = (objectInfo as FileInfo).Length;
                }
                else
                {
                    realFileInfo.Length = 0;
                }

                realFileInfo.FileName = objectInfo.Name;
                realFileInfo.Attributes = objectInfo.Attributes;
                realFileInfo.CreationTime = objectInfo.CreationTime;
                realFileInfo.LastAccessTime = objectInfo.LastAccessTime;
                realFileInfo.LastWriteTime = objectInfo.LastWriteTime;
            };

            return this.executeGenericPathInformationOperation(pathInfo, false, operation);
        }
Beispiel #22
0
 public static uint DokanVersion()
 {
     return(Dokan.DokanVersion());
 }
        public int FindFiles(string filename, LinkedList<FileInformation> files, Dokan.DokanFileInfo info)
        {
            Console.WriteLine("FindFiles: " + filename + ":" + info);
            //foreach (var Item in FileSystem.FindFiles(filename.Replace(@"\", "/")))
            foreach (var Item in FileSystem.FindFiles(filename))
            {
                var FileInformation = new FileInformation();
                FillFileInformationFromFileSystemEntry(FileInformation, Item);

                //FileInformation.CreationTime.

                /*
                Console.WriteLine("------------------------------------------------");
                Console.WriteLine("CreationTime  : " + FileInformation.CreationTime);
                Console.WriteLine("LastWriteTime : " + FileInformation.LastWriteTime);
                Console.WriteLine("LastAccessTime: " + FileInformation.LastAccessTime);
                Console.WriteLine("------------------------------------------------");
                */

                //var AvailableDate = Item.Time.CreationTime ?? Item.Time.LastWriteTime ?? Item.Time.LastAccessTime;

                /*
                FileInformation.CreationTime = DateTime.Now;
                FileInformation.LastAccessTime = DateTime.Now;
                FileInformation.LastWriteTime = DateTime.Now;
                */
                //FileInformation.Length = 10001;
                //Console.WriteLine(Item);
                files.AddLast(FileInformation);
            }
            //Thread.Sleep(400);
            return 0;
            //NotImplemented();
        }
 public int UnlockFile(string filename, long offset, long length, Dokan.DokanFileInfo info)
 {
     NotImplemented();
     return 0;
 }
 public int FlushFileBuffers(string filename, Dokan.DokanFileInfo info)
 {
     NotImplemented();
     return -1;
 }
        public int GetFileInformation(string filename, Dokan.FileInformation fileinfo, DokanFileInfo info)
        {
            WriteTrace("getfileinformation", filename);

            FileReferences fileReference = files.Value.GetFolderReference(filename);

            string name = filename.Split(new [] {'\\'}, StringSplitOptions.RemoveEmptyEntries).LastOrDefault();

            if (fileReference != null && (fileReference.Name ?? string.Empty) != (name ?? string.Empty))
            {
                return -DokanNet.ERROR_FILE_NOT_FOUND;
            }

            if (fileReference != null)
            {
                fileinfo.Attributes = fileReference.IsFolder() ? FileAttributes.Directory : FileAttributes.Normal;
                fileinfo.LastAccessTime = fileReference.Date ?? DateTime.Now;
                fileinfo.LastWriteTime = fileReference.Date ?? DateTime.Now;
                fileinfo.CreationTime = fileReference.Date ?? DateTime.Now;
                fileinfo.FileName = fileReference.Name;
                fileinfo.Length = fileReference.Size;

                return DokanNet.DOKAN_SUCCESS;
            }

            return -DokanNet.ERROR_FILE_NOT_FOUND;
        }
 public int Unmount(Dokan.DokanFileInfo info)
 {
     NotImplemented();
     return 0;
 }