public Dirent[] GetEntries() { Dirent[] direntArray; IntPtr intPtr = Syscall.opendir(base.FullPath); if (intPtr == IntPtr.Zero) { UnixMarshal.ThrowExceptionForLastError(); } bool flag = false; try { Dirent[] entries = UnixDirectoryInfo.GetEntries(intPtr); flag = true; direntArray = entries; } finally { int num = Syscall.closedir(intPtr); if (flag) { UnixMarshal.ThrowExceptionForLastErrorIf(num); } } return(direntArray); }
public static bool TryGetFileSystemEntry(string path, out UnixFileSystemInfo entry) { Native.Stat stat; int r = Native.Syscall.lstat(path, out stat); if (r == -1) { if (Native.Stdlib.GetLastError() == Native.Errno.ENOENT) { entry = new UnixFileInfo(path); return(true); } entry = null; return(false); } if (IsFileType(stat.st_mode, Native.FilePermissions.S_IFDIR)) { entry = new UnixDirectoryInfo(path, stat); } else if (IsFileType(stat.st_mode, Native.FilePermissions.S_IFLNK)) { entry = new UnixSymbolicLinkInfo(path, stat); } else { entry = new UnixFileInfo(path, stat); } return(true); }
static void ScanPath(UnixDirectoryInfo dirinfo, string prefix) { foreach (var fileinfo in dirinfo.GetFileSystemEntries()) { string id = string.Concat(prefix, fileinfo.Name); switch (fileinfo.FileType) { case FileTypes.RegularFile: string hash; if (fileinfo.Length == 0) hash = "0\t0\t0\t0"; else hash = FormatMd5Hash(fileinfo.FullName); Console.WriteLine("{0}\t0\t{1}", id, hash); break; case FileTypes.Directory: ScanPath((UnixDirectoryInfo)fileinfo, string.Concat(id, "!")); break; default: /* Do nothing for symlinks or other weird things. */ break; } } }
private static string _GetFullPath(string path) { if (path == null) { throw new ArgumentNullException("path"); } if (!UnixPath.IsPathRooted(path)) { path = string.Concat(UnixDirectoryInfo.GetCurrentDirectory(), UnixPath.DirectorySeparatorChar, path); } return(path); }
private static string _GetFullPath(string path) { if (path == null) { throw new ArgumentNullException("path"); } if (!IsPathRooted(path)) { path = UnixDirectoryInfo.GetCurrentDirectory() + DirectorySeparatorChar + path; } return(path); }
public Dirent[] GetEntries(Regex regex) { Dirent[] entries; IntPtr intPtr = Syscall.opendir(base.FullPath); if (intPtr == IntPtr.Zero) { UnixMarshal.ThrowExceptionForLastError(); } try { entries = UnixDirectoryInfo.GetEntries(intPtr, regex); } finally { UnixMarshal.ThrowExceptionForLastErrorIf(Syscall.closedir(intPtr)); } return(entries); }
public void Delete(bool recursive) { if (recursive) { UnixFileSystemInfo[] fileSystemEntries = this.GetFileSystemEntries(); for (int i = 0; i < (int)fileSystemEntries.Length; i++) { UnixFileSystemInfo unixFileSystemInfo = fileSystemEntries[i]; UnixDirectoryInfo unixDirectoryInfo = unixFileSystemInfo as UnixDirectoryInfo; if (unixDirectoryInfo == null) { unixFileSystemInfo.Delete(); } else { unixDirectoryInfo.Delete(true); } } } UnixMarshal.ThrowExceptionForLastErrorIf(Syscall.rmdir(base.FullPath)); base.Refresh(); }
public void Delete(bool recursive) { if (recursive) { foreach (UnixFileSystemInfo e in GetFileSystemEntries()) { UnixDirectoryInfo d = e as UnixDirectoryInfo; if (d != null) { d.Delete(true); } else { e.Delete(); } } } int r = Native.Syscall.rmdir(FullPath); UnixMarshal.ThrowExceptionForLastErrorIf(r); base.Refresh(); }
Result CopyDirectory(string source_absolute_path, string target_path, FilePermissions protection) { if (!dirs_created.ContainsKey (target_path)){ while (true){ int r = Syscall.mkdir (target_path, protection | FilePermissions.S_IRWXU); if (r != -1) break; Errno errno = Stdlib.GetLastError (); if (errno == Errno.EINTR) continue; if (errno == Errno.EEXIST || errno == Errno.EISDIR) break; var msg = UnixMarshal.GetErrorDescription (errno); switch (Interaction.Query (OResult.RetryIgnoreCancel, msg, "While creating \"{0}\"", target_path)){ case OResult.Retry: continue; case OResult.Ignore: break; case OResult.Cancel: return Result.Cancel; } } dirs_created [target_path] = protection; } var udi = new UnixDirectoryInfo (source_absolute_path); foreach (var entry in udi.GetFileSystemEntries ()){ if (entry.Name == "." || entry.Name == "..") continue; string source = Path.Combine (source_absolute_path, entry.Name); string target = Path.Combine (target_path, entry.Name); Result res; if (entry.IsDirectory){ if (CopyDirectory (source, target, entry.Protection) == Result.Cancel) return Result.Cancel; } else { if (!CopyFile (source, target)){ return skip ? Result.Skip : Result.Cancel; } } } return Result.Ok; }
static void Main() { var dirinfo = new UnixDirectoryInfo("."); ScanPath(dirinfo, ""); }
private bool DirectoryIsSuitable(string folderToTest) { // A directory with invalid characters isn't suitable string pathToTest = null; try { pathToTest = Path.GetFullPath(folderToTest); } catch(Exception) { return false; } // A directory doesn't have to exist yet to be suitable but if the root directory isn't suitable that's not good while(!Directory.Exists(pathToTest)) { if(String.IsNullOrEmpty(pathToTest.Trim())) return false; pathToTest = Path.GetDirectoryName(pathToTest); } if(!MiscUtils.IsUnix) { // Check the OS file permissions for the folder var accessControlList = Directory.GetAccessControl(pathToTest); var accessRules = accessControlList.GetAccessRules(true, true, typeof(SecurityIdentifier)); var readAllowed = false; var writeAllowed = false; foreach(FileSystemAccessRule rule in accessRules) { //If we find one that matches the identity we are looking for using(var currentUserIdentity = WindowsIdentity.GetCurrent()) { var userName = currentUserIdentity.User.Value; if( rule.IdentityReference.Value.Equals(userName, StringComparison.CurrentCultureIgnoreCase) || currentUserIdentity.Groups.Contains(rule.IdentityReference)) { if((FileSystemRights.Read & rule.FileSystemRights) == FileSystemRights.Read) { if(rule.AccessControlType == AccessControlType.Allow) readAllowed = true; if(rule.AccessControlType == AccessControlType.Deny) return false; } if((FileSystemRights.Write & rule.FileSystemRights) == FileSystemRights.Write) { if(rule.AccessControlType == AccessControlType.Allow) writeAllowed = true; if(rule.AccessControlType == AccessControlType.Deny) return false; } } } return readAllowed && writeAllowed; } } #if __MonoCS__ var ufi = new UnixDirectoryInfo(pathToTest); return (ufi.CanAccess(Mono.Unix.Native.AccessModes.R_OK) && ufi.CanAccess(Mono.Unix.Native.AccessModes.W_OK)); // accessible for writing #else return false; // unreachable in practice #endif }
public static int Main (string [] args) { var configurationManager = new ConfigurationManager ("mono-fpm"); if (!configurationManager.LoadCommandLineArgs (args)) return 1; // Show the help and exit. if (configurationManager.Help) { configurationManager.PrintHelp (); #if DEBUG Console.WriteLine ("Press any key..."); Console.ReadKey (); #endif return 0; } // Show the version and exit. if (configurationManager.Version) { Version.Show (); return 0; } if (!configurationManager.LoadConfigFile ()) return 1; configurationManager.SetupLogger (); #if DEBUG // Log everything while debugging Logger.Level = LogLevel.All; #endif Logger.Write (LogLevel.Debug, Assembly.GetExecutingAssembly ().GetName ().Name); string configDir = configurationManager.ConfigDir; string webDir = configurationManager.WebDir; if (String.IsNullOrEmpty (configDir) && (!Platform.IsUnix || String.IsNullOrEmpty (webDir))) { if(Platform.IsUnix) Logger.Write (LogLevel.Error, "You MUST provide a configuration directory with the --config-dir parameter or web directories with the --web-dir parameter."); else Logger.Write (LogLevel.Error, "You MUST provide a configuration directory with the --config-dir parameter."); return 1; } if (!String.IsNullOrEmpty (configDir)) { var configDirInfo = new DirectoryInfo (configDir); if (!configDirInfo.Exists) { Logger.Write (LogLevel.Error, "The configuration directory \"{0}\" does not exist!", configDir); } else { Logger.Write (LogLevel.Debug, "Configuration directory {0} exists, loading configuration files", configDir); FileInfo[] configFiles = configDirInfo.GetFiles ("*.xml"); ChildrenManager.StartChildren (configFiles, configurationManager); } } if (Platform.IsUnix && !String.IsNullOrEmpty (webDir)) { var webDirInfo = new UnixDirectoryInfo (Path.GetFullPath (webDir)); if (!webDirInfo.Exists) { Logger.Write (LogLevel.Error, "The web directory \"{0}\" does not exist!", webDir); } else { Logger.Write (LogLevel.Debug, "Web directory {0} exists, starting children", webDir); IEnumerable<UnixDirectoryInfo> webDirs = from entry in webDirInfo.GetFileSystemEntries () let dir = entry as UnixDirectoryInfo where dir != null select dir; if (configurationManager.HttpdGroup == null) { Logger.Write (LogLevel.Error, "Couldn't autodetect the httpd group, you must specify it explicitly with --httpd-group"); return 1; } if (!CheckGroupExists (configurationManager.FpmGroup) || !CheckGroupExists (configurationManager.HttpdGroup) || !CheckUserExists (configurationManager.FpmUser)) return 1; ChildrenManager.StartAutomaticChildren (webDirs, configurationManager); } } Platform.SetIdentity (configurationManager.FpmUser, configurationManager.FpmGroup); if (!configurationManager.Stoppable) { var sleep = new ManualResetEvent (false); sleep.WaitOne (); // Do androids dream of electric sheep? } Console.WriteLine ("Hit Return to stop the server."); Console.ReadLine (); ChildrenManager.TermChildren(); ChildrenManager.KillChildren(); return 0; }
public static UnixDriveInfo GetDriveInfo(this UnixFileInfo fileInfo) { Mono.Unix.UnixDirectoryInfo file = new Mono.Unix.UnixDirectoryInfo(fileInfo.FullName); Mono.Unix.UnixDriveInfo drive = new Mono.Unix.UnixDriveInfo(fileInfo.FullName); return(drive); }
public IEnumerable<SafeUri> GetDirectories(string directory) { var unix_dir = new UnixDirectoryInfo (directory); foreach (var entry in unix_dir.GetFileSystemEntries ()) { var info = TraverseSymlink (entry); if (info != null && info.IsDirectory && info.Exists && !info.IsSocket) { yield return new SafeUri (info.FullName, false); } } }
public static UnixFileSystemInfo[] EntriesMaybe(UnixDirectoryInfo di) { try { return Entries(di); } catch (Exception) { return new UnixFileSystemInfo[0]; } }
public void Delete(string directory, bool recursive) { UnixDirectoryInfo unix_dir = new UnixDirectoryInfo (directory); unix_dir.Delete (recursive); }
public static UnixFileSystemInfo[] Entries(UnixDirectoryInfo di) { return di.GetFileSystemEntries (); }
/// <summary> /// Searches for songs in a specific folder, using recursivity or not. /// </summary> /// <param name="folderPath">Path to search</param> /// <param name="recursive">Recursive (if true, will search for sub-folders)</param> /// <returns>List of songs (file paths)</returns> private List<string> SearchMediaFilesInFolders(string folderPath, bool recursive) { // Declare variables List<string> arrayFiles = new List<string>(); string extensionsSupported = string.Empty; // Refresh status OnRaiseRefreshStatusEvent(new UpdateLibraryEntity() { Title = "Searching for media files", Subtitle = "Searching for media files in library folder " + folderPath, PercentageDone = 0 }); // Set supported extensions #if MACOSX extensionsSupported = @"^.+\.((wav)|(mp3)|(flac)|(ogg)|(mpc)|(wv)|(m3u)|(m3u8)|(pls)|(xspf))$"; #elif LINUX extensionsSupported = @"^.+\.((wav)|(mp3)|(flac)|(ogg)|(mpc)|(wv)|(m3u)|(m3u8)|(pls)|(xspf))$"; #elif (!MACOSX && !LINUX) extensionsSupported = @"WAV;MP3;FLAC;OGG;MPC;WV;WMA;APE;M3U;M3U8;PLS;XSPF"; #endif #if (MACOSX || LINUX) // Get Unix-style directory information (i.e. case sensitive file names) UnixDirectoryInfo rootDirectoryInfo = new UnixDirectoryInfo(folderPath); // For each directory, search for new directories foreach (UnixFileSystemInfo fileInfo in rootDirectoryInfo.GetFileSystemEntries()) { // Check if entry is a directory if(fileInfo.IsDirectory && recursive) { // Make sure this isn't an Apple index directory if(!fileInfo.Name.StartsWith(".Apple")) { Console.WriteLine("UpdateLibraryService - SearchMediaFilesInFolders {0}", fileInfo.FullName); try { List<string> listMediaFiles = SearchMediaFilesInFolders(fileInfo.FullName, true); arrayFiles.AddRange(listMediaFiles); } catch(Exception ex) { Console.WriteLine("UpdateLibraryService - SearchMediaFilesInFolders {0} - Exception {1}", fileInfo.FullName, ex); } } } // If the extension matches, add file to list Match match = Regex.Match(fileInfo.FullName, extensionsSupported, RegexOptions.IgnoreCase); if(match.Success) arrayFiles.Add(fileInfo.FullName); } #else // Get Windows-style directory information DirectoryInfo rootDirectoryInfo = new DirectoryInfo(folderPath); // Check for sub directories if recursive if (recursive) { // For each directory, search for new directories DirectoryInfo[] directoryInfos = rootDirectoryInfo.GetDirectories(); foreach (DirectoryInfo directoryInfo in directoryInfos) { // Make sure this isn't an Apple index directory if (!directoryInfo.Name.StartsWith(".Apple")) { // Search for songs in that directory List<string> listSongs = SearchMediaFilesInFolders(directoryInfo.FullName, recursive); arrayFiles.AddRange(listSongs); } } } string[] extensions = extensionsSupported.Split(new string[]{";"}, StringSplitOptions.RemoveEmptyEntries); //FileInfo[] fileInfos = rootDirectoryInfo.GetFiles("*." + extension); FileInfo[] fileInfos = rootDirectoryInfo.GetFiles(); foreach (FileInfo fileInfo in fileInfos) { // Check if file matches supported extensions if (extensions.Contains(fileInfo.Extension.Replace(".", ""), StringComparer.InvariantCultureIgnoreCase)) { arrayFiles.Add(fileInfo.FullName); } } #endif return arrayFiles; }
public void SetCurrentDir(string dirname, bool resetZoom) { Profiler p = new Profiler (); dirLatencyProfiler.Restart (); FirstFrameOfDir = true; if (dirname != Helpers.RootDir) dirname = dirname.TrimEnd(Helpers.DirSepC); UnixDirectoryInfo d = new UnixDirectoryInfo (dirname); string odp = CurrentDirPath; CurrentDirPath = d.FullName; if (odp != CurrentDirPath) { if (CurrentDirEntry != null && CurrentDirEntry.InProgress) FSCache.CancelTraversal (); CurrentDirEntry = FSCache.FastGet (CurrentDirPath); FSCache.Watch (CurrentDirPath); } FSNeedRedraw = true; if (resetZoom) ResetZoom (); UpdateLayout (); p.Time("SetCurrentDir"); }
public void RefreshSongInformation(AudioFile audioFile, long lengthBytes, int playlistIndex, int playlistCount) { Gtk.Application.Invoke(delegate{ if(audioFile != null) { // Refresh labels Console.WriteLine("MainWindow - RefreshSongInformation"); lblArtistName.Text = audioFile.ArtistName; lblAlbumTitle.Text = audioFile.AlbumTitle; lblSongTitle.Text = audioFile.Title; lblSongFilePath.Text = audioFile.FilePath; //lblCurrentPosition.Text = audioFile.Position; lblCurrentLength.Text = audioFile.Length; lblCurrentFileType.Text = audioFile.FileType.ToString(); lblCurrentBitrate.Text = audioFile.Bitrate.ToString(); lblCurrentSampleRate.Text = audioFile.SampleRate.ToString(); lblCurrentBitsPerSample.Text = audioFile.BitsPerSample.ToString(); //Pixbuf stuff = new Pixbuf("icon48.png"); //stuff = stuff.ScaleSimple(150, 150, InterpType.Bilinear); //imageAlbumCover.Pixbuf = stuff; System.Drawing.Image drawingImage = AudioFile.ExtractImageForAudioFile(audioFile.FilePath); if(drawingImage != null) { // Resize image and set cover drawingImage = SystemDrawingHelper.ResizeImage(drawingImage, 150, 150); imageAlbumCover.Pixbuf = ImageToPixbuf(drawingImage); } else { // Get Unix-style directory information (i.e. case sensitive file names) if(!String.IsNullOrEmpty(audioFile.FilePath)) { try { bool imageFound = false; string folderPath = System.IO.Path.GetDirectoryName(audioFile.FilePath); UnixDirectoryInfo rootDirectoryInfo = new UnixDirectoryInfo(folderPath); // For each directory, search for new directories UnixFileSystemInfo[] infos = rootDirectoryInfo.GetFileSystemEntries(); foreach (UnixFileSystemInfo fileInfo in rootDirectoryInfo.GetFileSystemEntries()) { // Check if the file matches string fileName = fileInfo.Name.ToUpper(); if((fileName.EndsWith(".JPG") || fileName.EndsWith(".JPEG") || fileName.EndsWith(".PNG") || fileName.EndsWith(".GIF")) && (fileName.StartsWith("FOLDER") || fileName.StartsWith("COVER"))) { // Get image from file imageFound = true; Pixbuf imageCover = new Pixbuf(fileInfo.FullName); imageCover = imageCover.ScaleSimple(150, 150, InterpType.Bilinear); imageAlbumCover.Pixbuf = imageCover; } } // Set empty image if not cover not found if(!imageFound) imageAlbumCover.Pixbuf = null; } catch { imageAlbumCover.Pixbuf = null; } } else { // Set empty album cover imageAlbumCover.Pixbuf = null; } } // Check if image cover is still empty if(imageAlbumCover.Pixbuf == null) { Pixbuf imageCover = ResourceHelper.GetEmbeddedImageResource("black.png"); imageCover = imageCover.ScaleSimple(150, 150, InterpType.Bilinear); imageAlbumCover.Pixbuf = imageCover; } } }); }
public static bool TryGetFileSystemEntry (string path, out UnixFileSystemInfo entry) { Native.Stat stat; int r = Native.Syscall.lstat (path, out stat); if (r == -1) { if (Native.Stdlib.GetLastError() == Native.Errno.ENOENT) { entry = new UnixFileInfo (path); return true; } entry = null; return false; } if (IsFileType (stat.st_mode, Native.FilePermissions.S_IFDIR)) entry = new UnixDirectoryInfo (path, stat); else if (IsFileType (stat.st_mode, Native.FilePermissions.S_IFLNK)) entry = new UnixSymbolicLinkInfo (path, stat); else entry = new UnixFileInfo (path, stat); return true; }