/// <summary>
/// Creates a file output stream to write to the file represented by
/// the specified <code>File</code> object. If the second argument is
/// <code>true</code>, then bytes will be written to the end of the file
/// rather than the beginning. A new <code>FileDescriptor</code> object is
/// created to represent this file connection.
/// <para>
/// First, if there is a security manager, its <code>checkWrite</code>
/// method is called with the path represented by the <code>file</code>
/// argument as its argument.
/// </para>
/// <para>
/// If the file exists but is a directory rather than a regular file, does
/// not exist but cannot be created, or cannot be opened for any other
/// reason then a <code>FileNotFoundException</code> is thrown.
///
/// </para>
/// </summary>
/// <param name="file"> the file to be opened for writing. </param>
/// <param name="append"> if <code>true</code>, then bytes will be written
/// to the end of the file rather than the beginning </param>
/// <exception cref="FileNotFoundException"> if the file exists but is a directory
/// rather than a regular file, does not exist but cannot
/// be created, or cannot be opened for any other reason </exception>
/// <exception cref="SecurityException"> if a security manager exists and its
/// <code>checkWrite</code> method denies write access
/// to the file. </exception>
/// <seealso cref= java.io.File#getPath() </seealso>
/// <seealso cref= java.lang.SecurityException </seealso>
/// <seealso cref= java.lang.SecurityManager#checkWrite(java.lang.String)
/// @since 1.4 </seealso>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public FileOutputStream(File file, boolean append) throws FileNotFoundException
public FileOutputStream(File file, bool append)
{
String name = (file != null ? file.Path : null);
SecurityManager security = System.SecurityManager;
if (security != null)
{
security.CheckWrite(name);
}
if (name == null)
{
throw new NullPointerException();
}
if (file.Invalid)
{
throw new FileNotFoundException("Invalid file path");
}
this.Fd = new FileDescriptor();
Fd.Attach(this);
this.Append = append;
this.Path = name;
Open(name, append);
}
public static int socketRead0(object _this, java.io.FileDescriptor fd, byte[] b, int off, int len, int timeout)
{
#if FIRST_PASS
return(0);
#else
// [IKVM] this method is a direct port of the native code in openjdk6-b18\jdk\src\windows\native\java\net\SocketInputStream.c
System.Net.Sockets.Socket socket = null;
int nread;
if (fd == null)
{
throw new SocketException("socket closed");
}
socket = fd.getSocket();
if (socket == null)
{
throw new SocketException("Socket closed");
}
if (timeout != 0)
{
if (timeout <= 5000 || !net_util_md.isRcvTimeoutSupported)
{
int ret = net_util_md.NET_Timeout(socket, timeout);
if (ret <= 0)
{
if (ret == 0)
{
throw new SocketTimeoutException("Read timed out");
}
else
{
// [IKVM] the OpenJDK native code is broken and always throws this exception on any failure of NET_Timeout
throw new SocketException("socket closed");
}
}
/*check if the socket has been closed while we were in timeout*/
if (fd.getSocket() == null)
{
throw new SocketException("Socket Closed");
}
}
}
nread = Winsock.recv(socket, b, off, len, 0);
if (nread > 0)
{
// ok
}
else
{
if (nread < 0)
{
/*
* Recv failed.
*/
switch (Winsock.WSAGetLastError())
{
case Winsock.WSAEINTR:
throw new SocketException("socket closed");
case Winsock.WSAECONNRESET:
case Winsock.WSAESHUTDOWN:
/*
* Connection has been reset - Windows sometimes reports
* the reset as a shutdown error.
*/
throw new sun.net.ConnectionResetException();
case Winsock.WSAETIMEDOUT:
throw new SocketTimeoutException("Read timed out");
default:
throw net_util_md.NET_ThrowCurrent("recv failed");
}
}
}
return(nread);
#endif
}
public static void socketWrite0(object _this, java.io.FileDescriptor fd, byte[] data, int off, int len)
{
#if !FIRST_PASS
// [IKVM] this method is a direct port of the native code in openjdk6-b18\jdk\src\windows\native\java\net\SocketOutputStream.c
const int MAX_BUFFER_LEN = 2048;
System.Net.Sockets.Socket socket;
int buflen = 65536; // MAX_HEAP_BUFFER_LEN
int n;
if (fd == null)
{
throw new SocketException("socket closed");
}
else
{
socket = fd.getSocket();
}
if (data == null)
{
throw new java.lang.NullPointerException("data argument");
}
while (len > 0)
{
int loff = 0;
int chunkLen = java.lang.Math.min(buflen, len);
int llen = chunkLen;
int retry = 0;
while (llen > 0)
{
n = Winsock.send(socket, data, off + loff, llen, 0);
if (n > 0)
{
llen -= n;
loff += n;
continue;
}
/*
* Due to a bug in Windows Sockets (observed on NT and Windows
* 2000) it may be necessary to retry the send. The issue is that
* on blocking sockets send/WSASend is supposed to block if there
* is insufficient buffer space available. If there are a large
* number of threads blocked on write due to congestion then it's
* possile to hit the NT/2000 bug whereby send returns WSAENOBUFS.
* The workaround we use is to retry the send. If we have a
* large buffer to send (>2k) then we retry with a maximum of
* 2k buffer. If we hit the issue with <=2k buffer then we backoff
* for 1 second and retry again. We repeat this up to a reasonable
* limit before bailing out and throwing an exception. In load
* conditions we've observed that the send will succeed after 2-3
* attempts but this depends on network buffers associated with
* other sockets draining.
*/
if (Winsock.WSAGetLastError() == Winsock.WSAENOBUFS)
{
if (llen > MAX_BUFFER_LEN)
{
buflen = MAX_BUFFER_LEN;
chunkLen = MAX_BUFFER_LEN;
llen = MAX_BUFFER_LEN;
continue;
}
if (retry >= 30)
{
throw new SocketException("No buffer space available - exhausted attempts to queue buffer");
}
System.Threading.Thread.Sleep(1000);
retry++;
continue;
}
/*
* Send failed - can be caused by close or write error.
*/
if (Winsock.WSAGetLastError() == Winsock.WSAENOTSOCK)
{
throw new SocketException("Socket closed");
}
else
{
throw net_util_md.NET_ThrowCurrent("socket write error");
}
}
len -= chunkLen;
off += chunkLen;
}
#endif
}
public static void close0(object _this, [In] java.io.FileDescriptor fd)
{
#if !FIRST_PASS
fd.close();
#endif
}
public static void setLength(object _this, long newLength, [In] java.io.FileDescriptor fd)
{
#if !FIRST_PASS
fd.setLength(newLength);
#endif
}
public FileInputStream(FileDescriptor file)
{
}
public void setFileDescriptorsForSend(FileDescriptor[] fds)
{
}
public static int receive0(object obj, FileDescriptor fd, byte[] buf, int pos, int len, bool connected)
{
#if FIRST_PASS
return(0);
#else
sun.nio.ch.DatagramChannelImpl impl = (sun.nio.ch.DatagramChannelImpl)obj;
java.net.SocketAddress remoteAddress = impl.remoteAddress();
System.Net.EndPoint remoteEP;
if (fd.getSocket().AddressFamily == System.Net.Sockets.AddressFamily.InterNetworkV6)
{
remoteEP = new System.Net.IPEndPoint(System.Net.IPAddress.IPv6Any, 0);
}
else
{
remoteEP = new System.Net.IPEndPoint(0, 0);
}
java.net.InetSocketAddress addr;
int length;
do
{
for (; ;)
{
try
{
length = fd.getSocket().ReceiveFrom(buf, pos, len, System.Net.Sockets.SocketFlags.None, ref remoteEP);
break;
}
catch (System.Net.Sockets.SocketException x)
{
if (x.ErrorCode == java.net.SocketUtil.WSAECONNRESET)
{
// A previous send failed (i.e. the remote host responded with a ICMP that the port is closed) and
// the winsock stack helpfully lets us know this, but we only care about this when we're connected,
// otherwise we'll simply retry the receive (note that we use SIO_UDP_CONNRESET to prevent these
// WSAECONNRESET exceptions, but when switching from connected to disconnected, some can slip through).
if (connected)
{
throw new java.net.PortUnreachableException();
}
continue;
}
if (x.ErrorCode == java.net.SocketUtil.WSAEMSGSIZE)
{
// The buffer size was too small for the packet, ReceiveFrom receives the part of the packet
// that fits in the buffer and then throws an exception, so we have to ignore the exception in this case.
length = len;
break;
}
if (x.ErrorCode == java.net.SocketUtil.WSAEWOULDBLOCK)
{
return(sun.nio.ch.IOStatus.UNAVAILABLE);
}
throw java.net.SocketUtil.convertSocketExceptionToIOException(x);
}
catch (ObjectDisposedException)
{
throw new java.net.SocketException("Socket is closed");
}
}
System.Net.IPEndPoint ep = (System.Net.IPEndPoint)remoteEP;
addr = new java.net.InetSocketAddress(java.net.SocketUtil.getInetAddressFromIPEndPoint(ep), ep.Port);
} while (remoteAddress != null && !addr.equals(remoteAddress));
impl.sender = addr;
return(length);
#endif
}
public static void open0(object _this, string name, [In] java.io.FileDescriptor fd)
{
#if !FIRST_PASS
fd.openReadOnly(name);
#endif
}
public virtual long GetHandle(FileDescriptor obj)
{
return(obj.Handle);
}
public virtual void SetHandle(FileDescriptor obj, long handle)
{
obj.Handle = handle;
}
public virtual int Get(FileDescriptor obj)
{
return(obj.Fd);
}
public virtual void Set(FileDescriptor obj, int fd)
{
obj.Fd = fd;
}
public static void getFlowOption(java.io.FileDescriptor fd, object f)
{
#if !FIRST_PASS
throw new java.lang.UnsupportedOperationException();
#endif
}
public static void updateAcceptContext(FileDescriptor listenSocket, FileDescriptor acceptSocket)
{
// already handled by .NET Framework
}
public static void write0(object _this, int b, [In] java.io.FileDescriptor fd)
{
#if !FIRST_PASS
fd.write(b);
#endif
}
public static void updateConnectContext(FileDescriptor fd)
{
// already handled by .NET Framework
}
public static void writeBytes(object _this, byte[] b, int off, int len, [In] java.io.FileDescriptor fd)
{
#if !FIRST_PASS
fd.writeBytes(b, off, len);
#endif
}
public FileInputStream(FileDescriptor file)
{
}
public static void seek0(object _this, long pos, [In] java.io.FileDescriptor fd)
{
#if !FIRST_PASS
fd.seek(pos);
#endif
}
/// <summary>
/// Constructs a FileWriter object associated with a file descriptor.
/// </summary>
public FileWriter(FileDescriptor fd)
{
}
/// <summary>
/// Constructs a FileWriter object associated with a file descriptor.
/// </summary>
public FileWriter(FileDescriptor fd)
{
}