Exemplo n.º 1
0
        /// <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
    }
Exemplo n.º 4
0
    public static void close0(object _this, [In] java.io.FileDescriptor fd)
    {
#if !FIRST_PASS
        fd.close();
#endif
    }
Exemplo n.º 5
0
    public static void setLength(object _this, long newLength, [In] java.io.FileDescriptor fd)
    {
#if !FIRST_PASS
        fd.setLength(newLength);
#endif
    }
Exemplo n.º 6
0
 public FileInputStream(FileDescriptor file)
 {
 }
Exemplo n.º 7
0
 public void setFileDescriptorsForSend(FileDescriptor[] fds)
 {
 }
Exemplo n.º 8
0
    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
    }
Exemplo n.º 9
0
    public static void open0(object _this, string name, [In] java.io.FileDescriptor fd)
    {
#if !FIRST_PASS
        fd.openReadOnly(name);
#endif
    }
Exemplo n.º 10
0
 public virtual long GetHandle(FileDescriptor obj)
 {
     return(obj.Handle);
 }
Exemplo n.º 11
0
 public virtual void SetHandle(FileDescriptor obj, long handle)
 {
     obj.Handle = handle;
 }
Exemplo n.º 12
0
 public virtual int Get(FileDescriptor obj)
 {
     return(obj.Fd);
 }
Exemplo n.º 13
0
 public virtual void Set(FileDescriptor obj, int fd)
 {
     obj.Fd = fd;
 }
Exemplo n.º 14
0
    public static void getFlowOption(java.io.FileDescriptor fd, object f)
    {
#if !FIRST_PASS
        throw new java.lang.UnsupportedOperationException();
#endif
    }
Exemplo n.º 15
0
 public static void updateAcceptContext(FileDescriptor listenSocket, FileDescriptor acceptSocket)
 {
     // already handled by .NET Framework
 }
Exemplo n.º 16
0
    public static void write0(object _this, int b, [In] java.io.FileDescriptor fd)
    {
#if !FIRST_PASS
        fd.write(b);
#endif
    }
Exemplo n.º 17
0
 public static void updateConnectContext(FileDescriptor fd)
 {
     // already handled by .NET Framework
 }
Exemplo n.º 18
0
    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
    }
Exemplo n.º 19
0
 public FileInputStream(FileDescriptor file)
 {
 }
Exemplo n.º 20
0
    public static void seek0(object _this, long pos, [In] java.io.FileDescriptor fd)
    {
#if !FIRST_PASS
        fd.seek(pos);
#endif
    }
Exemplo n.º 21
0
 /// <summary>
 /// Constructs a FileWriter object associated with a file descriptor.
 /// </summary>
 public FileWriter(FileDescriptor fd)
 {
 }
Exemplo n.º 22
0
 /// <summary>
 /// Constructs a FileWriter object associated with a file descriptor.
 /// </summary>
 public FileWriter(FileDescriptor fd)
 {
 }