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);
}
/// <summary>
/// Copies the file at the given path to the server, which could be anywhere from
/// the local machine to a remote one.
/// </summary>
/// <param name="virtualPath">The virtual path.</param>
public void CopyToServer(VirtualPath virtualPath)
{
var fromFullPath = _pathFactory.CreateShadwoFullPath4Write(virtualPath);
byte[] infoBytes = _serverProxy.Get(new Uri("/BitTorrent/Info"));
var infoObj = XmlUtil.FromXml<BitTorrentServiceInfo>(
Encoding.UTF8.GetString(infoBytes));
if (infoObj.ServerCacheUri.IsLoopback) {
// Server on the same machine, we copy from file system.
var relativePath = virtualPath.PathString.Substring(
virtualPath.PathString.IndexOf(Path.DirectorySeparatorChar, 1));
var toFullPath = UriUtil.CombinePaths(infoObj.ServerCacheUri.LocalPath,
new Uri(relativePath, UriKind.Relative));
IOUtil.PrepareParentDirForPath(toFullPath);
if (SysEnvironment.OSVersion == OS.Unix) {
// In case of Unix, we actually use symbolic link instead of copying.
var symlink = new UnixSymbolicLinkInfo(toFullPath);
Logger.WriteLineIf(LogLevel.Verbose, _log_props, string.Format(
"Creating Symlink: {0} -> {1}", toFullPath, fromFullPath.PathString));
// Linking toPath to fromPath == Copy fromPath to toPath.
symlink.CreateSymbolicLinkTo(fromFullPath.PathString);
} else {
throw new NotImplementedException("Only Unix hosts are currently supported.");
}
} else {
throw new NotImplementedException("Only local machine is currently supported.");
}
}
public override NodeType GetSymbolicLinkTargetType(string path)
{
UnixSymbolicLinkInfo obj;
try
{
obj = new UnixSymbolicLinkInfo(path);
}
catch (InvalidOperationException)
{
/* Not a symbolic link */
return null;
}
try
{
if (!obj.IsSymbolicLink)
{
return null;
}
var retval = obj.GetContents();
if (retval == null)
{
return null;
}
var isDirectory = retval.IsDirectory;
if (isDirectory)
{
return NodeType.Directory;
}
var isRegularFile = retval.IsRegularFile;
if (isRegularFile)
{
return NodeType.File;
}
return null;
}
catch (OutOfMemoryException)
{
throw;
}
catch (StackOverflowException)
{
throw;
}
catch (Exception)
{
return null;
}
}
public override IEnumerable<Item> Load()
{
if (!IsValidConfinementItem (this)) {
yield break;
}
link = new UnixSymbolicLinkInfo (File.FullName);
if (!link.HasContents) {
yield break;
}
yield return this;
yield return Item.Resolve (Confinement,
new FileInfo (link.GetContents ().FullName));
}
public override string GetSymbolicLinkTarget(string path)
{
UnixSymbolicLinkInfo symbolicLinkInfo;
try
{
symbolicLinkInfo = new UnixSymbolicLinkInfo(path);
}
catch (InvalidOperationException)
{
/* Not a symbolic link */
return null;
}
string retval = null;
try
{
if (!symbolicLinkInfo.IsSymbolicLink)
{
return null;
}
retval = symbolicLinkInfo.ContentsPath;
if (retval != "/" && retval.EndsWith("/"))
{
retval = retval.Substring(0, retval.Length - 1);
}
}
catch (OutOfMemoryException)
{
throw;
}
catch (StackOverflowException)
{
throw;
}
catch
{
}
return retval;
}
public void cb1(JToken obj, string graph_path, fbdump_params p)
{
if (obj.Type == JTokenType.Object)
{
JObject obj1 = (JObject)obj;
string id = obj1 ["id"].Value <string> ();
try {
string fn = saveto + "/" + id;
if (System.IO.File.Exists(fn))
{
p.exists++;
}
System.IO.FileStream fs = new System.IO.FileStream(fn, p.stop_on_existing ? FileMode.CreateNew : FileMode.Create);
JsonWriter w = new JsonTextWriter(new StreamWriter(fs));
obj.WriteTo(w);
w.CloseOutput = true;
w.Close();
if (graph_path != null)
{
string n = graph_path.Trim('/').Replace('/', '.');
Mono.Unix.UnixSymbolicLinkInfo inf = new Mono.Unix.UnixSymbolicLinkInfo(saveto + "/" + n + "/" + id);
inf.CreateSymbolicLinkTo("../" + id);
}
foreach (JProperty pr in obj1.Properties())
{
if (p.saveurl.Contains(pr.Name))
{
saveurl(pr.Value.Value <string> (), id + "." + pr.Name);
}
}
} catch (Exception ex) {
Console.WriteLine(ex.Message);
if (p.stop_on_existing)
{
stop();
}
}
}
}
protected override List<Disk> LoadLogicalVolumesInternal() {
//var files = new string[] { "./FAT16.img", "./FAT32.img", "./NTFS.img"/* "/dev/sdb5" */ };
/*var disks = new List<Disk>();
foreach (var file in files) {
var disk = new LinLogicalDisk(file);
disks.Add(disk);
}
return disks;*/
var disks = new List<Disk>();
#if MONO
foreach (var file in Directory.GetFiles("/dev/disk/by-path")) {
var actual_path = new UnixSymbolicLinkInfo(file).GetContents().FullName;
try {
var disk = new LinLogicalDisk(actual_path);
disks.Add(disk);
} catch (Exception e) {
Console.Error.WriteLine("Could not read device: " + actual_path);
//Console.Error.WriteLine(e);
}
}
#endif
return disks;
}
/// <summary>
/// Depth-first recursive delete, with handling for descendant
/// directories open in Windows Explorer.
/// See http://stackoverflow.com/a/1703799/264822
/// </summary>
public static void deleteDirectory(string path)
{
Mono.Unix.UnixSymbolicLinkInfo info = new Mono.Unix.UnixSymbolicLinkInfo(path);
if (info.FileType == FileTypes.Directory)
{
foreach (string directory in Directory.GetDirectories(path))
{
deleteDirectory(directory);
}
}
try
{
Directory.Delete(path, true);
}
catch (IOException)
{
Directory.Delete(path, true);
}
catch (UnauthorizedAccessException)
{
Directory.Delete(path, true);
}
}
/// <summary>
/// Depth-first recursive delete, with handling for descendant
/// directories open in Windows Explorer.
/// See http://stackoverflow.com/a/1703799/264822
/// </summary>
public static void deleteDirectory(string path)
{
Mono.Unix.UnixSymbolicLinkInfo info = new Mono.Unix.UnixSymbolicLinkInfo(path);
if (info.FileType == FileTypes.Directory)
{
foreach (string directory in Directory.GetDirectories(path))
{
deleteDirectory(directory);
}
}
try
{
Directory.Delete(path, true);
}
catch (IOException)
{
Directory.Delete(path, true);
}
catch (UnauthorizedAccessException)
{
Directory.Delete(path, true);
}
}
/// <summary>
/// Checks whether a file is a Unix symbolic link.
/// </summary>
/// <param name="path">The path of the file to check.</param>
/// <param name="target">Returns the target the symbolic link points to if it exists.</param>
/// <returns><c>true</c> if <paramref name="path"/> points to a symbolic link; <c>false</c> otherwise.</returns>
/// <exception cref="InvalidOperationException">The underlying Unix subsystem failed to process the request (e.g. because of insufficient rights).</exception>
/// <exception cref="UnixIOException">The underlying Unix subsystem failed to process the request (e.g. because of insufficient rights).</exception>
public static bool IsSymlink([NotNull, Localizable(false)] string path, out string target)
{
#region Sanity checks
if (string.IsNullOrEmpty(path)) throw new ArgumentNullException(nameof(path));
#endregion
bool result = IsSymlink(path);
if (result)
{
var symlinkInfo = new UnixSymbolicLinkInfo(path);
target = symlinkInfo.ContentsPath;
}
else target = null;
return result;
}
/// <summary>
/// This thread is the main thread that checks for devices being added to or removed from the system.
/// </summary>
private void StorageDeviceDetectionThread()
{
int errorCount = 0;
DateTime lastErrorTime = new DateTime(0);
while (IsStarted && !IsStopping)
{
try
{
// Determine all current available devices by UUID for those that are not in ignore list
string[] allDevices = Directory.GetFiles("/dev/disk/by-uuid");
List <string> allDeviceNames = new List <string>();
foreach (string uuidPath in allDevices)
{
try
{
// Get the real device from the symbolic link
string device = uuidPath;
Mono.Unix.UnixSymbolicLinkInfo symLink = new Mono.Unix.UnixSymbolicLinkInfo(uuidPath);
if (symLink.HasContents)
{
device = Path.GetFullPath(Path.Combine(Path.GetDirectoryName(device), symLink.ContentsPath));
}
allDeviceNames.Add(device);
// If this device is on ignore list, already mounted or already failed skip it
if ((_devicesToIgnore.Contains(device)) || (_mountedDevices.ContainsKey(device)))
{
continue;
}
// Mount the device
string uuid = Path.GetFileName(uuidPath);
if (!Mount(device, _mountPrefix + "/" + uuid))
{
_devicesToIgnore.Add(device);
}
else
{
_mountedDevices.Add(device, uuid);
if (DeviceMounted != null)
{
DeviceMounted(this, new MountedDeviceEventArgs(new MountedDevice(device, _mountPrefix + "/" + uuid, uuid)));
}
}
}
catch
{
}
}
// Determine removed devices and unmount plus update dictionaries
Dictionary <string, string> allMountedDevices = GetMountedDevices();
List <string> removedDevices = new List <string>();
foreach (KeyValuePair <string, string> mountedDevice in _mountedDevices)
{
if ((!allMountedDevices.ContainsKey(mountedDevice.Key)) || (!File.Exists(mountedDevice.Key)))
{
removedDevices.Add(mountedDevice.Key);
}
}
foreach (string failedDevice in _devicesToIgnore)
{
if ((!allDeviceNames.Contains(failedDevice)) || (!File.Exists(failedDevice)))
{
removedDevices.Add(failedDevice);
}
}
foreach (string removedDevice in removedDevices)
{
// Remove from mappings
if (_devicesToIgnore.Contains(removedDevice))
{
_devicesToIgnore.Remove(removedDevice);
}
if (_mountedDevices.ContainsKey(removedDevice))
{
_mountedDevices.Remove(removedDevice);
}
// Attempt to unmount
string mountPath = allMountedDevices.ContainsKey(removedDevice) ? allMountedDevices[removedDevice] : null;
Unmount(removedDevice, mountPath);
if (DeviceUnmounted != null)
{
string uuid = null;
if ((mountPath != null) && (mountPath.StartsWith(_mountPrefix)))
{
uuid = mountPath.Substring(_mountPrefix.Length + 1);
}
DeviceUnmounted(this, new MountedDeviceEventArgs(new MountedDevice(removedDevice, _mountPrefix + uuid, uuid)));
}
}
// Wait for next loop
Thread.Sleep(500);
}
catch
{
if (DateTime.UtcNow.Subtract(lastErrorTime).TotalSeconds > 30)
{
errorCount = 0;
}
errorCount++;
if (errorCount >= 5)
{
throw;
}
lastErrorTime = DateTime.UtcNow;
}
}
_storageDeviceDetectionThread = null;
}
public static string ResolveSymbolicLink(string path)
{
if (string.IsNullOrEmpty (path))
return path;
if (Path.DirectorySeparatorChar == '\\')
return Path.GetFullPath (path);
try {
var alreadyVisted = new HashSet<string> ();
while (true) {
if (alreadyVisted.Contains (path))
return string.Empty;
alreadyVisted.Add (path);
var linkInfo = new UnixSymbolicLinkInfo (path);
if (linkInfo.IsSymbolicLink && linkInfo.HasContents) {
string contentsPath = linkInfo.ContentsPath;
if (!Path.IsPathRooted (contentsPath))
path = Path.Combine (Path.GetDirectoryName (path), contentsPath);
else
path = contentsPath;
path = ResolveFullPath (path);
continue;
}
path = Path.Combine (ResolveSymbolicLink (Path.GetDirectoryName (path)), Path.GetFileName (path));
return ResolveFullPath (path);
}
} catch {
return path;
}
}
public override bool RenameTo(FilePath path, string name)
{
var symlink = GetUnixFileInfo (path) as UnixSymbolicLinkInfo;
if (symlink != null) {
var newFile = new UnixSymbolicLinkInfo (name);
newFile.CreateSymbolicLinkTo (symlink.ContentsPath);
return true;
} else {
return base.RenameTo (path, name);
}
}
/// <summary>
/// Gets all currently mounted devices on the system.
/// </summary>
/// <returns>
/// A dictionary keying the physical device to its mount path.
/// </returns>
private Dictionary <string, string> GetMountedDevices()
{
// Read the MTab file initially and load all data
string[] mtabLines = File.ReadAllLines("/proc/mounts");
Dictionary <string, string> returnValue = new Dictionary <string, string>();
foreach (string line in mtabLines)
{
string[] parts = line.Split(new char[] { ' ' });
string device = string.Empty;
string mountPath = string.Empty;
int startIndex = 0;
bool parsingDevice = true;
for (int i = 1; i < parts.Length; i++)
{
// If previous string ended in / we continue
if (parts[i - 1].EndsWith("\\"))
{
continue;
}
// The previous one didn't end with a / so it's a completed part
if (parsingDevice)
{
// Get the device
for (int j = startIndex; j < i; j++)
{
device += (device == string.Empty ? string.Empty : " ") + parts[j];
}
startIndex = i;
// If the device does not start with a "/" we assume it's not a real path
if (!device.StartsWith("/"))
{
break;
}
// Move on to parsing the mount path
parsingDevice = false;
}
else
{
for (int j = startIndex; j < i; j++)
{
mountPath += (mountPath == string.Empty ? string.Empty : " ") + parts[j];
}
break;
}
}
// Continue if we don't have a mount path and device
if ((string.IsNullOrEmpty(device)) || (string.IsNullOrEmpty(mountPath)))
{
continue;
}
// If the device name is a symbolic link attempt to convert to its real one
if (File.Exists(device))
{
Mono.Unix.UnixSymbolicLinkInfo symLink = new Mono.Unix.UnixSymbolicLinkInfo(device);
if (symLink.HasContents)
{
device = Path.GetFullPath(Path.Combine(Path.GetDirectoryName(device), symLink.ContentsPath));
}
}
// Add to return value
returnValue.Add(device, mountPath);
}
// Return the results
return(returnValue);
}
protected override BuildResult Build (IProgressMonitor monitor, SolutionEntityItem item, ConfigurationSelector configuration)
{
var proj = item as MonoMacProject;
if (proj == null || proj.CompileTarget != CompileTarget.Exe)
return base.Build (monitor, item, configuration);
var conf = (MonoMacProjectConfiguration) configuration.GetConfiguration (item);
var resDir = conf.AppDirectory.Combine ("Contents", "Resources");
var appDir = conf.AppDirectory;
var res = base.Build (monitor, item, configuration);
if (res.ErrorCount > 0)
return res;
//copy exe, mdb, refs, copy-to-output, Content files to Resources
var filesToCopy = GetCopyFiles (proj, configuration, conf).Where (NeedsBuilding).ToList ();
if (filesToCopy.Count > 0) {
monitor.BeginTask ("Copying resource files to app bundle", filesToCopy.Count);
foreach (var f in filesToCopy) {
f.EnsureOutputDirectory ();
File.Copy (f.Input, f.Output, true);
monitor.Log.WriteLine ("Copied {0}", f.Output.ToRelative (appDir));
monitor.Step (1);
}
monitor.EndTask ();
}
//FIXME: only do this check if there are actually xib files
if (!Platform.IsMac) {
res.AddWarning ("Cannot compile xib files on non-Mac platforms");
} else {
//Interface Builder files
if (res.Append (CompileXibFiles (monitor, proj.Files, resDir)).ErrorCount > 0)
return res;
}
//info.plist
var plistOut = conf.AppDirectory.Combine ("Contents", "Info.plist");
var appInfoIn = proj.Files.GetFile (proj.BaseDirectory.Combine ("Info.plist"));
if (new FilePair (proj.FileName, plistOut).NeedsBuilding () ||
(appInfoIn != null && new FilePair (appInfoIn.FilePath, plistOut).NeedsBuilding ()))
if (res.Append (MergeInfoPlist (monitor, proj, conf, appInfoIn, plistOut)).ErrorCount > 0)
return res;
if (Platform.IsWindows) {
res.AddWarning ("Cannot create app bundle on Windows");
} else {
//launch script
var macOSDir = appDir.Combine ("Contents", "MacOS");
CopyExecutableFile (AddinManager.CurrentAddin.GetFilePath ("MonoMacLaunchScript.sh"), conf.LaunchScript);
CopyExecutableFile (AddinManager.CurrentAddin.GetFilePath ("mono-version-check"),
macOSDir.Combine ("mono-version-check"));
var si = new UnixSymbolicLinkInfo (appDir.Combine (conf.AppName));
if (!si.Exists)
si.CreateSymbolicLinkTo ("/Library/Frameworks/Mono.framework/Versions/Current/bin/mono");
}
//pkginfo
var pkgInfo = conf.AppDirectory.Combine ("Contents", "PkgInfo");
if (!File.Exists (pkgInfo))
using (var f = File.OpenWrite (pkgInfo))
f.Write (new byte [] { 0X41, 0X50, 0X50, 0X4C, 0x3f, 0x3f, 0x3f, 0x3f}, 0, 8); // "APPL???"
return res;
}
private UnixFileSystemInfo TraverseSymlink(UnixFileSystemInfo info)
{
lock (visited_symlinks) {
visited_symlinks.Clear ();
while (info.IsSymbolicLink) {
if (visited_symlinks.Contains (info.FullName)) {
return null;
}
visited_symlinks.Add (info.FullName);
var target = new UnixSymbolicLinkInfo (info.FullName).GetContents ();
if (info.FullName.StartsWith (target.FullName)) {
return null;
}
if (!target.Exists) {
return null;
}
info = target;
}
return info;
}
}
public void Setup(UnixFileSystemInfo u)
{
FullName = u.FullName;
Name = u.Name;
LCName = Name.ToLower ();
Owner = Helpers.OwnerName(u);
Group = Helpers.GroupName(u);
LastModified = Helpers.LastModified(u);
LastFileChange = Helpers.LastChange(FullName);
Permissions = Helpers.FilePermissions(u);
FileType = Helpers.FileType(u);
IsDirectory = FileType == FileTypes.Directory;
if (FileType == FileTypes.SymbolicLink) {
LinkTarget = Helpers.ReadLink(FullName);
var lt = new UnixSymbolicLinkInfo(LinkTarget);
IsDirectory = Helpers.FileExists(LinkTarget) && Helpers.FileType(lt) == FileTypes.Directory;
}
Suffix = IsDirectory ? "" : Helpers.Extname(Name).ToLower();
Size = Helpers.FileSize(u);
if (!IsDirectory) {
Count = 1;
SubTreeSize = Size;
SubTreeCount = 1;
Complete = true;
FilePassDone = true;
} else {
Count = 0;
Entries = new List<FSEntry> ();
}
}
public void cb1 (JToken obj, string graph_path, fbdump_params p)
{
if (obj.Type == JTokenType.Object) {
JObject obj1 = (JObject)obj;
string id = obj1 ["id"].Value<string> ();
try {
string fn = saveto + "/" + id;
if (System.IO.File.Exists (fn))
p.exists++;
System.IO.FileStream fs = new System.IO.FileStream (fn, p.stop_on_existing ? FileMode.CreateNew : FileMode.Create);
JsonWriter w = new JsonTextWriter (new StreamWriter (fs));
obj.WriteTo (w);
w.CloseOutput = true;
w.Close ();
if (graph_path != null) {
string n = graph_path.Trim ('/').Replace ('/', '.');
Mono.Unix.UnixSymbolicLinkInfo inf = new Mono.Unix.UnixSymbolicLinkInfo (saveto + "/" + n + "/" + id);
inf.CreateSymbolicLinkTo ("../" + id);
}
foreach (JProperty pr in obj1.Properties()) {
if (p.saveurl.Contains (pr.Name)) {
saveurl (pr.Value.Value<string> (), id + "." + pr.Name);
}
}
} catch (Exception ex) {
Console.WriteLine (ex.Message);
if (p.stop_on_existing) {
stop ();
}
}
}
}
public bool RenameTo (string name)
{
try {
if (RunningOnLinux) {
var symlink = UnixFileInfo.GetFileSystemEntry (path) as UnixSymbolicLinkInfo;
if (symlink != null) {
var newFile = new UnixSymbolicLinkInfo (name);
newFile.CreateSymbolicLinkTo (symlink.ContentsPath);
}
}
File.Move (path, name);
return true;
} catch {
return false;
}
}
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;
}
string GetTargetFile (string file)
{
if (!Platform.IsWindows) {
try {
UnixSymbolicLinkInfo fi = new UnixSymbolicLinkInfo (file);
if (fi.IsSymbolicLink)
return fi.ContentsPath;
} catch {
}
}
return file;
}
public override bool RenameTo (FilePath path, string name)
{
var symlink = GetUnixFileInfo (path) as UnixSymbolicLinkInfo;
if (symlink != null) {
var newFile = new UnixSymbolicLinkInfo (name);
newFile.CreateSymbolicLinkTo (symlink.ContentsPath);
return true;
} else {
// This call replaces the file if it already exists.
// File.Move throws an exception if dest already exists
return Mono.Unix.Native.Stdlib.rename (path, name) == 0;
}
}
