/// <summary>
/// Removes the lock for deleting directories for all directories (recursive up to the root).
/// </summary>
/// <param name="blockDirectory"></param>
/// <param name="flock"></param>
private static void ReleaseBlockDeletePermission(IFuserFilesystemDirectory blockDirectory, FileLockItem flock)
{
if (blockDirectory == null)
{
return; // Abort criterion for recursive method.
}
if (flock == null)
{
return;
}
try {
FileLockManager lockMgr = blockDirectory.Filelock;
if (lockMgr == null)
{
return;
}
lock (lockMgr) {
lockMgr.ReleaseBlockDeletePermission(flock);
}
} catch {
return;
}
ReleaseBlockDeletePermission(blockDirectory.Parent, flock); // recursively reset to root for all
}
/// <summary>
/// Sets the specified FileLock on the file and saves it in the file handle. Returns whether the setting is successful;
/// if False is returned, the file is already blocked by another process.
/// </summary>
/// <param name="fileHandle"></param>
/// <param name="fsItem"></param>
/// <param name="LockItem"></param>
/// <returns></returns>
public static bool FilelockSet(FileHandler fileHandle, IFuserFilesystemItem fsItem, FileLockItem LockItem)
{
if (LockItem == null || fileHandle == null || fsItem == null)
{
return(false);
}
try {
bool ret = false;
FileLockManager lockMgr = fsItem.Filelock;
if (lockMgr == null)
{
return(false);
}
lock (lockMgr) {
ret = lockMgr.RegisterLock(LockItem);
}
if (ret && fsItem is IFuserFilesystemDirectory && LockItem.IsDirectory && !LockItem.IsOpLock && !LockItem.Share.HasFlag(FileShare.Delete))
{
RegisterBlockDeletePermission((IFuserFilesystemDirectory)fsItem, LockItem);
}
if (ret)
{
lock (fileHandle) {
fileHandle.AddFileLock(LockItem);
}
}
else
{
return(false); // access violation occurred
}
} catch {
return(false);
}
return(true);
}
/// <summary>
/// Release a filelock
/// </summary>
/// <param name="fileHandle"></param>
/// <param name="item"></param>
public static void FilelockRelease(FileHandler fileHandle, IFuserFilesystemItem item)
{
try {
if (fileHandle == null || item == null)
{
return;
}
FileLockManager lockMgr = item.Filelock;
FileLockItem[] locks = null;
lock (fileHandle) {
locks = fileHandle.GetFileLockList();
}
if (locks != null)
{
IFuserFilesystemDirectory dirItem = null;
if (item is IFuserFilesystemDirectory)
{
dirItem = (IFuserFilesystemDirectory)item;
}
lock (lockMgr) {
foreach (FileLockItem lItem in locks)
{
lockMgr.UnregisterLock(lItem);
if (dirItem != null)
{
ReleaseBlockDeletePermission(dirItem, lItem);
}
}
}
}
} catch {
return;
}
}
/// <summary>
/// Checks whether the specified directory is flagged for deletion.
/// </summary>
/// <param name="vDir"></param>
/// <returns></returns>
public static bool CheckIsDirectoryDeletedOnClose(IFuserFilesystemDirectory vDir)
{
// TODO: check if a certain error code must be returned when calling this function
if (vDir == null)
{
return(false);
}
if (vDir.Filelock == null)
{
return(false);
}
bool selDeleted = false;
try {
FileLockManager lockMgr = vDir.Filelock;
lock (lockMgr) {
selDeleted = lockMgr.DeleteOnClose;
}
} catch {
return(false);
}
return(selDeleted);
}
/// <summary>
/// Checks whether the specified area has been locked by another file handle.
/// </summary>
/// <param name="fileHandle"></param>
/// <param name="item"></param>
/// <param name="offset"></param>
/// <param name="length"></param>
/// <returns></returns>
public static bool FileOPLockCheck(FileHandler fileHandle, IFuserFilesystemItem item, long offset, long length)
{
try {
if (fileHandle == null)
{
return(false);
}
if (!fileHandle.OPLockActive)
{
return(true); // do not check any locks, according to the filehandle locks are not possible.
}
if (item == null)
{
return(false);
}
if (offset < 0)
{
return(true);
}
if (length <= 0)
{
return(true);
}
FileLockManager lockMgr = item.Filelock;
FileLockItem[] locksHandle = null; // list of locks from this handle.
FileLockItem[] locksFile = null; // list of locks from this file.
lock (fileHandle) {
locksHandle = fileHandle.GetFileLockList();
}
lock (lockMgr) {
locksFile = lockMgr.GetFileLockList();
}
if (locksFile == null)
{
return(true);
}
List <FileLockItem> locks = new List <FileLockItem>(locksFile);
if (locksHandle != null)
{
foreach (FileLockItem lItem in locksHandle)
{
locks.Remove(lItem);
}
}
foreach (FileLockItem lItem in locks)
{
if (lItem.IsOpLock)
{
if (!lItem.CheckOPLockRange(offset, length))
{
return(false);// violation occurred!
}
}
}
return(true);
} catch {
return(false);
}
}
/// <summary>
/// Checks whether the selected item can be deleted. Only the FileLocks are taken into account. Required for Move and Delete
/// </summary>
/// <param name="fileHandle"></param>
/// <param name="item"></param>
/// <returns></returns>
public static bool DeletionAllow(FileHandler fileHandle, IFuserFilesystemItem item)
{
try {
if (fileHandle == null)
{
return(false);
}
if (item == null)
{
return(false);
}
List <FileLockItem> locks;
FileLockManager lockMgr = item.Filelock;
FileLockItem[] locksHandle = null; // list with locks for the current fileHandle
FileLockItem[] locksFile = null; // list with locks for the current file
FileLockItem[] locksBlockDelete = null; // list with deletion-locks for the current file
lock (fileHandle) {
locksHandle = fileHandle.GetFileLockList();
}
lock (lockMgr) {
locksFile = lockMgr.GetFileLockList();
locksBlockDelete = lockMgr.GetBlockDeletePermissionList();
}
if (locksFile == null)
{
return(true); // no locks found, file not in use
}
// check: deletion block
if (locksBlockDelete != null)
{
locks = new List <FileLockItem>(locksBlockDelete);
if (locksHandle != null)
{
foreach (FileLockItem lItem in locksHandle)
{
locks.Remove(lItem);
}
}
if (locks.Count != 0)
{
return(false);// deletion was blocked
}
}
// check: deletion block
locks = new List <FileLockItem>(locksFile);
if (locksHandle != null)
{
foreach (FileLockItem lItem in locksHandle)
{
locks.Remove(lItem);
}
}
bool del = false;
foreach (FileLockItem lck in locks)
{
if (!lck.Share.HasFlag(FileShare.Delete))
{
del = true;
}
}
if (del == false)
{
return(true);
}
else
{
return(false);
}
} catch {
return(false);
}
}
