org.filesys.server.filesys.db.DBDiskDriver Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jfileserver Show documentation
Show all versions of jfileserver Show documentation
Java file server with SMB, FTP/FTPS and NFS support, virtual filesystems, database filesystems
/*
* Copyright (C) 2006-2010 Alfresco Software Limited.
*
* This file is part of Alfresco
*
* Alfresco is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Alfresco is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Alfresco. If not, see searchFlags)
throws FileNotFoundException {
// Access the JDBC context
DBDeviceContext dbCtx = (DBDeviceContext) tree.getContext();
// Check if the database is online
if (dbCtx.getDBInterface().isOnline() == false)
throw new FileNotFoundException("Database is offline");
// Check if the file loader is online
if (dbCtx.getFileLoader().isOnline() == false)
throw new FileNotFoundException("File loader is offline");
// Prepend a leading slash to the path if not on the search path
if (searchPath.startsWith( FileName.DOS_SEPERATOR_STR) == false)
searchPath = FileName.DOS_SEPERATOR_STR + searchPath;
// Check if the path is to a file or folder, if there is no trailing seperator
if ( searchPath.endsWith( FileName.DOS_SEPERATOR_STR) == false) {
// Get the file name part of the path and check if it contains wildcard character(s)
String fileNamePart = FileName.getFileNamePart( searchPath);
if ( fileNamePart == null || WildCard.containsWildcards( fileNamePart) == false) {
// Check if the search path is to a file or folder
FileStatus pathSts = fileExists(sess, tree, searchPath);
if (pathSts == FileStatus.DirectoryExists && searchFlags.contains( SearchFlags.SingleEntry) == false)
searchPath = searchPath + FileName.DOS_SEPERATOR_STR;
}
}
// Get the directory id for the last directory in the path
int dirId = findParentDirectoryId(dbCtx, searchPath, true);
if (dirId == -1)
throw new FileNotFoundException("Invalid path");
// Start the search
SearchContext search = null;
try {
// Check if the search path is a none wildcard search, the file information may be in the
// state cache
if (WildCard.containsWildcards(searchPath) == false) {
// Check if there is a file state for the search path
FileState searchState = getFileState(searchPath, dbCtx, false);
if (searchState != null && searchState.fileExists() == true) {
// Check if the file state has the file information attached
DBFileInfo finfo = (DBFileInfo) searchState.findAttribute(FileState.FileInformation);
if (finfo != null) {
// Create a single file search context using the cached file information
search = new CachedSearchContext(finfo);
// DEBUG
if (Debug.EnableInfo && hasDebug())
Debug.println("DB StartSearch using cached file information, path=" + searchPath + ", info=" + finfo);
}
}
}
// Start the search via the database interface, if the search is not valid
if (search == null) {
// Start the search
DBSearchContext dbSearch = dbCtx.getDBInterface().startSearch(dirId, searchPath, attrib, DBInterface.FileInfoLevel.All, -1);
// Check if files should be marked as offline
dbSearch.setMarkAsOffline(dbCtx.hasOfflineFiles());
dbSearch.setOfflineFileSize(dbCtx.getOfflineFileSize());
search = dbSearch;
}
}
catch (DBException ex) {
throw new FileNotFoundException( ex.getMessage());
}
// Return the search context
return search;
}
/**
* Truncate a file to the specified size
*
* @param sess Server session
* @param tree Tree connection
* @param file Network file details
* @param siz New file length
* @throws IOException If an error occurs.
*/
public void truncateFile(SrvSession sess, TreeConnection tree, NetworkFile file, long siz)
throws java.io.IOException {
// Debug
if (Debug.EnableInfo && hasDebug())
Debug.println("DB truncateFile()");
// Check that the network file is our type
if (file instanceof DBNetworkFile) {
// Access the JDBC context
DBDeviceContext dbCtx = (DBDeviceContext) tree.getContext();
// Get the JDBC file
DBNetworkFile jfile = (DBNetworkFile) file;
// Get, or create, the file state
FileState fstate = jfile.getFileState();
// Get the file details
DBFileInfo dbInfo = getFileDetails(jfile.getFullName(), dbCtx, fstate);
if (dbInfo == null)
throw new FileNotFoundException(jfile.getFullName());
// Check if the new file size is greater than the maximum allowed file size, if enabled
if (dbCtx.hasMaximumFileSize() && siz > dbCtx.getMaximumFileSize()) {
// Mark the file to delete on close
file.setDeleteOnClose(true);
// Return a disk full error
throw new DiskFullException("Write is beyond maximum allowed file size");
}
// Keep track of the allocation/release size in case the file resize fails
long allocSize = 0L;
long releaseSize = 0L;
// Check if there is a quota manager
QuotaManager quotaMgr = dbCtx.getQuotaManager();
if (dbCtx.hasQuotaManager()) {
// Determine if the new file size will release space or require space allocating
if (siz > dbInfo.getAllocationSize()) {
// Calculate the space to be allocated
allocSize = siz - dbInfo.getAllocationSize();
// Allocate space to extend the file
quotaMgr.allocateSpace(sess, tree, file, allocSize);
} else {
// Calculate the space to be released as the file is to be truncated, release the space if
// the file truncation is successful
releaseSize = dbInfo.getAllocationSize() - siz;
}
}
// Set the file length
try {
jfile.truncateFile(siz);
}
catch (IOException ex) {
// Check if we allocated space to the file
if (allocSize > 0 && quotaMgr != null)
quotaMgr.releaseSpace(sess, tree, file.getFileId(), null, allocSize);
// Rethrow the exception
throw ex;
}
// Check if space has been released by the file resizing
if (releaseSize > 0 && quotaMgr != null)
quotaMgr.releaseSpace(sess, tree, file.getFileId(), null, releaseSize);
// Update the file information
if (allocSize > 0)
dbInfo.setAllocationSize(dbInfo.getAllocationSize() + allocSize);
else if (releaseSize > 0)
dbInfo.setAllocationSize(dbInfo.getAllocationSize() - releaseSize);
// Update the last file change date/time
try {
// Build the file information to set the change date/time
FileInfo finfo = new FileInfo();
finfo.setChangeDateTime(System.currentTimeMillis());
finfo.setFileInformationFlags(FileInfo.SetChangeDate);
// Set the file change date/time
dbCtx.getDBInterface().setFileInformation(jfile.getDirectoryId(), jfile.getFileId(), finfo);
// Update the cached file information
dbInfo.setChangeDateTime(finfo.getChangeDateTime());
dbInfo.setAllocationSize(siz);
}
catch (DBException ex) {
throw new IOException( "Failed to truncate " + file.getFullName(), ex);
}
}
}
/**
* Write a block of data to a file
*
* @param sess Session details
* @param tree Tree connection
* @param file Network file
* @param buf Data to be written
* @param bufoff Offset of data within the buffer
* @param siz Number of bytes to be written
* @param fileoff Offset within the file to start writing the data
*/
public int writeFile(SrvSession sess, TreeConnection tree, NetworkFile file, byte[] buf, int bufoff, int siz, long fileoff)
throws IOException {
// Debug
if (Debug.EnableInfo && hasDebug())
Debug.println("DB writeFile()");
// Access the JDBC context
DBDeviceContext dbCtx = (DBDeviceContext) tree.getContext();
// Check if the database is online
if (dbCtx.getDBInterface().isOnline() == false)
throw new DiskOfflineException("Database is offline");
// Check if the file loader is online
if (dbCtx.getFileLoader().isOnline() == false)
throw new DiskOfflineException("File loader is offline");
// Check that the network file is our type
if (file instanceof DBNetworkFile) {
// Access the JDBC network file
DBNetworkFile jfile = (DBNetworkFile) file;
// Check if there are any locks on the file
if (jfile.hasFileState() && jfile.getFileState().hasActiveLocks()) {
// Check if this session has write access to the required section of the file
if (jfile.getFileState().canWriteFile(fileoff, siz, sess.getProcessId()) == false)
throw new LockConflictException();
}
// Check if there is a maximum file size, if so then check if the write is beyond the allowed file size
if (dbCtx.hasMaximumFileSize() && (fileoff + siz) > dbCtx.getMaximumFileSize()) {
// Mark the file to delete on close
file.setDeleteOnClose(true);
// Return a disk full error
throw new DiskFullException("Write is beyond maximum allowed file size");
}
// Check if there is a quota manager
QuotaManager quotaMgr = dbCtx.getQuotaManager();
if (quotaMgr != null) {
// Get the file information
DBFileInfo finfo = getFileDetails(jfile.getFullName(), dbCtx, jfile.getFileState());
if (finfo == null)
throw new FileNotFoundException(jfile.getFullName());
// Check if the file requires extending
long extendSize = 0L;
long endOfWrite = fileoff + siz;
if (endOfWrite > finfo.getSize()) {
// Calculate the amount the file must be extended
extendSize = endOfWrite - finfo.getSize();
// Allocate space for the file extend
quotaMgr.allocateSpace(sess, tree, file, extendSize);
}
// Write to the file
try {
jfile.writeFile(buf, siz, bufoff, fileoff);
}
catch (IOException ex) {
// Check if we allocated space to the file
if (extendSize > 0 && quotaMgr != null)
quotaMgr.releaseSpace(sess, tree, file.getFileId(), null, extendSize);
// Rethrow the exception
throw ex;
}
// Update the file information
if (extendSize > 0)
finfo.setAllocationSize(MemorySize.roundupLongSize(endOfWrite));
} else {
// Write to the file
jfile.writeFile(buf, siz, bufoff, fileoff);
// Update the cached file size
DBFileInfo finfo = getFileDetails(jfile.getFullName(), dbCtx, jfile.getFileState());
if (finfo != null)
finfo.setFileSize( jfile.getFileSize());
}
}
// Return the actual write length
return siz;
}
/**
* Parse/validate the parameter string and create a device context for this share
*
* @param shareName String
* @param args ConfigElement
* @return DeviceContext
* @throws DeviceContextException Device context error
*/
public DeviceContext createContext(String shareName, ConfigElement args)
throws DeviceContextException {
// Check the arguments
if (args.getChildCount() < 3)
throw new DeviceContextException("Not enough context arguments");
// Check for the debug enable flags
if (args.getChild("Debug") != null)
m_debug = true;
// Create the database device context
DBDeviceContext ctx = new DBDeviceContext(args);
// Return the database device context
return ctx;
}
/**
* Get the file information for a path
*
* @param path String
* @param dbCtx DBDeviceContext
* @return DBFileInfo
*/
protected final DBFileInfo getFileDetails(String path, DBDeviceContext dbCtx) {
return getFileDetails(path, dbCtx, null);
}
/**
* Get the file information for a path
*
* @param path String
* @param dbCtx DBDeviceContext
* @param fstate FileState
* @return DBFileInfo
*/
protected final DBFileInfo getFileDetails(String path, DBDeviceContext dbCtx, FileState fstate) {
// Check if the file details are attached to the file state
if (fstate != null) {
// Return the file information
DBFileInfo finfo = (DBFileInfo) fstate.findAttribute(FileState.FileInformation);
if (finfo != null)
return finfo;
}
// Check for the root directory
if (path.length() == 0 || path.compareTo("\\") == 0) {
// Get the root directory information from the device context
DBFileInfo rootDir = dbCtx.getRootDirectoryInfo();
// Mark the directory as existing
if (fstate != null)
fstate.setFileStatus(FileStatus.DirectoryExists);
return rootDir;
}
// Split the path string and find the parent directory id
int dirId = findParentDirectoryId(dbCtx, path, true);
if (dirId == -1)
return null;
// Strip any trailing slash from the path
if (path.length() > 1 && path.endsWith(FileName.DOS_SEPERATOR_STR))
path = path.substring(0, path.length() - 1);
// Get the file name
String[] paths = FileName.splitPathStream(path);
String fname = paths[1];
String filePath = null;
if (paths[0] != null && paths[0].endsWith(FileName.DOS_SEPERATOR_STR) == false)
filePath = paths[0] + FileName.DOS_SEPERATOR_STR + paths[1];
else
filePath = paths[0] + paths[1];
// Get the file id for the specified file
int fid = getFileId(filePath, fname, dirId, dbCtx);
if (fid == -1) {
// Set the file status as not existing
if (fstate != null)
fstate.setFileStatus(FileStatus.NotExist);
return null;
}
// Create the file information
DBFileInfo finfo = getFileInfo(filePath, dirId, fid, dbCtx);
if (finfo != null && fstate != null) {
// Set various file state details
fstate.setFileStatus(finfo.isDirectory() ? FileStatus.DirectoryExists : FileStatus.FileExists);
fstate.setFileId(finfo.getFileId());
// Set the file name
finfo.setFileName(fname);
finfo.setFullName(path);
// Check if files should be marked as offline
if (dbCtx.hasOfflineFiles() && finfo.hasAttribute(FileAttribute.NTOffline) == false) {
if (dbCtx.getOfflineFileSize() == 0 || finfo.getSize() >= dbCtx.getOfflineFileSize())
finfo.setFileAttributes(finfo.getFileAttributes() + FileAttribute.NTOffline);
}
} else if (finfo == null && fstate != null) {
// Set the file status
fstate.setFileStatus(FileStatus.NotExist);
}
// Check if the path is a file stream
if (paths[2] != null) {
// Get the file information for the stream
finfo = getStreamInfo(fstate, paths, dbCtx);
}
// Return the file/stream information
return finfo;
}
/**
* Get the file id for a file
*
* @param path String
* @param name String
* @param dirId int
* @param dbCtx DBDeviceContext
* @return int
*/
protected final int getFileId(String path, String name, int dirId, DBDeviceContext dbCtx) {
// Check if the file is in the cache
FileStateCache cache = dbCtx.getStateCache();
FileState state = null;
if (cache != null) {
// Search for the file state
state = cache.findFileState(path);
if (state != null) {
// Check if the file id is cached
if (state.getFileId() != -1) {
// Debug
if (Debug.EnableInfo && hasDebug())
Debug.println("@@ Cache hit - getFileId() name=" + name);
// Return the file id
return state.getFileId();
} else if (state.getFileStatus() == FileStatus.NotExist) {
// DEBUG
if (Debug.EnableInfo && hasDebug())
Debug.println("@@ Cache hit - getFileStatus() name=" + name + ", sts=NotExist");
// Indicate that the file does not exist
return -1;
}
}
}
// Get the file id from the database
int fileId = -1;
try {
// Get the file id
fileId = dbCtx.getDBInterface().getFileId(dirId, name, false, true);
}
catch (DBException ex) {
Debug.println( ex);
}
// Update the cache entry, if available
if (state != null && fileId != -1)
state.setFileId(fileId);
// Return the file id, or -1 if the file was not found
return fileId;
}
/**
* Load the retention details for a file state, if enabled
*
* @param dbCtx DBDeviceContext
* @param fstate FileState
* @throws DBException Database error
*/
protected final void getRetentionDetailsForState(DBDeviceContext dbCtx, FileState fstate)
throws DBException {
// If retention is enabled get the expiry date/time
if (dbCtx.hasRetentionPeriod()) {
// Get the file retention expiry date/time
RetentionDetails retDetails = dbCtx.getDBInterface().getFileRetentionDetails(-1, fstate.getFileId());
if (retDetails != null)
fstate.setRetentionExpiryDateTime(retDetails.getEndTime());
}
}
/**
* Find the directory id for the parent directory in the specified path
*
* @param ctx DBDeviceContext
* @param path String
* @param filePath boolean
* @return int
*/
protected final int findParentDirectoryId(DBDeviceContext ctx, String path, boolean filePath) {
// Split the path
String[] paths = null;
if (path != null && path.startsWith( FileName.DOS_SEPERATOR_STR)) {
// Split the path
paths = FileName.splitPath(path);
} else {
// Add a leading slash to the path before parsing
paths = FileName.splitPath(FileName.DOS_SEPERATOR_STR + path);
}
if (paths[0] != null && paths[0].compareTo(FileName.DOS_SEPERATOR_STR) == 0 ||
paths[0].startsWith(FileName.DOS_SEPERATOR_STR) == false)
return RootDirId;
// Check if the file is in the cache
FileStateCache cache = ctx.getStateCache();
FileState state = null;
if (cache != null) {
// Search for the file state
state = cache.findFileState(paths[0]);
if (state != null && state.getFileId() != -1) {
// Debug
if (Debug.EnableInfo && hasDebug())
Debug.println("@@ Cache hit - findParentDirectoryId() path=" + paths[0]);
// Return the file id
return state.getFileId();
}
}
// Get the directory id list
int[] ids = findParentDirectoryIdList(ctx, path, filePath);
if (ids == null)
return -1;
// Check for the root directory id only
if (ids.length == 1)
return ids[0];
// Return the directory id of the last directory
int idx = ids.length - 1;
if (filePath == true && ids[ids.length - 1] == -1)
idx--;
return ids[idx];
}
/**
* Find the directory ids for the specified path list
*
* @param ctx DBDeviceContext
* @param path String
* @param filePath boolean
* @return int[]
*/
protected final int[] findParentDirectoryIdList(DBDeviceContext ctx, String path, boolean filePath) {
// Validate the paths and check for the root path
String[] paths = FileName.splitAllPaths(path);
if (paths == null || paths.length == 0)
return null;
if (paths[0].compareTo("*.*") == 0 || paths[0].compareTo("*") == 0 ||
(filePath == true && paths.length == 1)) {
int[] ids = {0};
return ids;
}
if (paths[0].startsWith("\\")) {
// Trim the leading slash from the first path
paths[0] = paths[0].substring(1);
}
// Find the directory id by traversing the list of directories
int endIdx = paths.length - 1;
if (filePath == true)
endIdx--;
// If there are no paths to check then return the root directory id
if (endIdx <= 1 && paths[0].length() == 0) {
int[] ids = new int[1];
ids[0] = 0;
return ids;
}
// Allocate the directory id list
int[] ids = new int[paths.length];
for (int i = 0; i < ids.length; i++)
ids[i] = -1;
// Build up the current path as we traverse the list
StringBuffer pathStr = new StringBuffer("\\");
// Check for paths in the file state cache
FileStateCache cache = ctx.getStateCache();
FileState fstate = null;
// Traverse the path list, initialize the directory id to the root id
int dirId = 0;
int parentId = -1;
int idx = 0;
try {
// Loop until the end of the path list
while (idx <= endIdx) {
// Get the current path, and add to the full path string
String curPath = paths[idx];
pathStr.append(curPath);
// Check if there is a file state for the current path
fstate = cache.findFileState(pathStr.toString());
if (fstate != null && fstate.getFileId() != -1) {
// Get the file id from the cached information
ids[idx] = fstate.getFileId();
parentId = dirId;
dirId = ids[idx];
} else {
// Search for the current directory in the database
parentId = dirId;
dirId = ctx.getDBInterface().getFileId(dirId, curPath, true, true);
if (dirId != -1) {
// Get the next directory id
ids[idx] = dirId;
// Check if we have a file state, or create a new file state for the current path
if (fstate != null) {
// Set the file id for the file state
fstate.setFileId(dirId);
} else {
// Create a new file state for the current path
fstate = cache.findFileState(pathStr.toString(), true);
// Get the file information
DBFileInfo finfo = ctx.getDBInterface().getFileInformation(parentId, dirId, DBInterface.FileInfoLevel.All);
fstate.addAttribute(FileState.FileInformation, finfo);
fstate.setFileStatus(finfo.isDirectory() ? FileStatus.DirectoryExists : FileStatus.FileExists);
fstate.setFileId(dirId);
}
} else
return null;
}
// Update the path index
idx++;
// Update the current path string
pathStr.append("\\");
}
}
catch (DBException ex) {
Debug.println(ex);
return null;
}
// Return the directory id list
return ids;
}
/**
* Return file information about the specified file, using the internal file id
*
* @param path String
* @param dirId int
* @param fid int
* @param dbCtx DBDeviceContext
* @return DBFileInfo
*/
public DBFileInfo getFileInfo(String path, int dirId, int fid, DBDeviceContext dbCtx) {
// Check if the file is in the cache
FileState state = getFileState(path, dbCtx, true);
if (state != null && state.getFileId() != -1) {
// Debug
if (Debug.EnableInfo && hasDebug())
Debug.println("@@ Cache hit - getFileInfo() path=" + path);
// Return the file information
DBFileInfo finfo = (DBFileInfo) state.findAttribute(FileState.FileInformation);
if (finfo != null)
return finfo;
}
// Get the file information from the database
DBFileInfo finfo = null;
try {
// Get the file information
finfo = dbCtx.getDBInterface().getFileInformation(dirId, fid, DBInterface.FileInfoLevel.All);
}
catch (DBException ex) {
Debug.println(ex);
finfo = null;
}
// Set the full path for the file
if (finfo != null)
finfo.setFullName(path);
// Update the cached information, if available
if (state != null && finfo != null) {
state.addAttribute(FileState.FileInformation, finfo);
state.setFileStatus(finfo.isDirectory() ? FileStatus.DirectoryExists : FileStatus.FileExists);
}
// Return the file information
return finfo;
}
/**
* Get the details for a file stream
*
* @param parent FileState
* @param paths String[]
* @param dbCtx DBDeviceContext
* @return DBFileInfo
*/
public DBFileInfo getStreamInfo(FileState parent, String[] paths, DBDeviceContext dbCtx) {
// Check if the file is in the cache
String streamPath = paths[0] + paths[1] + paths[2];
FileState state = getFileState(streamPath, dbCtx, true);
if (state != null && state.getFileId() != -1) {
// Debug
if (Debug.EnableInfo && hasDebug())
Debug.println("@@ Cache hit - getStreamInfo() path=" + streamPath);
// Return the file information
DBFileInfo finfo = (DBFileInfo) state.findAttribute(FileState.FileInformation);
if (finfo != null)
return finfo;
}
// DEBUG
if (Debug.EnableInfo && hasDebug())
Debug.println("DBDiskDriver getStreamInfo parent=" + parent.getPath() + ", stream=" + paths[2]);
// Get a list of the streams for the parent file
DBFileInfo finfo = null;
try {
// Get the list of streams
StreamInfoList sList = (StreamInfoList) parent.findAttribute(DBStreamList);
if (sList == null) {
// No cached stream information, get the list from the database
sList = dbCtx.getDBInterface().getStreamsList(parent.getFileId(), DBInterface.StreamInfoLevel.All);
// Cache the information
parent.addAttribute(DBStreamList, sList);
}
// Find the required stream information
if (sList != null) {
// Find the required stream information
StreamInfo sInfo = sList.findStream(paths[2]);
// Convert the stream information to file information
if (sInfo != null) {
// Load the stream information
finfo = new DBFileInfo();
finfo.setFileId(parent.getFileId());
// Copy the stream information
finfo.setFileName(sInfo.getName());
finfo.setSize(sInfo.getSize());
// Get the file creation date, or use the current date/time
if (sInfo.hasCreationDateTime())
finfo.setCreationDateTime(sInfo.getCreationDateTime());
// Get the modification date, or use the current date/time
if (sInfo.hasModifyDateTime())
finfo.setModifyDateTime(sInfo.getModifyDateTime());
else if (sInfo.hasCreationDateTime())
finfo.setModifyDateTime(sInfo.getCreationDateTime());
// Get the last access date, or use the current date/time
if (sInfo.hasAccessDateTime())
finfo.setAccessDateTime(sInfo.getAccessDateTime());
else if (sInfo.hasCreationDateTime())
finfo.setAccessDateTime(sInfo.getCreationDateTime());
}
}
}
catch (DBException ex) {
Debug.println(ex);
finfo = null;
}
// Set the full path for the file
if (finfo != null)
finfo.setFullName(streamPath);
// Update the cached information, if available
if (state != null && finfo != null) {
state.addAttribute(FileState.FileInformation, finfo);
state.setFileStatus(FileStatus.FileExists);
}
// Return the file information for the stream
return finfo;
}
/**
* Get the cached file state for the specified path
*
* @param path String
* @param ctx DBDeviceContext
* @param create boolean
* @return FileState
*/
protected final FileState getFileState(String path, DBDeviceContext ctx, boolean create) {
// Access the file state cache
FileStateCache cache = ctx.getStateCache();
if (cache == null)
return null;
// Return the required file state
return cache.findFileState(path, create);
}
/**
* Update the parent folder path file information last write and change timestamps
*
* @param path String
* @param ctx DBDeviceContext
*/
protected final void updateParentFolderTimestamps(String path, DBDeviceContext ctx) {
// Get the parent folder path
String parentPath = FileName.removeFileName( path);
if ( parentPath == null)
return;
// Get the file state for the parent folder, or create it
FileState fstate = getFileState( parentPath, ctx, true);
if ( fstate != null) {
// Update the cached last write and change timestamps for the folder
long updTime = System.currentTimeMillis();
fstate.updateModifyDateTime( updTime);
fstate.updateChangeDateTime( updTime);
// Update the cached file information, if available
DBFileInfo finfo = (DBFileInfo) fstate.findAttribute(FileState.FileInformation);
if (finfo != null) {
// Update the file information timestamps
finfo.setModifyDateTime( updTime);
finfo.setChangeDateTime( updTime);
}
// DEBUG
// if ( hasDebug()) {
// Debug.println("$$$ Update parent folder path=" + parentPath + ", fstate=" + fstate);
// ctx.getStateCache().dumpCache( true);
// }
}
}
/**
* Connection opened to this disk device
*
* @param sess Server session
* @param tree Tree connection
*/
public void treeOpened(SrvSession sess, TreeConnection tree) {
}
/**
* Connection closed to this device
*
* @param sess Server session
* @param tree Tree connection
*/
public void treeClosed(SrvSession sess, TreeConnection tree) {
}
/**
* Check if general debug output is enabled
*
* @return boolean
*/
protected final boolean hasDebug() {
return m_debug;
}
/**
* Return disk information about a shared filesystem
*
* @param ctx DiskDeviceContext
* @param info SrvDiskInfo
* @throws IOException If an error occurs.
*/
public final void getDiskInformation(DiskDeviceContext ctx, SrvDiskInfo info)
throws IOException {
// Check if there is static disk size information available
if (ctx.hasDiskInformation())
info.copyFrom(ctx.getDiskInformation());
// Check that the context is a JDBC context
if (ctx instanceof DBDeviceContext) {
// Access the associated file loader class, if it implements the disk size interface then call the loader
// to fill in the disk size details
DBDeviceContext dbCtx = (DBDeviceContext) ctx;
if (dbCtx.getFileLoader() instanceof DiskSizeInterface) {
// Pass the disk size request to the associated file loader
DiskSizeInterface sizeInterface = (DiskSizeInterface) dbCtx.getFileLoader();
sizeInterface.getDiskInformation(ctx, info);
// DEBUG
if (Debug.EnableInfo && hasDebug())
Debug.println("DBDiskDriver getDiskInformation() handed to file loader");
}
}
// Check if there is a quota manager, if so then get the current free space from the quota manager
if (ctx.hasQuotaManager()) {
// Get the free space, in bytes, from the quota manager
long freeSpace = ctx.getQuotaManager().getAvailableFreeSpace();
// Convert the free space to free units
long freeUnits = freeSpace / info.getUnitSize();
info.setFreeUnits(freeUnits);
}
}
/**
* Determine if NTFS streams support is enabled. Check if the associated file loader
* supports NTFS streams.
*
* @param sess SrvSession
* @param tree TreeConnection
* @return boolean
*/
public boolean hasStreamsEnabled(SrvSession sess, TreeConnection tree) {
// Check that the context is a JDBC context
if (tree.getContext() instanceof DBDeviceContext) {
// Access the associated file loader class to check if it supports NTFS streams
DBDeviceContext dbCtx = (DBDeviceContext) tree.getContext();
if (dbCtx.hasNTFSStreamsEnabled()) {
// Check if the file loader supports NTFS streams
return dbCtx.getFileLoader().supportsStreams();
}
}
// Disable streams
return false;
}
/**
* Get the stream information for the specified file stream
*
* @param sess SrvSession
* @param tree TreeConnection
* @param streamInfo StreamInfo
* @return StreamInfo
* @throws IOException If an error occurs.
*/
public StreamInfo getStreamInformation(SrvSession sess, TreeConnection tree, StreamInfo streamInfo)
throws IOException {
// DEBUG
if (Debug.EnableInfo && hasDebug())
Debug.println("### getStreamInformation() called ###");
return null;
}
/**
* Return the list of available streams for the specified file
*
* @param sess SrvSession
* @param tree TreeConnection
* @param fileName String
* @return StreamInfoList
* @throws IOException If an error occurs.
*/
public StreamInfoList getStreamList(SrvSession sess, TreeConnection tree, String fileName)
throws IOException {
// Access the JDBC context
DBDeviceContext dbCtx = (DBDeviceContext) tree.getContext();
// Get the file state for the top level file
String parentPath = FileName.getParentPathForStream(fileName);
FileState fstate = getFileState(parentPath, dbCtx, true);
// Check if the file state already has the streams list cached
StreamInfoList streamList = (StreamInfoList) fstate.findAttribute(DBStreamList);
if (streamList != null && streamList.numberOfStreams() > 0)
return streamList;
// Get the main file information and convert to stream information
DBFileInfo finfo = getFileDetails(fileName, dbCtx, fstate);
if (finfo == null)
return null;
// Create the stream list
streamList = new StreamInfoList();
// Add an entry for the main file data stream
StreamInfo sinfo = new StreamInfo("::$DATA", finfo.getFileId(), 0, finfo.getSize(), finfo.getAllocationSize());
streamList.addStream(sinfo);
// Get the list of streams
StreamInfoList sList = loadStreamList(fstate, finfo, dbCtx, true);
if (sList != null) {
// Copy the stream information to the main list
for (int i = 0; i < sList.numberOfStreams(); i++) {
// Add the stream to the main list
streamList.addStream(sList.getStreamAt(i));
}
}
// Cache the stream list
fstate.addAttribute(DBStreamList, streamList);
// Return the stream list
return streamList;
}
/**
* Create a new stream with the specified parent file
*
* @param sess SrvSession
* @param tree TreeConnection
* @param params FileOpenParams
* @param parent FileState
* @param dbCtx DBDeviceContext
* @return NetworkFile
* @throws IOException If an error occurs.
*/
protected final NetworkFile createStream(SrvSession sess, TreeConnection tree, FileOpenParams params, FileState parent, DBDeviceContext dbCtx)
throws IOException {
// Get the file information for the parent file
DBFileInfo finfo = getFileDetails(params.getPath(), dbCtx, parent);
if (finfo == null)
throw new AccessDeniedException();
// Get the list of streams for the file
StreamInfoList streamList = (StreamInfoList) parent.findAttribute(DBStreamList);
if (streamList == null)
streamList = getStreamList(sess, tree, params.getPath());
if (streamList == null)
throw new AccessDeniedException();
// Check if the stream already exists
if (streamList.findStream(params.getStreamName()) != null)
throw new FileExistsException("Stream exists, " + params.getFullPath());
// Create a new stream record
DBNetworkFile file = null;
FileAccessToken accessToken = null;
FileState fstate = null;
try {
// Check if the file can be opened in the requested mode
fstate = getFileState(params.getFullPath(), dbCtx, true);
accessToken = dbCtx.getStateCache().grantFileAccess(params, fstate, FileStatus.FileExists);
// Create a new stream record
int stid = dbCtx.getDBInterface().createStreamRecord(params.getStreamName(), finfo.getFileId());
// Create a network file to hold details of the new stream
file = (DBNetworkFile) dbCtx.getFileLoader().openFile(params, finfo.getFileId(), stid, finfo.getDirectoryId(), true, false);
file.setFullName(params.getFullPath());
file.setStreamId(stid);
file.setStreamName(params.getStreamName());
file.setDirectoryId(finfo.getDirectoryId());
file.setAttributes(params.getAttributes());
// Set the file state for the file
file.setFileState(dbCtx.getStateCache().getFileStateProxy(fstate));
// Store the access token
file.setAccessToken(accessToken);
// Open the stream file
file.openFile(true);
// Add an entry to the stream list for the new stream
StreamInfo stream = new StreamInfo(params.getStreamName(), file.getFileId(), stid);
streamList.addStream(stream);
// DEBUG
if (Debug.EnableInfo && hasDebug())
Debug.println("createStream() file=" + params.getPath() + ", stream=" + params.getStreamName() + ", fid/stid=" + file.getFileId() + "/" + stid);
}
catch (DBException ex) {
if (Debug.EnableError && hasDebug()) {
Debug.println("Error: " + ex.toString());
Debug.println(ex);
}
}
finally {
// Check if the stream file is not valid but an access token has been allocated
if (file == null && accessToken != null)
dbCtx.getStateCache().releaseFileAccess(fstate, accessToken);
}
// If the file/stream is not valid throw an exception
if (file == null)
throw new AccessDeniedException(params.getFullPath());
// Return the network file for the new stream
return file;
}
/**
* Open an existing stream with the specified parent file
*
* @param sess SrvSession
* @param tree TreeConnection
* @param params FileOpenParams
* @param parent FileState
* @param dbCtx DBDeviceContext
* @return NetworkFile
* @throws IOException If an error occurs.
*/
protected final NetworkFile openStream(SrvSession sess, TreeConnection tree, FileOpenParams params, FileState parent, DBDeviceContext dbCtx)
throws IOException {
// Get the file information for the parent file
DBFileInfo finfo = getFileDetails(params.getPath(), dbCtx, parent);
if (finfo == null)
throw new AccessDeniedException();
// Get the list of streams for the file
StreamInfoList streamList = getStreamList(sess, tree, params.getPath());
if (streamList == null)
throw new AccessDeniedException();
// Check if the stream exists
StreamInfo sInfo = streamList.findStream(params.getStreamName());
if (sInfo == null)
throw new FileNotFoundException("Stream does not exist, " + params.getFullPath());
// Open the stream
DBNetworkFile jdbcFile = null;
FileAccessToken accessToken = null;
FileState fstate = null;
try {
// Get, or create, a file state for the stream
fstate = getFileState(params.getFullPath(), dbCtx, true);
// Check if the file stream can be opened in the requested mode
accessToken = dbCtx.getStateCache().grantFileAccess(params, fstate, FileStatus.FileExists);
// Check if the file shared access indicates exclusive file access
if (params.getSharedAccess() == SharingMode.NOSHARING && fstate.getOpenCount() > 0 &&
params.getProcessId() != fstate.getProcessId())
throw new FileSharingException("File already open, " + params.getPath());
// Set the file information for the stream, using the stream information
DBFileInfo sfinfo = new DBFileInfo(sInfo.getName(), params.getFullPath(), finfo.getFileId(), finfo.getDirectoryId());
sfinfo.setFileSize(sInfo.getSize());
sfinfo.setFileAttributes(FileAttribute.Normal);
sfinfo.setCreationDateTime(sInfo.getCreationDateTime());
sfinfo.setModifyDateTime(sInfo.getModifyDateTime());
sfinfo.setAccessDateTime(sInfo.getAccessDateTime());
fstate.addAttribute(FileState.FileInformation, sfinfo);
// Create a JDBC network file and open the stream
if (Debug.EnableInfo && hasDebug())
Debug.println("DB openStream() file=" + params.getPath() + ", stream=" + sInfo.getName());
jdbcFile = (DBNetworkFile) dbCtx.getFileLoader().openFile(params, finfo.getFileId(), sInfo.getStreamId(),
finfo.getDirectoryId(), false, false);
jdbcFile.setFileState(dbCtx.getStateCache().getFileStateProxy(fstate));
jdbcFile.setFileDetails(sfinfo);
// Open the stream file, if not a directory
jdbcFile.openFile(false);
}
finally {
// Check if the stream file is not valid but an access token has been allocated
if (jdbcFile == null && accessToken != null)
dbCtx.getStateCache().releaseFileAccess(fstate, accessToken);
}
// Return the network file
return jdbcFile;
}
/**
* Close an NTFS stream
*
* @param sess Session details
* @param tree Tree connection
* @param stream Network file details
* @throws IOException If an error occurs.
*/
protected final void closeStream(SrvSession sess, TreeConnection tree, NetworkFile stream)
throws IOException {
// Debug
if (Debug.EnableInfo && hasDebug())
Debug.println("DB closeStream() file=" + stream.getFullName() + ", stream=" + stream.getStreamName() +
", fid/stid=" + stream.getFileId() + "/" + stream.getStreamId());
// Access the JDBC context
DBDeviceContext dbCtx = (DBDeviceContext) tree.getContext();
// Close the file
dbCtx.getFileLoader().closeFile(sess, stream);
// Access the JDBC file
DBNetworkFile jdbcFile = null;
if (stream instanceof DBNetworkFile) {
// Access the JDBC file
jdbcFile = (DBNetworkFile) stream;
// Decrement the open file count
FileState fstate = jdbcFile.getFileState();
// Check if the file state is valid, if not then check the main file state cache
if (fstate == null) {
// Check the main file state cache
fstate = getFileState(stream.getFullName(), dbCtx, false);
}
// Release the file access token for the stream
if (jdbcFile.hasAccessToken()) {
// Release the access token, update the open file count
dbCtx.getStateCache().releaseFileAccess(fstate, jdbcFile.getAccessToken());
}
// Check if we have a valid file state
if (fstate != null) {
// Update the cached file size
FileInfo finfo = getFileInformation(sess, tree, fstate.getPath());
if (finfo != null && stream.getWriteCount() > 0) {
// Update the file size
finfo.setSize(jdbcFile.getFileSize());
// Update the modified date/time
finfo.setModifyDateTime(jdbcFile.getModifyDate());
// DEBUG
if (Debug.EnableInfo && hasDebug())
Debug.println(" Stream size=" + jdbcFile.getFileSize() + ", modifyDate=" + jdbcFile.getModifyDate());
}
}
} else
Debug.println("closeFile() Not DBNetworkFile file=" + stream);
// Check if the stream was opened for write access, if so then update the stream size
if (stream.getGrantedAccess() != NetworkFile.Access.READ_ONLY && stream.isDirectory() == false &&
stream.getWriteCount() > 0) {
// DEBUG
if (Debug.EnableInfo && hasDebug())
Debug.println(" Update stream size=" + stream.getFileSize());
// Get the current date/time
long modifiedTime = 0L;
if (stream.hasModifyDate())
modifiedTime = stream.getModifyDate();
else
modifiedTime = System.currentTimeMillis();
// Check if the modified time is earlier than the file creation date/time
if (stream.hasCreationDate() && modifiedTime < stream.getCreationDate()) {
// Use the creation date/time for the modified date/time
modifiedTime = stream.getCreationDate();
// DEBUG
if (Debug.EnableInfo && hasDebug())
Debug.println("Close stream using creation date/time for modified date/time");
}
// Update the in-memory stream information
String parentPath = FileName.getParentPathForStream(stream.getFullName());
FileState parent = getFileState(parentPath, dbCtx, false);
StreamInfo sInfo = null;
int sattr = 0;
if (parent != null) {
// Check if the stream list has been loaded
StreamInfoList streamList = getStreamList(sess, tree, parentPath);
if (streamList != null) {
// Find the stream information
sInfo = streamList.findStream(stream.getStreamName());
if (sInfo != null) {
// Update the stream size
sInfo.setSize(stream.getFileSize());
sattr += StreamInfo.SetStreamSize;
// DEBUG
if (Debug.EnableInfo && hasDebug())
Debug.println("Updated stream file size");
} else {
// DEBUG
if (Debug.EnableInfo && hasDebug())
Debug.println("** Failed to find details for stream " + stream.getStreamName());
}
} else {
// DEBUG
if (Debug.EnableInfo && hasDebug())
Debug.println("** Failed to get streams list for " + parentPath);
}
}
// Update the file details for the file stream in the database
try {
// Check if the file strea, details are valid
if (sInfo == null) {
// Create the stream information
sInfo = new StreamInfo();
sInfo.setSize(stream.getFileSize());
sInfo.setStreamId(stream.getStreamId());
sattr += StreamInfo.SetStreamSize;
}
// Set the modify date/time for the stream
sInfo.setModifyDateTime(System.currentTimeMillis());
sattr += StreamInfo.SetModifyDate;
// Set the stream information values to be updated
sInfo.setStreamInformationFlags(sattr);
// Update the stream details
dbCtx.getDBInterface().setStreamInformation(stream.getDirectoryId(), stream.getFileId(), stream.getStreamId(), sInfo);
}
catch (DBException ex) {
throw new IOException( "Failed to close stream " + stream.getFullName(), ex);
}
}
}
/**
* Delete a stream within a file
*
* @param sess SrvSession
* @param tree TreeConnection
* @param name String
* @throws IOException If an error occurs.
*/
protected final void deleteStream(SrvSession sess, TreeConnection tree, String name)
throws IOException {
// Access the JDBC context
DBDeviceContext dbCtx = (DBDeviceContext) tree.getContext();
// Get, or create, the file state for main file path and stream
String filePath = FileName.getParentPathForStream(name);
FileState fstate = getFileState(filePath, dbCtx, true);
FileState sstate = getFileState(name, dbCtx, false);
// Check if the file is within an active retention period
if (fstate.hasActiveRetentionPeriod())
throw new AccessDeniedException("File retention active");
// Get the top level file information
DBFileInfo finfo = getFileDetails(filePath, dbCtx, fstate);
// Get the stream list for the top level file
StreamInfoList streamList = (StreamInfoList) fstate.findAttribute(DBStreamList);
if (streamList == null)
streamList = getStreamList(sess, tree, filePath);
if (streamList == null)
throw new FileNotFoundException("Stream not found, " + name);
// Parse the path string to get the directory, file name and stream name
String[] paths = FileName.splitPathStream(name);
// Find the required stream details
StreamInfo sInfo = streamList.findStream(paths[2]);
if (sInfo == null)
throw new FileNotFoundException("Stream not found, " + name);
// Delete the stream record from the database
try {
// Call the file loader to delete the stream data
dbCtx.getFileLoader().deleteFile(name, sInfo.getFileId(), sInfo.getStreamId());
// Delete the stream record
dbCtx.getDBInterface().deleteStreamRecord(sInfo.getFileId(), sInfo.getStreamId(), dbCtx.isTrashCanEnabled());
// Remove the stream information from the in memory list
streamList.removeStream(sInfo.getName());
// Set the streams file state to indicate that it does not exist
if (sstate != null)
sstate.setFileStatus(FileStatus.NotExist);
}
catch (DBException ex) {
throw new IOException( "Failed to delete stream " + name, ex);
}
}
/**
* Load the stream list for the specified file
*
* @param fstate FileState
* @param finfo DBFileInfo
* @param dbCtx DBDeviceContext
* @param dbLoad boolean
* @return StreamInfoList
*/
protected final StreamInfoList loadStreamList(FileState fstate, DBFileInfo finfo, DBDeviceContext dbCtx, boolean dbLoad) {
// Check if the stream list has already been loaded
StreamInfoList sList = (StreamInfoList) fstate.findAttribute(FileState.StreamsList);
// If the streams list is not loaded then load it from the database
if (sList == null && dbLoad == true) {
// Load the streams list from the database, if NTFS streams are enabled
try {
// Load the streams list
sList = dbCtx.getDBInterface().getStreamsList(finfo.getFileId(), DBInterface.StreamInfoLevel.All);
// Cache the streams list via the parent file state
if (sList != null)
fstate.addAttribute(DBStreamList, sList);
}
catch (DBException ex) {
Debug.println(ex);
}
}
// Return the streams list
return sList;
}
/**
* Rename a stream
*
* @param sess SrvSession
* @param tree TreeConnection
* @param oldName String
* @param newName String
* @param overWrite boolean
* @throws IOException If an error occurs.
*/
public void renameStream(SrvSession sess, TreeConnection tree, String oldName, String newName, boolean overWrite)
throws IOException {
}
/**
* Return the volume information
*
* @param ctx DiskDeviceContext
* @return VolumeInfo
*/
public VolumeInfo getVolumeInformation(DiskDeviceContext ctx) {
// Check if the context has volume information
VolumeInfo volInfo = ctx.getVolumeInformation();
if (volInfo == null) {
// Create volume information for the filesystem
volInfo = new VolumeInfo(ctx.getDeviceName());
// Add to the device context
ctx.setVolumeInformation(volInfo);
}
// Check if the serial number is valid
if (volInfo.getSerialNumber() == 0) {
// Generate a random serial number
volInfo.setSerialNumber(new java.util.Random().nextInt());
}
// Check if the creation date is valid
if (volInfo.hasCreationDateTime() == false) {
// Set the creation date to now
volInfo.setCreationDateTime(new java.util.Date());
}
// Return the volume information
return volInfo;
}
/**
* Return the lock manager implementation
*
* @param sess SrvSession
* @param tree TreeConnection
* @return LockManager
*/
public LockManager getLockManager(SrvSession sess, TreeConnection tree) {
// Access the context
DBDeviceContext dbCtx = (DBDeviceContext) tree.getContext();
return dbCtx.getFileStateLockManager();
}
/**
* Return the oplock manager implementation
*
* @param sess SrvSession
* @param tree TreeConnection
* @return OpLockManager
*/
public OpLockManager getOpLockManager(SrvSession sess, TreeConnection tree) {
// Access the context
DBDeviceContext dbCtx = (DBDeviceContext) tree.getContext();
return dbCtx.getFileStateLockManager();
}
/**
* Enable/disable oplock support
*
* @param sess SrvSession
* @param tree TreeConnection
* @return boolean
*/
public boolean isOpLocksEnabled(SrvSession sess, TreeConnection tree) {
// Access the context
DBDeviceContext dbCtx = (DBDeviceContext) tree.getContext();
return dbCtx.isOpLocksEnabled();
}
/**
* Convert a file id to a share relative path
*
* @param sess SrvSession
* @param tree TreeConnection
* @param dirid int
* @param fileid int
* @return String
* @throws FileNotFoundException File not found
*/
public String buildPathForFileId(SrvSession sess, TreeConnection tree, int dirid, int fileid)
throws FileNotFoundException {
// Access the JDBC context
DBDeviceContext dbCtx = (DBDeviceContext) tree.getContext();
// Build an array of folder names working back from the files id
ArrayList names = new ArrayList(16);
try {
// Loop, walking backwards up the tree until we hit root
int curFid = fileid;
int curDid = dirid;
FileInfo finfo = null;
do {
// Search for the current file in the database
finfo = dbCtx.getDBInterface().getFileInformation(curDid, curFid, DBInterface.FileInfoLevel.Ids);
if (finfo != null) {
// Get the filename
names.add(finfo.getFileName());
// The directory id becomes the next file id to search for
curFid = finfo.getDirectoryId();
curDid = -1;
} else
throw new FileNotFoundException("" + curFid);
} while (curFid > RootDirId);
}
catch (DBException ex) {
Debug.println(ex);
return null;
}
// Build the path string
StringBuilder pathStr = new StringBuilder(256);
pathStr.append(FileName.DOS_SEPERATOR_STR);
for (int i = names.size() - 1; i >= 0; i--) {
pathStr.append(names.get(i));
pathStr.append(FileName.DOS_SEPERATOR_STR);
}
// Remove the trailing slash from the path
if (pathStr.length() > 0)
pathStr.setLength(pathStr.length() - 1);
// Return the path string
return pathStr.toString();
}
/**
* Determine if symbolic links are enabled
*
* @param sess SrvSession
* @param tree TreeConnection
* @return boolean
*/
public boolean hasSymbolicLinksEnabled(SrvSession sess, TreeConnection tree) {
// Access the associated database interface to check if it supports symbolic links
DBDeviceContext dbCtx = (DBDeviceContext) tree.getContext();
if (dbCtx.getDBInterface().supportsFeature(DBInterface.Feature.SymLinks)) {
// Database interface supports symbolic links
return true;
}
// Symbolic links not supported
return false;
}
/**
* Read the link data for a symbolic link
*
* @param sess SrvSession
* @param tree TreeConnection
* @param path String
* @return String
* @throws AccessDeniedException Access denied
* @throws FileNotFoundException File not found
*/
public String readSymbolicLink(SrvSession sess, TreeConnection tree, String path)
throws AccessDeniedException, FileNotFoundException {
// Access the associated database interface to check if it supports symbolic links
DBDeviceContext dbCtx = (DBDeviceContext) tree.getContext();
DBInterface dbInterface = dbCtx.getDBInterface();
String symLink = null;
if (dbInterface.supportsFeature(DBInterface.Feature.SymLinks)) {
// Get, or create, the file state for the existing file
FileState fstate = getFileState(path, dbCtx, true);
// Get the file id of the existing file
int fid = fstate.getFileId();
int dirId = -1;
if (fid == -1) {
// Split the current path string and find the file id of the existing file/directory
dirId = findParentDirectoryId(dbCtx, path, true);
if (dirId == -1)
throw new FileNotFoundException(path);
// Get the file/directory name
String[] oldPaths = FileName.splitPath(path);
String fname = oldPaths[1];
// Get the file id
fid = getFileId(path, fname, dirId, dbCtx);
if (fid == -1)
throw new FileNotFoundException(path);
// Update the file state
fstate.setFileId(fid);
}
try {
// Database interface supports symbolic links, read the symbolic link
symLink = dbInterface.readSymbolicLink(dirId, fid);
}
catch (DBException ex) {
throw new FileNotFoundException(path + ":" + ex.getMessage());
}
}
// Return the symbolic link data
return symLink;
}
/**
* Return the security descriptor length for the specified file
*
* @param sess Server session
* @param tree Tree connection
* @param netFile Network file
* @return int
* @throws SMBSrvException SMB error
*/
public int getSecurityDescriptorLength(SrvSession sess, TreeConnection tree, NetworkFile netFile)
throws SMBSrvException {
return 0;
}
/**
* Load a security descriptor for the specified file
*
* @param sess Server session
* @param tree Tree connection
* @param netFile Network file
* @return SecurityDescriptor
* @throws SMBSrvException SMB error
*/
public SecurityDescriptor loadSecurityDescriptor(SrvSession sess, TreeConnection tree, NetworkFile netFile)
throws SMBSrvException {
return null;
}
/**
* Save the security descriptor for the specified file
*
* @param sess Server session
* @param tree Tree connection
* @param netFile Network file
* @param secDesc Security descriptor
* @throws SMBSrvException SMB error
*/
public void saveSecurityDescriptor(SrvSession sess, TreeConnection tree, NetworkFile netFile, SecurityDescriptor secDesc)
throws SMBSrvException {
}
/**
* Post close the file, called after the protocol layer has sent the close response to the client.
*
* @param sess Server session
* @param tree Tree connection.
* @param netFile Network file context.
* @throws IOException If an error occurs.
*/
public void postCloseFile(SrvSession sess, TreeConnection tree, NetworkFile netFile)
throws IOException
{
// Close the file
doCloseFile(sess, tree, netFile);
}
}