src.com.ibm.as400.access.IFSFileDescriptorImplRemote Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jt400 Show documentation
Show all versions of jt400 Show documentation
The Open Source version of the IBM Toolbox for Java
///////////////////////////////////////////////////////////////////////////////
//
// JTOpen (IBM Toolbox for Java - OSS version)
//
// Filename: IFSFileDescriptorImplRemote.java
//
// The source code contained herein is licensed under the IBM Public License
// Version 1.0, which has been approved by the Open Source Initiative.
// Copyright (C) 1997-2000 International Business Machines Corporation and
// others. All rights reserved.
//
///////////////////////////////////////////////////////////////////////////////
// @A3 - 10/18/2007 - Update finalize0() method to not send TWO close requests
// to the server. When garbage collection finds a descriptor
// that has not been closed, it calls the finalize method on
// one of the various IFSFilexxx classes which calls the
// finalize0() method of this class.
// This class was sending TWO close requests to the server
// for the same fileHandle_. Normally, the second close would
// silently fail. However, in some cases another thread might
// issue an open request for another file BETWEEN the two close
// requests sent by the garbage collection thread. This
// results in the newly opened file being incorrectly closed.
// Fix to finalize0() is to issue ONE close request to the
// File server.
///////////////////////////////////////////////////////////////////////////////
package com.ibm.as400.access;
import java.io.IOException;
import java.io.InterruptedIOException;
import java.util.Vector;
/**
Provides a full remote implementation for the IFSFileDescriptor class.
**/
class IFSFileDescriptorImplRemote
implements IFSFileDescriptorImpl
{
private static final int UNINITIALIZED = -1; // @B8a
private static final int MAX_BYTES_PER_READ = 16000000; // limit of file server
// Note: We allow direct access to some of these fields, for performance. @B2C
ConverterImplRemote converter_;
private int fileHandle_ = UNINITIALIZED; // @B8c
int preferredServerCCSID_;
private int fileDataCCSID_ = UNINITIALIZED;
private int fileAsp_ = UNINITIALIZED;//@V4A
private int fileSystemType_ = UNINITIALIZED;//@V4A
int serverDatastreamLevel_; // @B3A
int requestedDatastreamLevel_; // @B6a
private long fileOffset_;
boolean isOpen_;
boolean isOpenAllowed_ = true;
private Object parent_; // The object that instantiated this IFSDescriptor.
String path_ = "";
byte[] pathnameBytes_;
transient Object serverLock_ = new Object();
AS400Server server_; // Note: AS400Server is not serializable.
private int shareOption_;
AS400ImplRemote system_;
private Object fileOffsetLock_ = new Object();
// Semaphore for synchronizing access to fileOffset_.
private int maxDataBlockSize_ = 1024; // @B2A
// Used by IFSFileOutputStreamImplRemote, IFSRandomAccessFileImplRemote.
private boolean determinedSystemVRM_ = false; // @B3A @B4C
private int systemVRM_; // @B3A @B4C
transient int errorRC_; // error return code from most recent request
int patternMatching_ = IFSFile.PATTERN_DEFAULT; // pattern-matching semantics
// Used for debugging only. This should always be false for production.
// When this is false, all debug code will theoretically compile out.
private static final boolean DEBUG = false; // @B3A
//@AC7 Start
String fileOwnerName_ = null;
boolean isDirectory_ = false;
//@AC7 End
// Static initialization code.
static
{
// Add all byte stream reply data streams of interest to the
// AS400 server's reply data stream hash table.
AS400Server.addReplyStream(new IFSCloseRep(), AS400.FILE);
AS400Server.addReplyStream(new IFSExchangeAttrRep(), AS400.FILE);
AS400Server.addReplyStream(new IFSLockBytesRep(), AS400.FILE);
AS400Server.addReplyStream(new IFSReturnCodeRep(), AS400.FILE);
AS400Server.addReplyStream(new IFSWriteRep(), AS400.FILE);
AS400Server.addReplyStream(new IFSReadRep(), AS400.FILE);
}
// Cast an IFSFileDescriptorImpl object into an IFSFileDescriptorImplRemote.
// Used by various IFS*ImplRemote classes.
static IFSFileDescriptorImplRemote castImplToImplRemote(IFSFileDescriptorImpl fd)
{
try
{
return (IFSFileDescriptorImplRemote)fd;
}
catch (ClassCastException e)
{
Trace.log(Trace.ERROR, "Argument is not an instance of IFSFileDescriptorImplRemote", e);
throw new
InternalErrorException(InternalErrorException.UNEXPECTED_EXCEPTION);
}
}
// @B8m - Moved this method here from IFSFileImplRemote.
// Determine if the directory entry can be accessed in the specified
// manner.
// Returns the returnCode that was set (as a side effect) by createFileHandle().
int checkAccess(int access, int openOption) // @D1C @B8c
throws IOException, AS400SecurityException
{
int fileHandle = UNINITIALIZED;
try {
fileHandle = createFileHandle(access, openOption);
}
finally {
if (fileHandle != UNINITIALIZED) close(fileHandle); // we don't need this handle anymore
}
return errorRC_;
}
public void close()
{
try {
close0();
}
catch (IOException e) {
Trace.log(Trace.ERROR, "Error while closing file " + path_, e);
}
}
public void close0() throws IOException
{
isOpen_ = false;
close(fileHandle_);
fileHandle_ = UNINITIALIZED;
}
void close(int fileHandle) throws IOException
{
if (fileHandle == UNINITIALIZED) return; // @B8c
// Close the file. Send a close request to the server.
ClientAccessDataStream ds = null;
IFSCloseReq req = new IFSCloseReq(fileHandle);
try
{
ds = (ClientAccessDataStream) server_.sendAndReceive(req);
}
catch(ConnectionDroppedException e)
{
Trace.log(Trace.ERROR, "Byte stream connection lost during close", e);
connectionDropped(e);
}
catch(InterruptedException e)
{
Trace.log(Trace.ERROR, "Interrupted", e);
InterruptedIOException throwException = new InterruptedIOException(e.getMessage());
try {
throwException.initCause(e);
} catch (Throwable t) {}
throw throwException;
}
// Validate the reply.
if (ds instanceof IFSCloseRep)
{
int rc = ((IFSCloseRep) ds).getReturnCode();
if (rc != 0)
{
Trace.log(Trace.ERROR, "IFSCloseRep return code", rc);
throw new ExtendedIOException(path_, rc);
}
}
else if (ds instanceof IFSReturnCodeRep)
{
int rc = ((IFSReturnCodeRep) ds).getReturnCode();
if (rc != IFSReturnCodeRep.SUCCESS)
{
Trace.log(Trace.ERROR, "IFSReturnCodeRep return code", descriptionForReturnCode(rc));
throw new ExtendedIOException(path_, rc);
}
}
else
{
Trace.log(Trace.ERROR, "Unknown reply data stream", ds.data_);
throw new
InternalErrorException(Integer.toHexString(ds.getReqRepID()),
InternalErrorException.DATA_STREAM_UNKNOWN);
}
}
/**
Establishes communications with the server.
@exception AS400SecurityException If a security or authority error occurs.
@exception IOException If an error occurs while communicating with the server.
**/
void connect() // @B2A - code relocated from IFSFileOutputStreamImplRemote,etc.
throws IOException, AS400SecurityException
{
// Connect to the byte stream server if not already connected.
if (server_ == null)
{
// Ensure that the system has been set.
if (system_ == null)
{
throw new ExtendedIllegalStateException("system",
ExtendedIllegalStateException.PROPERTY_NOT_SET);
}
try {
server_ = system_.getConnection(AS400.FILE, false /*forceNewConnection*/, false /*skip signon server */ );
}
catch(AS400SecurityException e)
{
Trace.log(Trace.ERROR, "Access to byte stream server on '" +
system_.getSystemName() + "' denied.", e);
throw e;
}
// Exchange attributes with the server.
exchangeServerAttributes();
}
}
/**
Disconnects from the byte stream server.
@exception ConnectionDroppedException If the connection is dropped unexpectedly.
**/
void connectionDropped(ConnectionDroppedException e) // @B2A - code relocated from IFSFileOutputStreamImplRemote,etc.
throws ConnectionDroppedException
{
if (server_ != null)
{
system_.disconnectServer(server_);
server_ = null;
try { close(); } catch (Exception exc) {} // Note: Not relevant for IFSFileImplRemote.
}
Trace.log(Trace.ERROR, "Byte stream connection lost.");
throw e;
}
/**
* Copies a file or directory to another file or directory.
**/
boolean copyTo(String destinationPath, boolean replace)
throws AS400SecurityException, IOException
{
ClientAccessDataStream ds = null;
IFSCopyReq req = new IFSCopyReq(path_, destinationPath, replace);
try
{
ds = (ClientAccessDataStream) server_.sendAndReceive(req);
}
catch(ConnectionDroppedException e)
{
Trace.log(Trace.ERROR, "Byte stream connection lost during copy", e);
connectionDropped(e);
}
catch(InterruptedException e)
{
Trace.log(Trace.ERROR, "Interrupted", e);
InterruptedIOException throwException = new InterruptedIOException(e.getMessage());
try {
throwException.initCause(e);
} catch (Throwable t) {}
throw throwException;
}
if (ds instanceof IFSReturnCodeRep)
{
int rc = ((IFSReturnCodeRep) ds).getReturnCode();
if (rc != IFSReturnCodeRep.SUCCESS)
{
String path = (rc == IFSReturnCodeRep.DUPLICATE_DIR_ENTRY_NAME ? destinationPath : path_);
throwSecurityExceptionIfAccessDenied(path,rc); // check for "access denied"
Trace.log(Trace.ERROR, "IFSReturnCodeRep return code", descriptionForReturnCode(rc));
throw new ExtendedIOException(path, rc);
}
return true;
}
else
{
Trace.log(Trace.ERROR, "Unknown reply data stream", ds.data_);
throw new
InternalErrorException(Integer.toHexString(ds.getReqRepID()),
InternalErrorException.DATA_STREAM_UNKNOWN);
}
}
// Opens the file for 'read' access, and returns a file handle.
// If failure, sets errorRC_ and returns UNINITIALIZED.
private final int createFileHandle()
throws IOException, AS400SecurityException
{
return createFileHandle(IFSOpenReq.READ_ACCESS, IFSOpenReq.OPEN_OPTION_FAIL_OPEN);
}
// Opens the file with specified access and option, and returns a file handle.
// If failure, sets errorRC_ and returns UNINITIALIZED.
int createFileHandle(int access, int openOption) // @D1C @B8c
throws IOException, AS400SecurityException
{
int returnCode = IFSReturnCodeRep.FILE_NOT_FOUND;
int fileHandle = UNINITIALIZED;
errorRC_ = 0;
// Try to open the file for the specified type of access.
try
{
// Process an open file request.
// For 3rd parm (file data CCSID), specify 0 since we don't care about CCSID.
IFSOpenReq req = new IFSOpenReq(getPathnameAsBytes(), preferredServerCCSID_,
0, access, IFSOpenReq.DENY_NONE,
IFSOpenReq.NO_CONVERSION,
openOption, serverDatastreamLevel_); // @D1C
ClientAccessDataStream ds = (ClientAccessDataStream) server_.sendAndReceive(req);
if (ds instanceof IFSOpenRep)
{
// The open was successful. Close the file if appropriate.
returnCode = IFSReturnCodeRep.SUCCESS;
fileHandle = ((IFSOpenRep) ds).getFileHandle(); // @B8a
}
else if (ds instanceof IFSReturnCodeRep)
{
returnCode = ((IFSReturnCodeRep) ds).getReturnCode();
throwSecurityExceptionIfAccessDenied(path_,returnCode); // check for "access denied"
}
else
{
// Unknown data stream.
Trace.log(Trace.ERROR, "Unknown reply data stream", ds.data_);
throw new
InternalErrorException(Integer.toHexString(ds.getReqRepID()),
InternalErrorException.DATA_STREAM_UNKNOWN);
}
}
catch(ConnectionDroppedException e)
{
Trace.log(Trace.ERROR, "Byte stream server connection lost", e);
connectionDropped(e);
}
catch(InterruptedException e)
{
Trace.log(Trace.ERROR, "Interrupted", e);
InterruptedIOException throwException = new InterruptedIOException(e.getMessage());
try {
throwException.initCause(e);
} catch (Throwable t) {}
throw throwException;
}
if (returnCode != IFSReturnCodeRep.SUCCESS)
{
if (Trace.isTraceOn() && Trace.isTraceDiagnosticOn())
{
Trace.log(Trace.DIAGNOSTIC, "Unable to open file " + path_ + ": " +
"IFSReturnCodeRep return code", descriptionForReturnCode(returnCode));
}
errorRC_ = returnCode;
return UNINITIALIZED;
}
return fileHandle;
}
/**
Exchanges server attributes.
@exception IOException If an error occurs while communicating with the server.
**/
void exchangeServerAttributes() // @B2A - code relocated from IFSFileOutputStreamImplRemote,etc.
throws IOException, AS400SecurityException
{
synchronized (serverLock_)
{
DataStream ds = server_.getExchangeAttrReply();
IFSExchangeAttrRep rep = null;
try { rep = (IFSExchangeAttrRep)ds; }
catch (ClassCastException e)
{
if (ds instanceof IFSReturnCodeRep)
{
int rc = ((IFSReturnCodeRep) ds).getReturnCode();
throwSecurityExceptionIfAccessDenied(path_,rc); // check for "access denied"
Trace.log(Trace.ERROR, "IFSReturnCodeRep return code", descriptionForReturnCode(rc));
throw new ExtendedIOException(path_, rc);
}
else {
String className = ( ds == null ? "null" : ds.getClass().getName());
Trace.log(Trace.ERROR, "Unexpected reply from Exchange Server Attributes: " + className);
throw new InternalErrorException(InternalErrorException.DATA_STREAM_UNKNOWN);
}
}
// Note: For releases after V5R4, we ask for Datastream Level 16;
// for V5R3 thru V5R4, we ask for Datastream Level 8;
// for V4R5 thru V5R2, we ask for Datastream Level 2;
// for earlier systems, we ask for Datastream Level 0. // @B6c
if (getSystemVRM() >= 0x00060100)
requestedDatastreamLevel_ = 16;
else if (getSystemVRM() >= 0x00050300)
requestedDatastreamLevel_ = 8;
else if (getSystemVRM() >= 0x00040500) // @B3A @B4C
requestedDatastreamLevel_ = 2;
else
requestedDatastreamLevel_ = 0;
if (rep == null)
{
ds = null;
try
{
int[] preferredCcsids; // @A2A
// Datastream level 8 was introduced in release V5R3.
if (getSystemVRM() >= 0x00050300)
{ // System is post-V5R2.
preferredCcsids = new int[] {0x04b0,0x34b0,0xf200}; // UTF-16, new or old Unicode.
}
// Note: Pre-V4R5 systems hang when presented with multiple
// preferred CCSIDs in the exchange of attributes. @B3A @B4C
else if (getSystemVRM() >= 0x00040500) // @B3A @B4C
{ // System is V4R5 or later. We can present a list of preferred CCSIDs.
preferredCcsids = new int[] {0x34b0,0xf200}; // New or old Unicode.
}
else
{ // System is pre-V4R5. Exchange attr's the old way.
preferredCcsids = new int[] {0xf200}; // Old Unicode only.
}
// Use GMT date/time, don't use posix style return codes,
// use PC pattern matching semantics,
// maximum data transfer size of 0xffffffff.
ds = server_.sendExchangeAttrRequest( //@B3A
new IFSExchangeAttrReq(true, false,
IFSExchangeAttrReq.PC_PATTERN_MATCH,
0xffffffff,
requestedDatastreamLevel_,
preferredCcsids)); // @A2C
rep = (IFSExchangeAttrRep)ds;
}
catch(ConnectionDroppedException e)
{
Trace.log(Trace.ERROR, "Byte stream server connection lost");
connectionDropped(e);
}
catch(InterruptedException e)
{
Trace.log(Trace.ERROR, "Interrupted", e);
system_.disconnectServer(server_);
server_ = null;
InterruptedIOException throwException = new InterruptedIOException(e.getMessage());
try {
throwException.initCause(e);
} catch (Throwable t) {}
throw throwException;
}
catch(IOException e)
{
Trace.log(Trace.ERROR, "I/O error during attribute exchange.");
system_.disconnectServer(server_);
server_ = null;
throw e;
}
catch(ClassCastException e)
{
if (ds instanceof IFSReturnCodeRep)
{
int rc = ((IFSReturnCodeRep) ds).getReturnCode();
throwSecurityExceptionIfAccessDenied(path_,rc); // check for "access denied"
Trace.log(Trace.ERROR, "IFSReturnCodeRep return code", descriptionForReturnCode(rc));
throw new ExtendedIOException(path_, rc);
}
else {
String className = ( ds == null ? "null" : ds.getClass().getName());
Trace.log(Trace.ERROR, "Unexpected reply from Exchange Server Attributes: " + className);
throw new InternalErrorException(InternalErrorException.DATA_STREAM_UNKNOWN);
}
}
}
// Process the exchange attributes reply.
if (rep != null)
{
maxDataBlockSize_ = ((IFSExchangeAttrRep) rep).getMaxDataBlockSize();
preferredServerCCSID_ = rep.getPreferredCCSID();
serverDatastreamLevel_ = rep.getDataStreamLevel();
setConverter(ConverterImplRemote.getConverter(preferredServerCCSID_,
system_));
if (DEBUG) {
System.out.println("DEBUG: IFSFileDescriptorImplRemote.exchangeServerAttributes(): " +
"preferredServerCCSID_ == " + preferredServerCCSID_);
int[] list = rep.getPreferredCCSIDs();
for (int i=0; i 1) {
if (Trace.traceOn_) Trace.log(Trace.WARNING, "Received multiple replies from listAttributes(fileHandle) (" +
replys.size() + ")");
}
else {
reply = (IFSListAttrsRep) replys.elementAt(0);
}
}
finally {
if(!usedGlobalHandle && fileHandle != UNINITIALIZED) //@KKBA
close(fileHandle);
}
return reply;
}
/**
Places a lock on the file at the specified bytes.
@param offset The first byte of the file to lock (zero is the first byte).
@param length The number of bytes to lock.
@return A key for undoing this lock.
@exception ConnectionDroppedException If the connection is dropped unexpectedly.
@exception ExtendedIOException If an error occurs while communicating with the server.
@exception InterruptedIOException If this thread is interrupted.
@exception ServerStartupException If the server cannot be started.
@exception UnknownHostException If the system cannot be located.
@see IFSKey
@see #unlock
**/
IFSKey lock(long length) // @B2A
throws IOException, AS400SecurityException
{
return lock(fileOffset_, length);
}
IFSKey lock(long offset, // @B2A - code relocated from IFSFileOutputStreamImplRemote,etc.
long length)
throws IOException, AS400SecurityException
{
// Assume the arguments have been validated by the caller.
// Attempt to lock the file.
ClientAccessDataStream ds = null;
try
{
// Issue a mandatory, exclusive lock bytes request. Mandatory
// means that the file system enforces the lock by causing any
// operation which conflicts with the lock to fail. Exclusive
// means that only the owner of the lock can read or write the
// locked area.
IFSLockBytesReq req =
new IFSLockBytesReq(fileHandle_, true, false, offset,
length, serverDatastreamLevel_);
ds = (ClientAccessDataStream) server_.sendAndReceive(req);
}
catch(ConnectionDroppedException e)
{
Trace.log(Trace.ERROR, "Byte stream server connection lost");
connectionDropped(e);
}
catch(InterruptedException e)
{
Trace.log(Trace.ERROR, "Interrupted", e);
InterruptedIOException throwException = new InterruptedIOException(e.getMessage());
try {
throwException.initCause(e);
} catch (Throwable t) {}
throw throwException;
}
// Verify the reply.
if (ds instanceof IFSLockBytesRep)
{
int rc = ((IFSLockBytesRep) ds).getReturnCode();
if (rc != 0)
{
Trace.log(Trace.ERROR, "IFSLockBytesRep return code", rc);
throw new ExtendedIOException(path_, rc);
}
}
else if (ds instanceof IFSReturnCodeRep)
{
int rc = ((IFSReturnCodeRep) ds).getReturnCode();
if (rc != IFSReturnCodeRep.SUCCESS)
{
throwSecurityExceptionIfAccessDenied(path_,rc); // check for "access denied"
Trace.log(Trace.ERROR, "IFSReturnCodeRep return code", descriptionForReturnCode(rc));
throw new ExtendedIOException(path_, rc);
}
}
else
{
// Unknown data stream.
Trace.log(Trace.ERROR, "Unknown reply data stream", ds.data_);
throw new
InternalErrorException(Integer.toHexString(ds.getReqRepID()),
InternalErrorException.DATA_STREAM_UNKNOWN);
}
// Generate the key for this lock.
IFSKey key = new IFSKey(fileHandle_, offset, length, true);
return key;
}
// Common code used by IFSFileInputStreamImplRemote and IFSRandomAccessFileImplRemote.
/**
Reads up to length bytes of data from this input stream into data,
starting at the array offset dataOffset.
@param data The buffer into which the data is read.
@param offset The start offset of the data in the buffer.
@param length The maximum number of bytes to read
@return The total number of bytes read into the buffer, or -1 if there is no more data because the end of file has been reached.
@exception ConnectionDroppedException If the connection is dropped unexpectedly.
@exception ExtendedIOException If an error occurs while communicating with the server.
@exception InterruptedIOException If this thread is interrupted.
@exception ServerStartupException If the server cannot be started.
@exception UnknownHostException If the system cannot be located.
**/
int read(byte[] data, // @B2A - code relocated from IFSFileInputStreamImplRemote,etc.
int dataOffset,
int length)
throws IOException, AS400SecurityException
{
// Assume the arguments have been validated by the public class.
// If length is zero then return zero.
if (length == 0)
{
return 0;
}
int totalBytesRead = 0;
int bytesRemainingToRead = length;
boolean endOfFile = false;
while (totalBytesRead < length && !endOfFile)
{
// If the number of bytes being requested is greater than 16 million, then submit multiple requests for smaller chunks. The File Server has a limit that is somewhat below 16 megabytes (allowing for headers, etc), so 16 _million_ bytes is a safe limit.
// Issue the read data request.
int bytesToReadThisTime = Math.min(bytesRemainingToRead, MAX_BYTES_PER_READ);
IFSReadReq req = new IFSReadReq(fileHandle_, fileOffset_,
bytesToReadThisTime, serverDatastreamLevel_);
ClientAccessDataStream ds = null;
try
{
ds = (ClientAccessDataStream) server_.sendAndReceive(req);
}
catch(ConnectionDroppedException e)
{
Trace.log(Trace.ERROR, "Byte stream server connection lost");
connectionDropped(e);
}
catch(InterruptedException e)
{
Trace.log(Trace.ERROR, "Interrupted", e);
InterruptedIOException throwException = new InterruptedIOException(e.getMessage());
try {
throwException.initCause(e);
} catch (Throwable t) {}
throw throwException;
}
// Receive replies until the end of chain.
boolean endOfChain = false;
int bytesReadByThisRequest = 0;
do
{
if (ds instanceof IFSReadRep)
{
// Copy the data from the reply to the data parameter.
byte[] buffer = ((IFSReadRep) ds).getData();
if (buffer.length > 0)
{
System.arraycopy(buffer, 0, data, dataOffset, buffer.length);
bytesReadByThisRequest += buffer.length;
dataOffset += buffer.length;
}
else // no data returned. This implies end-of-file (e.g. if file is empty).
{
bytesReadByThisRequest = -1;
endOfFile = true;
}
}
else if (ds instanceof IFSReturnCodeRep)
{
// Check for failure.
int rc = ((IFSReturnCodeRep) ds).getReturnCode();
if (rc == IFSReturnCodeRep.SUCCESS)
{ // It worked, so nothing special to do here.
}
else if (rc == IFSReturnCodeRep.NO_MORE_DATA)
{
// End of file.
bytesReadByThisRequest = -1;
endOfFile = true;
}
else // none of the above
{
throwSecurityExceptionIfAccessDenied(path_,rc); // check for "access denied"
Trace.log(Trace.ERROR, "IFSReturnCodeRep return code", descriptionForReturnCode(rc));
throw new ExtendedIOException(path_, rc);
}
}
else // neither IFSReadRep nor IFSReturnCodeRep
{
// Unknown data stream.
Trace.log(Trace.ERROR, "Unknown reply data stream", ds.data_);
throw new
InternalErrorException(Integer.toHexString(ds.getReqRepID()),
InternalErrorException.DATA_STREAM_UNKNOWN);
}
// Get the next reply if not end of chain.
endOfChain = ((IFSDataStream) ds).isEndOfChain();
if (!endOfChain)
{
try
{
ds = (ClientAccessDataStream)
server_.receive(req.getCorrelation());
}
catch(ConnectionDroppedException e)
{
Trace.log(Trace.ERROR, "Byte stream server connection lost");
connectionDropped(e);
}
catch(InterruptedException e)
{
Trace.log(Trace.ERROR, "Interrupted", e);
InterruptedIOException throwException = new InterruptedIOException(e.getMessage());
try {
throwException.initCause(e);
} catch (Throwable t) {}
throw throwException;
}
}
}
while (!endOfChain);
// Advance the file pointer.
if (bytesReadByThisRequest > 0) {
incrementFileOffset(bytesReadByThisRequest);
totalBytesRead += bytesReadByThisRequest;
bytesRemainingToRead -= bytesReadByThisRequest;
}
}
// If we have read zero bytes and hit end-of-file, indicate that by returning -1.
// Otherwise return total number of bytes read.
return (endOfFile && totalBytesRead == 0 ? -1 : totalBytesRead);
}
void setConverter(ConverterImplRemote converter)
{
converter_ = converter;
}
/**
Sets the cached "file data CCSID" value.
**/
void setCCSID(int ccsid)
throws IOException
{
fileDataCCSID_ = ccsid;
}
public void setFileOffset(long fileOffset)
{
synchronized(fileOffsetLock_)
{
fileOffset_ = fileOffset;
}
}
// @B8a
boolean setLength(long length)
throws IOException, AS400SecurityException
{
// Assume that we are connected to the server.
// Prepare to issue a 'change attributes' request.
ClientAccessDataStream ds = null;
int fileHandle = UNINITIALIZED;
try
{
// Open the file for read/write, get a file handle, and call 'change attributes'.
fileHandle = createFileHandle(IFSOpenReq.WRITE_ACCESS, IFSOpenReq.OPEN_OPTION_FAIL_OPEN);
if (fileHandle == UNINITIALIZED)
{
if (Trace.traceOn_) Trace.log(Trace.ERROR, "Unable to create handle to file " + path_ + ". IFSReturnCodeRep return code", errorRC_);
return false;
}
IFSChangeAttrsReq req = new IFSChangeAttrsReq(fileHandle, length, serverDatastreamLevel_);
ds = (ClientAccessDataStream) server_.sendAndReceive(req);
}
catch(ConnectionDroppedException e)
{
Trace.log(Trace.ERROR, "Byte stream server connection lost.");
connectionDropped(e);
}
catch(InterruptedException e)
{
Trace.log(Trace.ERROR, "Interrupted");
InterruptedIOException throwException = new InterruptedIOException(e.getMessage());
try {
throwException.initCause(e);
} catch (Throwable t) {}
throw throwException;
}
finally {
close(fileHandle); // we don't need this handle anymore
}
// Verify the reply.
boolean success = false;
if (ds instanceof IFSReturnCodeRep)
{
int rc = ((IFSReturnCodeRep) ds).getReturnCode();
if (rc == IFSReturnCodeRep.SUCCESS)
success = true;
else
{
throwSecurityExceptionIfAccessDenied(path_,rc); // check for "access denied"
Trace.log(Trace.ERROR, path_ + ": IFSReturnCodeRep return code", descriptionForReturnCode(rc));
}
}
else
{
// Unknown data stream.
Trace.log(Trace.ERROR, "Unknown reply data stream", ds.data_);
throw new
InternalErrorException(Integer.toHexString(ds.getReqRepID()),
InternalErrorException.DATA_STREAM_UNKNOWN);
}
// Back off the file pointer if needed.
if (fileOffset_ > length) {
fileOffset_ = length;
}
return success;
}
// Ignores fileHandle if state==false.
void setOpen(boolean state, int fileHandle)
{
if (state == true)
{
if (fileHandle == UNINITIALIZED)
{
Trace.log(Trace.ERROR, "Called setOpen with invalid file handle: " + fileHandle);
throw new
InternalErrorException(InternalErrorException.UNEXPECTED_EXCEPTION);
}
else
{
if (fileHandle != fileHandle_) close(); // close currently-open handle if different
fileHandle_ = fileHandle;
}
}
isOpen_ = state;
}
void setOpenAllowed(boolean state)
{
isOpenAllowed_ = state;
}
void setPreferredCCSID(int ccsid)
{
preferredServerCCSID_ = ccsid;
}
void setServer(AS400Server server)
{
server_ = server;
}
/**
Force the system buffers to synchronize with the underlying device.
**/ // $A1
public void sync() throws IOException
{
if (parent_ == null)
{
Trace.log(Trace.ERROR, "IFSFileDescriptor.sync() was called when parent is null.");
}
// Note: UserSpaceImplRemote creates an IFSFileDescriptorImplRemote directly.
else if (parent_ instanceof IFSRandomAccessFileImplRemote)
{
((IFSRandomAccessFileImplRemote)parent_).flush();
}
else if (parent_ instanceof IFSFileOutputStreamImplRemote)
{
((IFSFileOutputStreamImplRemote)parent_).flush();
}
else
{
Trace.log(Trace.WARNING, "IFSFileDescriptor.sync() was called " +
"when parent is neither an IFSRandomAccessFile nor an IFSFileOutputStream.");
}
}
private static final void throwSecurityExceptionIfAccessDenied(String path, int returnCode)
throws AS400SecurityException
{
if (returnCode == IFSReturnCodeRep.ACCESS_DENIED_TO_DIR_ENTRY ||
returnCode == IFSReturnCodeRep.ACCESS_DENIED_TO_REQUEST)
{
if (Trace.traceOn_) Trace.log(Trace.DIAGNOSTIC, "Access denied to file " + path + ". " +
"IFSReturnCodeRep return code", returnCode);
throw new AS400SecurityException(path, AS400SecurityException.DIRECTORY_ENTRY_ACCESS_DENIED);
}
}
/**
Undoes a lock on this file.
@param key The key for the lock.
@exception IOException If an error occurs while communicating with the server.
@see IFSKey
@see #lock
**/
void unlock(IFSKey key) // @B2A - code relocated from IFSFileOutputStreamImplRemote,etc.
throws IOException, AS400SecurityException
{
// Assume the argument has been validated by the caller.
// Verify that this key is compatible with this file.
if (key.fileHandle_ != fileHandle_)
{
Trace.log(Trace.ERROR, "Attempt to use IFSKey on different file stream.");
throw new ExtendedIllegalArgumentException("key",
ExtendedIllegalArgumentException.PARAMETER_VALUE_NOT_VALID);
}
// Attempt to unlock the file.
ClientAccessDataStream ds = null;
// Issue an unlock bytes request.
IFSUnlockBytesReq req =
new IFSUnlockBytesReq(key.fileHandle_, key.offset_,
key.length_, key.isMandatory_, serverDatastreamLevel_);
try
{
ds = (ClientAccessDataStream) server_.sendAndReceive(req);
}
catch(ConnectionDroppedException e)
{
Trace.log(Trace.ERROR, "Byte stream server connection lost");
connectionDropped(e);
}
catch(InterruptedException e)
{
Trace.log(Trace.ERROR, "Interrupted", e);
InterruptedIOException throwException = new InterruptedIOException(e.getMessage());
try {
throwException.initCause(e);
} catch (Throwable t) {}
throw throwException;
}
// Verify the reply.
if (ds instanceof IFSReturnCodeRep)
{
int rc = ((IFSReturnCodeRep) ds).getReturnCode();
if (rc != IFSReturnCodeRep.SUCCESS)
{
throwSecurityExceptionIfAccessDenied(path_,rc); // check for "access denied"
Trace.log(Trace.ERROR, "IFSReturnCodeRep return code", descriptionForReturnCode(rc));
throw new ExtendedIOException(path_, rc);
}
}
else
{
// Unknown data stream.
Trace.log(Trace.ERROR, "Unknown reply data stream", ds.data_);
throw new
InternalErrorException(Integer.toHexString(ds.getReqRepID()),
InternalErrorException.DATA_STREAM_UNKNOWN);
}
}
// Common code used by IFSFileOutputStreamImplRemote and IFSRandomAccessFileImplRemote.
/**
Writes length bytes from the byte array data, starting at dataOffset, to this File.
@param data The data.
@param dataOffset The start offset in the data.
@param length The number of bytes to write.
@parm forceToStorage Whether data must be written before the server replies.
@exception ConnectionDroppedException If the connection is dropped unexpectedly.
@exception ExtendedIOException If an error occurs while communicating with the server.
@exception InterruptedIOException If this thread is interrupted.
@exception ServerStartupException If the server cannot be started.
@exception UnknownHostException If the system cannot be located.
**/
void writeBytes(byte[] data, // @B2A
int dataOffset,
int length)
throws IOException, AS400SecurityException
{
writeBytes(data, dataOffset, length, false);
}
void writeBytes(byte[] data, // @B2A - code relocated from IFSFileOutputStreamImplRemote,etc.
int dataOffset,
int length,
boolean forceToStorage)
throws IOException, AS400SecurityException
{
// Assume the arguments have been validated by the caller.
// Send write requests until all data has been written.
while(length > 0)
{
// Determine how much data can be written on this request.
int writeLength = (length > maxDataBlockSize_ ?
maxDataBlockSize_ : length);
// Build the write request. Set the chain bit if there is
// more data to write.
IFSWriteReq req = new IFSWriteReq(fileHandle_, fileOffset_,
data, dataOffset, writeLength,
0xffff, forceToStorage, serverDatastreamLevel_);
if (length - writeLength > 0)
{
// Indicate that there is more to write.
req.setChainIndicator(1);
}
// Send the request.
ClientAccessDataStream ds = null;
try
{
// Send the request and receive the response.
ds = (ClientAccessDataStream) server_.sendAndReceive(req);
}
catch(ConnectionDroppedException e)
{
Trace.log(Trace.ERROR, "Byte stream server connection lost");
connectionDropped(e);
}
catch(InterruptedException e)
{
Trace.log(Trace.ERROR, "Interrupted", e);
InterruptedIOException throwException = new InterruptedIOException(e.getMessage());
try {
throwException.initCause(e);
} catch (Throwable t) {}
throw throwException;
}
// Check the reply.
if (ds instanceof IFSWriteRep)
{
IFSWriteRep rep = (IFSWriteRep) ds;
int rc = rep.getReturnCode();
if (rc != 0)
{
Trace.log(Trace.ERROR, "IFSWriteRep return code", rc);
throw new ExtendedIOException(path_, rc);
}
// Advance the file pointer the length of the data
// written.
int lengthWritten = writeLength - rep.getLengthNotWritten();
incrementFileOffset(lengthWritten);
dataOffset += lengthWritten;
length -= lengthWritten;
// Ensure that all data requested was written.
if (lengthWritten != writeLength)
{
Trace.log(Trace.ERROR, "Incomplete write. Only " +
Integer.toString(lengthWritten) + " bytes of a requested " +
Integer.toString(writeLength) + " were written.");
throw new ExtendedIOException(path_, ExtendedIOException.UNKNOWN_ERROR);
}
}
else if (ds instanceof IFSReturnCodeRep)
{
int rc = ((IFSReturnCodeRep) ds).getReturnCode();
if (rc != IFSReturnCodeRep.SUCCESS)
{
throwSecurityExceptionIfAccessDenied(path_,rc); // check for "access denied"
Trace.log(Trace.ERROR, "IFSReturnCodeRep return code", descriptionForReturnCode(rc));
throw new ExtendedIOException(path_, rc);
}
}
else
{
// Unknown data stream.
Trace.log(Trace.ERROR, "Unknown reply data stream", ds.data_);
throw new
InternalErrorException(Integer.toHexString(ds.getReqRepID()),
InternalErrorException.DATA_STREAM_UNKNOWN);
}
}
}
public int getServerDatastreamLevel() {
return serverDatastreamLevel_;
}
//@V4A
public int createUserHandle() throws IOException, AS400SecurityException{
ClientAccessDataStream ds = null;
int UserHandle = UNINITIALIZED;
int rc;
byte[] ClientSeed = BinaryConverter.longToByteArray(System.currentTimeMillis());
byte[] ServerSeed = null;
try {
IFSUserHandleSeedReq req = new IFSUserHandleSeedReq(ClientSeed);
ds = (ClientAccessDataStream) server_.sendAndReceive(req);
}
catch(InterruptedException e)
{
Trace.log(Trace.ERROR, "Interrupted");
InterruptedIOException throwException = new InterruptedIOException(e.getMessage());
try {
throwException.initCause(e);
} catch (Throwable t) {}
throw throwException;
}
// Verify that we got a handle back.
if (ds instanceof IFSUserHandleSeedRep)
{
ServerSeed = ((IFSUserHandleSeedRep) ds).getSeed();
}
else if (ds instanceof IFSReturnCodeRep)
{
rc = ((IFSReturnCodeRep) ds).getReturnCode();
if (rc != IFSReturnCodeRep.SUCCESS)
{
Trace.log(Trace.ERROR, "IFSReturnCodeRep return code", rc);
}
throw new ExtendedIOException(rc);
}
else
{
// Unknown data stream.
Trace.log(Trace.ERROR, "Unknown reply data stream",
ds.getReqRepID());
throw new
InternalErrorException(Integer.toHexString(ds.getReqRepID()),
InternalErrorException.DATA_STREAM_UNKNOWN);
}
rc = 0;
ds = null;
byte[] userIDbytes = SignonConverter.stringToByteArray(system_.getUserId());
byte[] encryptedPassword = system_.getPassword(ClientSeed, ServerSeed);
IFSCreateUserHandlerReq req = new IFSCreateUserHandlerReq(userIDbytes, encryptedPassword);
try {
ds = (ClientAccessDataStream) server_.sendAndReceive(req);
} catch (InterruptedException e) {
Trace.log(Trace.ERROR, "Interrupted");
InterruptedIOException throwException = new InterruptedIOException(e.getMessage());
try {
throwException.initCause(e);
} catch (Throwable t) {}
throw throwException;
}
// Verify the reply.
if (ds instanceof IFSCreateUserHandleRep)
{
rc = ((IFSCreateUserHandleRep)ds).getReturnCode();
if (rc != IFSReturnCodeRep.SUCCESS)
{
Trace.log(Trace.ERROR, "IFSCreateUserHandleRep return code", rc);
}
UserHandle = ((IFSCreateUserHandleRep) ds).getHandle();
}
else if (ds instanceof IFSReturnCodeRep)
{
rc = ((IFSReturnCodeRep) ds).getReturnCode();
if (rc != IFSReturnCodeRep.SUCCESS)
{
Trace.log(Trace.ERROR, "IFSReturnCodeRep return code", rc);
}
throw new ExtendedIOException(rc);
}
else
{
// Unknown data stream.
Trace.log(Trace.ERROR, "Unknown reply data stream",
ds.getReqRepID());
throw new
InternalErrorException(InternalErrorException.DATA_STREAM_UNKNOWN,
Integer.toHexString(ds.getReqRepID()),null);
}
return UserHandle;
}
public void freeUserHandle(int userHandle) throws IOException, AS400SecurityException{
IFSFreeUserHandlerReq req = new IFSFreeUserHandlerReq(userHandle);
server_.send(req);
}
public void freeHandle(int objectHandle) throws IOException, AS400SecurityException{
IFSFreeHandleReq req = new IFSFreeHandleReq(objectHandle);
server_.send(req);
}
//@AC7A Start
public int getASP(boolean isDirectory) throws IOException, AS400SecurityException {
isDirectory_ = isDirectory;
return getASP();
}
//@AC7A End
public int getASP() throws IOException, AS400SecurityException {
if (fileAsp_ == UNINITIALIZED)
{
ClientAccessDataStream ds = null;
int rc = 0;
connect();
// Ensure that we are connected to the server.
byte[] pathname = getConverter().stringToByteArray(path_);
//create user handle
int userHandle = UNINITIALIZED, objectHandle = UNINITIALIZED;
try{
userHandle = system_.createUserHandle();
try
{
// Issue a Look up request to create an object handle.
//IFSLookupReq req = new IFSLookupReq(pathname, preferredServerCCSID_, userHandle, IFSLookupReq.OA1, IFSLookupReq.ASP_FLAG, 0);
IFSLookupReq req = new IFSLookupReq(pathname, preferredServerCCSID_, userHandle, IFSLookupReq.OA12, IFSObjAttrs1.OWNERANAME_ASP_FLAS, 0); //@AC7A
ds = (ClientAccessDataStream) server_.sendAndReceive(req);
}
catch(ConnectionDroppedException e)
{
Trace.log(Trace.ERROR, "Byte stream server connection lost.");
connectionDropped(e);
}
catch(InterruptedException e)
{
Trace.log(Trace.ERROR, "Interrupted");
InterruptedIOException throwException = new InterruptedIOException(e.getMessage());
try {
throwException.initCause(e);
} catch (Throwable t) {}
throw throwException;
}
rc = 0;
if (ds instanceof IFSLookupRep)
{
objectHandle = ((IFSLookupRep) ds).getHandle();
//fileAsp_ = ((IFSLookupRep) ds).getASP(); //@AC7D
retrieveAttributes(ds, objectHandle); //@AC7A
}
else if (ds instanceof IFSReturnCodeRep)
{
rc = ((IFSReturnCodeRep) ds).getReturnCode();
if (rc != IFSReturnCodeRep.SUCCESS)
{
Trace.log(Trace.ERROR, "IFSReturnCodeRep return code", rc);
}
throw new ExtendedIOException(path_, rc);
}
else
{
// Unknown data stream.
Trace.log(Trace.ERROR, "Unknown reply data stream",
ds.getReqRepID());
throw new
InternalErrorException(Integer.toHexString(ds.getReqRepID()),
InternalErrorException.DATA_STREAM_UNKNOWN);
}
}finally{
//if(userHandle != UNINITIALIZED)
// freeUserHandle(userHandle);
if(objectHandle != UNINITIALIZED)
freeHandle(objectHandle);
}
}
return fileAsp_;
}
//@AC7A Start
public String getOwnerNameByUserHandle(boolean forceRetrieve) throws IOException, AS400SecurityException {
Trace.log(Trace.INFORMATION, "Owner Name " + (fileOwnerName_ == null? "is null" : fileOwnerName_));
isDirectory_ = true;
if (forceRetrieve || fileOwnerName_ == null) {
Trace.log(Trace.INFORMATION, "force retrieve for Owner Name.");
fileOwnerName_ = getOwnerNameByUserHandle();
}
return fileOwnerName_;
}
//@AC7A End
public String getOwnerNameByUserHandle() throws IOException, AS400SecurityException {
//String ownerName = null; //@AC7D
ClientAccessDataStream ds = null;
int rc = 0;
// Ensure that we are connected to the server.
connect();
byte[] pathname = getConverter().stringToByteArray(path_);
//create user handle
int userHandle = UNINITIALIZED, objectHandle = UNINITIALIZED;
try{
userHandle = system_.createUserHandle();
try
{
// Issue a Look up request to create an object handle.
//IFSLookupReq req = new IFSLookupReq(pathname, preferredServerCCSID_, userHandle, IFSLookupReq.OA1, IFSObjAttrs1.OWNER_NAME_FLAG, 0); //@AC7A End
IFSLookupReq req = new IFSLookupReq(pathname, preferredServerCCSID_, userHandle, IFSLookupReq.OA12, IFSObjAttrs1.OWNERANAME_ASP_FLAS, 0); //@AC7A
ds = (ClientAccessDataStream) server_.sendAndReceive(req);
}
catch(ConnectionDroppedException e)
{
Trace.log(Trace.ERROR, "Byte stream server connection lost.");
connectionDropped(e);
}
catch(InterruptedException e)
{
Trace.log(Trace.ERROR, "Interrupted");
InterruptedIOException throwException = new InterruptedIOException(e.getMessage());
try {
throwException.initCause(e);
} catch (Throwable t) {}
throw throwException;
}
// Verify that we got a handle back.
rc = 0;
if (ds instanceof IFSLookupRep)
{
//ownerName = ((IFSLookupRep) ds).getOwnerName(system_.getCcsid()); //@AC7A End
objectHandle = ((IFSLookupRep) ds).getHandle();
retrieveAttributes(ds, objectHandle); //@AC7A
}
else if (ds instanceof IFSReturnCodeRep)
{
rc = ((IFSReturnCodeRep) ds).getReturnCode();
if (rc != IFSReturnCodeRep.SUCCESS)
{
Trace.log(Trace.ERROR, "IFSReturnCodeRep return code", rc);
}
throw new ExtendedIOException(path_, rc);
}
else
{
// Unknown data stream.
Trace.log(Trace.ERROR, "Unknown reply data stream",
ds.getReqRepID());
throw new
InternalErrorException(Integer.toHexString(ds.getReqRepID()),
InternalErrorException.DATA_STREAM_UNKNOWN);
}
}finally{
// if(userHandle != UNINITIALIZED)
// freeUserHandle(userHandle);
if(objectHandle != UNINITIALIZED)
freeHandle(objectHandle);
}
//return (ownerName == null ? "" : ownerName); //@AC7D
return (fileOwnerName_ == null ? "" : fileOwnerName_); //@AC7A
}
//@AC7A Start
public String getFileSystemType(boolean isDirectory) throws IOException, AS400SecurityException {
isDirectory_ = isDirectory;
return getFileSystemType();
}
//@AC7A End
public String getFileSystemType() throws IOException, AS400SecurityException {
String typeString = "Unknown";
if (fileSystemType_ == UNINITIALIZED)
{
ClientAccessDataStream ds = null;
int rc = 0;
connect();
int objectHandle = UNINITIALIZED;
byte[] pathname = getConverter().stringToByteArray(path_);
//create user handle
int userHandle = UNINITIALIZED;
try{
userHandle = system_.createUserHandle();
try
{
// Issue a Look up request to create an object handle.
//IFSLookupReq req = new IFSLookupReq(pathname, preferredServerCCSID_, userHandle); //@AC7D
IFSLookupReq req = new IFSLookupReq(pathname, preferredServerCCSID_, userHandle, IFSLookupReq.OA12, IFSObjAttrs1.OWNERANAME_ASP_FLAS, 0); //@AC7A Start
ds = (ClientAccessDataStream) server_.sendAndReceive(req);
}
catch(ConnectionDroppedException e)
{
Trace.log(Trace.ERROR, "Byte stream server connection lost.");
connectionDropped(e);
}
catch(InterruptedException e)
{
Trace.log(Trace.ERROR, "Interrupted");
InterruptedIOException throwException = new InterruptedIOException(e.getMessage());
try {
throwException.initCause(e);
} catch (Throwable t) {}
throw throwException;
}
rc = 0;
if (ds instanceof IFSLookupRep)
{
objectHandle = ((IFSLookupRep) ds).getHandle();
retrieveAttributes(ds, objectHandle); //@AC7A
}
else if (ds instanceof IFSReturnCodeRep)
{
rc = ((IFSReturnCodeRep) ds).getReturnCode();
if (rc != IFSReturnCodeRep.SUCCESS)
{
Trace.log(Trace.ERROR, "IFSReturnCodeRep return code", rc);
}
throw new ExtendedIOException(path_, rc);
}
else
{
// Unknown data stream.
Trace.log(Trace.ERROR, "Unknown reply data stream",
ds.getReqRepID());
throw new
InternalErrorException(Integer.toHexString(ds.getReqRepID()),
InternalErrorException.DATA_STREAM_UNKNOWN);
}
/* //@AC7D Start
ds = null;
try
{
// Issue a get file system request.
IFSGetFileSystemReq req = new IFSGetFileSystemReq(objectHandle, userHandle);
ds = (ClientAccessDataStream) server_.sendAndReceive(req);
}
catch(ConnectionDroppedException e)
{
Trace.log(Trace.ERROR, "Byte stream server connection lost.");
connectionDropped(e);
}
catch(InterruptedException e)
{
Trace.log(Trace.ERROR, "Interrupted");
InterruptedIOException throwException = new InterruptedIOException(e.getMessage());
try {
throwException.initCause(e);
} catch (Throwable t) {}
throw throwException;
}
// Verify the reply.
rc = 0;
if (ds instanceof IFSGetFileSystemRep)
{
fileSystemType_ = ((IFSGetFileSystemRep) ds).getFileSystemType();
}
else if (ds instanceof IFSReturnCodeRep)
{
rc = ((IFSReturnCodeRep) ds).getReturnCode();
if (rc != IFSReturnCodeRep.SUCCESS)
{
Trace.log(Trace.ERROR, "IFSReturnCodeRep return code", rc);
}
throw new ExtendedIOException(path_, rc);
}
else
{
// Unknown data stream.
Trace.log(Trace.ERROR, "Unknown reply data stream",
ds.getReqRepID());
throw new
InternalErrorException(InternalErrorException.DATA_STREAM_UNKNOWN,
Integer.toHexString(ds.getReqRepID()),null);
}
*/ //@AC7D Start
}finally{
//if(userHandle != UNINITIALIZED)
// freeUserHandle(userHandle);
if(objectHandle != UNINITIALIZED)
freeHandle(objectHandle);
}
}
switch(fileSystemType_) {
case 1 : typeString = "EPFS"; break;
case 2 : typeString = "QDLS"; break;
case 3 : typeString = "QSYS"; break;
case 4 : typeString = "NFS"; break;
case 5 : typeString = "LRFS"; break;
case 6 : typeString = "QOPT"; break;
case 7 : typeString = "QRFS"; break;
case 9 : typeString = "EPFSP"; break;
case 11 : typeString = "QNETC"; break;
case 12 : typeString = "QDTL"; break;
case 13 : typeString = "IEPFS"; break;
case 14 : typeString = "ASPQSYS"; break;
}
return typeString;
}
//@AC7A Start
private void retrieveAttributes(ClientAccessDataStream ds, int objectHandle) throws IOException, AS400SecurityException {
fileAsp_ = ((IFSLookupRep) ds).getASP();
//if (isDirectory_) { @AE8D
fileOwnerName_ = ((IFSLookupRep) ds).getOwnerName(system_.getCcsid());
fileDataCCSID_ = ((IFSLookupRep) ds).getCCSID(serverDatastreamLevel_);
//}
int userHandle = system_.getUserHandle();
int rc = 0;
ds = null;
try
{
// Issue a get file system request.
IFSGetFileSystemReq req = new IFSGetFileSystemReq(objectHandle, userHandle);
ds = (ClientAccessDataStream) server_.sendAndReceive(req);
}
catch(ConnectionDroppedException e)
{
Trace.log(Trace.ERROR, "Byte stream server connection lost.");
connectionDropped(e);
}
catch(InterruptedException e)
{
Trace.log(Trace.ERROR, "Interrupted");
InterruptedIOException throwException = new InterruptedIOException(e.getMessage());
try {
throwException.initCause(e);
} catch (Throwable t) {}
throw throwException;
}
// Verify the reply.
rc = 0;
if (ds instanceof IFSGetFileSystemRep)
{
fileSystemType_ = ((IFSGetFileSystemRep) ds).getFileSystemType();
}
else if (ds instanceof IFSReturnCodeRep)
{
rc = ((IFSReturnCodeRep) ds).getReturnCode();
if (rc != IFSReturnCodeRep.SUCCESS)
{
Trace.log(Trace.ERROR, "IFSReturnCodeRep return code", rc);
}
throw new ExtendedIOException(path_, rc);
}
else
{
// Unknown data stream.
Trace.log(Trace.ERROR, "Unknown reply data stream",
ds.getReqRepID());
throw new
InternalErrorException(InternalErrorException.DATA_STREAM_UNKNOWN,
Integer.toHexString(ds.getReqRepID()),null);
}
}
//@AC7A End
}