| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| // BEGIN android-note |
| // address length was changed from long to int for performance reasons. |
| // END android-note |
| |
| package org.apache.harmony.luni.platform; |
| |
| import java.io.FileDescriptor; |
| import java.io.IOException; |
| import java.net.DatagramPacket; |
| import java.net.InetAddress; |
| import java.net.SocketException; |
| import java.net.SocketImpl; |
| import java.net.UnknownHostException; |
| import java.nio.channels.Channel; |
| // BEGIN android-removed |
| // import java.nio.channels.SelectableChannel; |
| // END android-removed |
| /* |
| * |
| * This Class is used for native code wrap, the implement class of |
| * INetworkSystem. |
| * |
| */ |
| final class OSNetworkSystem implements INetworkSystem { |
| |
| // ---------------------------------------------------- |
| // Class Variables |
| // ---------------------------------------------------- |
| |
| private static final int ERRORCODE_SOCKET_TIMEOUT = -209; |
| |
| private static OSNetworkSystem ref = new OSNetworkSystem(); |
| |
| private static final int INETADDR_REACHABLE = 0; |
| |
| private static boolean isNetworkInited = false; |
| |
| |
| // ---------------------------------------------------- |
| // Class Constructor |
| // ---------------------------------------------------- |
| |
| // can not be instantiated. |
| private OSNetworkSystem() { |
| super(); |
| } |
| |
| /* |
| * @return a static ref of this class |
| */ |
| public static OSNetworkSystem getOSNetworkSystem() { |
| return ref; |
| } |
| |
| // Useing when cache set/get is OK |
| // public static native void oneTimeInitializationDatagram( |
| // boolean jcl_IPv6_support); |
| // |
| // public static native void oneTimeInitializationSocket( |
| // boolean jcl_IPv6_support); |
| |
| // -------------------------------------------------- |
| // java codes that wrap native codes |
| // -------------------------------------------------- |
| |
| public void createSocket(FileDescriptor fd, boolean preferIPv4Stack) |
| throws IOException { |
| createSocketImpl(fd, preferIPv4Stack); |
| } |
| |
| public void createDatagramSocket(FileDescriptor fd, boolean preferIPv4Stack) |
| throws SocketException { |
| createDatagramSocketImpl(fd, preferIPv4Stack); |
| } |
| |
| public int read(FileDescriptor aFD, byte[] data, int offset, int count, |
| int timeout) throws IOException { |
| return readSocketImpl(aFD, data, offset, count, timeout); |
| } |
| |
| public int readDirect(FileDescriptor aFD, int address, int offset, int count, |
| int timeout) throws IOException { |
| return readSocketDirectImpl(aFD, address, offset, count, timeout); |
| } |
| |
| public int write(FileDescriptor aFD, byte[] data, int offset, int count) |
| throws IOException { |
| return writeSocketImpl(aFD, data, offset, count); |
| } |
| |
| public int writeDirect(FileDescriptor aFD, int address, int offset, |
| int count) throws IOException { |
| return writeSocketDirectImpl(aFD, address, offset, count); |
| } |
| |
| public void setNonBlocking(FileDescriptor aFD, boolean block) |
| throws IOException { |
| setNonBlockingImpl(aFD, block); |
| } |
| |
| public void connectDatagram(FileDescriptor aFD, int port, int trafficClass, |
| InetAddress inetAddress) throws SocketException { |
| connectDatagramImpl2(aFD, port, trafficClass, inetAddress); |
| } |
| |
| public int connect(FileDescriptor aFD, int trafficClass, |
| InetAddress inetAddress, int port) throws IOException{ |
| return connectSocketImpl(aFD, trafficClass, inetAddress, port); |
| } |
| |
| // BEGIN android-changed |
| public int connectWithTimeout(FileDescriptor aFD, int timeout, |
| int trafficClass, InetAddress inetAddress, int port, int step, |
| byte[] context) throws IOException{ |
| return connectWithTimeoutSocketImpl(aFD, timeout, trafficClass, |
| inetAddress, port, step, context); |
| } |
| // END android-changed |
| |
| public void connectStreamWithTimeoutSocket(FileDescriptor aFD, int aport, |
| int timeout, int trafficClass, InetAddress inetAddress) |
| throws IOException { |
| connectStreamWithTimeoutSocketImpl(aFD, aport, timeout, trafficClass, |
| inetAddress); |
| } |
| |
| public void bind(FileDescriptor aFD, int port, InetAddress inetAddress) |
| throws SocketException { |
| socketBindImpl(aFD, port, inetAddress); |
| } |
| |
| public boolean bind2(FileDescriptor aFD, int port, boolean bindToDevice, |
| InetAddress inetAddress) throws SocketException { |
| return socketBindImpl2(aFD, port, bindToDevice, inetAddress); |
| } |
| |
| public void accept(FileDescriptor fdServer, SocketImpl newSocket, |
| FileDescriptor fdnewSocket, int timeout) throws IOException { |
| acceptSocketImpl(fdServer, newSocket, fdnewSocket, timeout); |
| } |
| |
| public int sendDatagram(FileDescriptor fd, byte[] data, int offset, |
| int length, int port, boolean bindToDevice, int trafficClass, |
| InetAddress inetAddress) throws IOException { |
| return sendDatagramImpl(fd, data, offset, length, port, bindToDevice, |
| trafficClass, inetAddress); |
| } |
| |
| public int sendDatagramDirect(FileDescriptor fd, int address, int offset, |
| int length, int port, boolean bindToDevice, int trafficClass, |
| InetAddress inetAddress) throws IOException { |
| return sendDatagramDirectImpl(fd, address, offset, length, port, bindToDevice, |
| trafficClass, inetAddress); |
| } |
| |
| public int sendDatagram2(FileDescriptor fd, byte[] data, int offset, |
| int length, int port, InetAddress inetAddress) throws IOException { |
| return sendDatagramImpl2(fd, data, offset, length, port, inetAddress); |
| } |
| |
| public int receiveDatagram(FileDescriptor aFD, DatagramPacket packet, |
| byte[] data, int offset, int length, int receiveTimeout, |
| boolean peek) throws IOException { |
| return receiveDatagramImpl(aFD, packet, data, offset, length, |
| receiveTimeout, peek); |
| } |
| |
| public int receiveDatagramDirect(FileDescriptor aFD, DatagramPacket packet, |
| int address, int offset, int length, int receiveTimeout, |
| boolean peek) throws IOException { |
| return receiveDatagramDirectImpl(aFD, packet, address, offset, length, |
| receiveTimeout, peek); |
| } |
| |
| public int recvConnectedDatagram(FileDescriptor aFD, DatagramPacket packet, |
| byte[] data, int offset, int length, int receiveTimeout, |
| boolean peek) throws IOException { |
| return recvConnectedDatagramImpl(aFD, packet, data, offset, length, |
| receiveTimeout, peek); |
| } |
| |
| public int recvConnectedDatagramDirect(FileDescriptor aFD, DatagramPacket packet, int address, |
| int offset, int length, int receiveTimeout, boolean peek) |
| throws IOException { |
| return recvConnectedDatagramDirectImpl(aFD, packet, address, offset, length, receiveTimeout, peek); |
| } |
| |
| public int peekDatagram(FileDescriptor aFD, InetAddress sender, |
| int receiveTimeout) throws IOException { |
| return peekDatagramImpl(aFD, sender, receiveTimeout); |
| } |
| |
| public int sendConnectedDatagram(FileDescriptor fd, byte[] data, |
| int offset, int length, boolean bindToDevice) throws IOException { |
| return sendConnectedDatagramImpl(fd, data, offset, length, bindToDevice); |
| } |
| |
| public int sendConnectedDatagramDirect(FileDescriptor fd, int address, |
| int offset, int length, boolean bindToDevice) throws IOException { |
| return sendConnectedDatagramDirectImpl(fd, address, offset, length, bindToDevice); |
| } |
| |
| public void disconnectDatagram(FileDescriptor aFD) throws SocketException { |
| disconnectDatagramImpl(aFD); |
| } |
| |
| public void createMulticastSocket(FileDescriptor aFD, |
| boolean preferIPv4Stack) throws SocketException { |
| createMulticastSocketImpl(aFD, preferIPv4Stack); |
| } |
| |
| public void createServerStreamSocket(FileDescriptor aFD, |
| boolean preferIPv4Stack) throws SocketException { |
| createServerStreamSocketImpl(aFD, preferIPv4Stack); |
| } |
| |
| public int receiveStream(FileDescriptor aFD, byte[] data, int offset, |
| int count, int timeout) throws IOException { |
| return receiveStreamImpl(aFD, data, offset, count, timeout); |
| } |
| |
| public int sendStream(FileDescriptor fd, byte[] data, int offset, int count) |
| throws IOException { |
| return sendStreamImpl(fd, data, offset, count); |
| } |
| |
| public void shutdownInput(FileDescriptor descriptor) throws IOException { |
| shutdownInputImpl(descriptor); |
| } |
| |
| public void shutdownOutput(FileDescriptor descriptor) throws IOException { |
| shutdownOutputImpl(descriptor); |
| } |
| |
| public boolean supportsUrgentData(FileDescriptor fd) { |
| return supportsUrgentDataImpl(fd); |
| } |
| |
| public void sendUrgentData(FileDescriptor fd, byte value) { |
| sendUrgentDataImpl(fd, value); |
| } |
| |
| public int availableStream(FileDescriptor aFD) throws SocketException { |
| return availableStreamImpl(aFD); |
| } |
| |
| // BEGIN android-removed |
| // public void acceptStreamSocket(FileDescriptor fdServer, |
| // SocketImpl newSocket, FileDescriptor fdnewSocket, int timeout) |
| // throws IOException { |
| // acceptStreamSocketImpl(fdServer, newSocket, fdnewSocket, timeout); |
| // } |
| // |
| // public void createStreamSocket(FileDescriptor aFD, boolean preferIPv4Stack) |
| // throws SocketException { |
| // createStreamSocketImpl(aFD, preferIPv4Stack); |
| // } |
| // END android-removed |
| |
| public void listenStreamSocket(FileDescriptor aFD, int backlog) |
| throws SocketException { |
| listenStreamSocketImpl(aFD, backlog); |
| } |
| |
| // BEGIN android-removed |
| // public boolean isReachableByICMP(final InetAddress dest, |
| // InetAddress source, final int ttl, final int timeout) { |
| // return INETADDR_REACHABLE == isReachableByICMPImpl(dest, source, ttl, |
| // timeout); |
| // } |
| // END android-removed |
| |
| /* |
| * |
| * @param |
| * readChannels all channels interested in read and accept |
| * @param |
| * writeChannels all channels interested in write and connect |
| * @param timeout |
| * timeout in millis @return a set of channels that are ready for operation |
| * @throws |
| * SocketException @return int array, each int approve one of the * channel if OK |
| */ |
| |
| public int[] select(FileDescriptor[] readFDs, |
| FileDescriptor[] writeFDs, long timeout) |
| throws SocketException { |
| int countRead = readFDs.length; |
| int countWrite = writeFDs.length; |
| int result = 0; |
| if (0 == countRead + countWrite) { |
| return (new int[0]); |
| } |
| int[] flags = new int[countRead + countWrite]; |
| |
| // handle timeout in native |
| result = selectImpl(readFDs, writeFDs, countRead, countWrite, flags, |
| timeout); |
| |
| if (0 <= result) { |
| return flags; |
| } |
| if (ERRORCODE_SOCKET_TIMEOUT == result) { |
| return new int[0]; |
| } |
| throw new SocketException(); |
| |
| } |
| |
| public InetAddress getSocketLocalAddress(FileDescriptor aFD, |
| boolean preferIPv6Addresses) { |
| return getSocketLocalAddressImpl(aFD, preferIPv6Addresses); |
| } |
| |
| /* |
| * Query the IP stack for the local port to which this socket is bound. |
| * |
| * @param aFD the socket descriptor @param preferIPv6Addresses address |
| * preference for nodes that support both IPv4 and IPv6 @return int the |
| * local port to which the socket is bound |
| */ |
| public int getSocketLocalPort(FileDescriptor aFD, |
| boolean preferIPv6Addresses) { |
| return getSocketLocalPortImpl(aFD, preferIPv6Addresses); |
| } |
| |
| /* |
| * Query the IP stack for the nominated socket option. |
| * |
| * @param aFD the socket descriptor @param opt the socket option type |
| * @return the nominated socket option value |
| * |
| * @throws SocketException if the option is invalid |
| */ |
| public Object getSocketOption(FileDescriptor aFD, int opt) |
| throws SocketException { |
| return getSocketOptionImpl(aFD, opt); |
| } |
| |
| /* |
| * Set the nominated socket option in the IP stack. |
| * |
| * @param aFD the socket descriptor @param opt the option selector @param |
| * optVal the nominated option value |
| * |
| * @throws SocketException if the option is invalid or cannot be set |
| */ |
| public void setSocketOption(FileDescriptor aFD, int opt, Object optVal) |
| throws SocketException { |
| setSocketOptionImpl(aFD, opt, optVal); |
| } |
| |
| public int getSocketFlags() { |
| return getSocketFlagsImpl(); |
| } |
| |
| /* |
| * Close the socket in the IP stack. |
| * |
| * @param aFD the socket descriptor |
| */ |
| public void socketClose(FileDescriptor aFD) throws IOException { |
| socketCloseImpl(aFD); |
| } |
| |
| public InetAddress getHostByAddr(byte[] addr) throws UnknownHostException { |
| return getHostByAddrImpl(addr); |
| } |
| |
| public InetAddress getHostByName(String addr, boolean preferIPv6Addresses) |
| throws UnknownHostException { |
| return getHostByNameImpl(addr, preferIPv6Addresses); |
| } |
| |
| public void setInetAddress(InetAddress sender, byte[] address) { |
| setInetAddressImpl(sender, address); |
| } |
| |
| // --------------------------------------------------- |
| // Native Codes |
| // --------------------------------------------------- |
| |
| static native void createSocketImpl(FileDescriptor fd, |
| boolean preferIPv4Stack); |
| |
| /* |
| * Allocate a datagram socket in the IP stack. The socket is associated with |
| * the <code>aFD</code>. |
| * |
| * @param aFD the FileDescriptor to associate with the socket @param |
| * preferIPv4Stack IP stack preference if underlying platform is V4/V6 |
| * @exception SocketException upon an allocation error |
| */ |
| static native void createDatagramSocketImpl(FileDescriptor aFD, |
| boolean preferIPv4Stack) throws SocketException; |
| |
| static native int readSocketImpl(FileDescriptor aFD, byte[] data, |
| int offset, int count, int timeout) throws IOException; |
| |
| static native int readSocketDirectImpl(FileDescriptor aFD, int address, |
| int offset, int count, int timeout) throws IOException; |
| |
| static native int writeSocketImpl(FileDescriptor fd, byte[] data, |
| int offset, int count) throws IOException; |
| |
| static native int writeSocketDirectImpl(FileDescriptor fd, int address, |
| int offset, int count) throws IOException; |
| |
| static native void setNonBlockingImpl(FileDescriptor aFD, |
| boolean block); |
| |
| static native int connectSocketImpl(FileDescriptor aFD, |
| int trafficClass, InetAddress inetAddress, int port); |
| |
| // BEGIN android-changed |
| static native int connectWithTimeoutSocketImpl( |
| FileDescriptor aFD, int timeout, int trafficClass, |
| InetAddress hostname, int port, int step, byte[] context); |
| // END android-changed |
| |
| static native void connectStreamWithTimeoutSocketImpl(FileDescriptor aFD, |
| int aport, int timeout, int trafficClass, InetAddress inetAddress) |
| throws IOException; |
| |
| static native void socketBindImpl(FileDescriptor aFD, int port, |
| InetAddress inetAddress) throws SocketException; |
| |
| static native void listenStreamSocketImpl(FileDescriptor aFD, int backlog) |
| throws SocketException; |
| |
| static native int availableStreamImpl(FileDescriptor aFD) |
| throws SocketException; |
| |
| static native void acceptSocketImpl(FileDescriptor fdServer, |
| SocketImpl newSocket, FileDescriptor fdnewSocket, int timeout) |
| throws IOException; |
| |
| static native boolean supportsUrgentDataImpl(FileDescriptor fd); |
| |
| static native void sendUrgentDataImpl(FileDescriptor fd, byte value); |
| |
| /* |
| * Connect the socket to a port and address |
| * |
| * @param aFD the FileDescriptor to associate with the socket @param port |
| * the port to connect to @param trafficClass the traffic Class to be used |
| * then the connection is made @param inetAddress address to connect to. |
| * |
| * @exception SocketException if the connect fails |
| */ |
| static native void connectDatagramImpl2(FileDescriptor aFD, |
| int port, int trafficClass, InetAddress inetAddress) |
| throws SocketException; |
| |
| /* |
| * Disconnect the socket to a port and address |
| * |
| * @param aFD the FileDescriptor to associate with the socket |
| * |
| * @exception SocketException if the disconnect fails |
| */ |
| static native void disconnectDatagramImpl(FileDescriptor aFD) |
| throws SocketException; |
| |
| /* |
| * Allocate a datagram socket in the IP stack. The socket is associated with |
| * the <code>aFD</code>. |
| * |
| * @param aFD the FileDescriptor to associate with the socket @param |
| * preferIPv4Stack IP stack preference if underlying platform is V4/V6 |
| * @exception SocketException upon an allocation error |
| */ |
| |
| /* |
| * Bind the socket to the port/localhost in the IP stack. |
| * |
| * @param aFD the socket descriptor @param port the option selector @param |
| * bindToDevice bind the socket to the specified interface @param |
| * inetAddress address to connect to. @return if bind successful @exception |
| * SocketException thrown if bind operation fails |
| */ |
| static native boolean socketBindImpl2(FileDescriptor aFD, |
| int port, boolean bindToDevice, InetAddress inetAddress) |
| throws SocketException; |
| |
| /* |
| * Peek on the socket, update <code>sender</code> address and answer the |
| * sender port. |
| * |
| * @param aFD the socket FileDescriptor @param sender an InetAddress, to be |
| * updated with the sender's address @param receiveTimeout the maximum |
| * length of time the socket should block, reading @return int the sender |
| * port |
| * |
| * @exception IOException upon an read error or timeout |
| */ |
| static native int peekDatagramImpl(FileDescriptor aFD, |
| InetAddress sender, int receiveTimeout) throws IOException; |
| |
| /* |
| * Recieve data on the socket into the specified buffer. The packet fields |
| * <code>data</code> & <code>length</code> are passed in addition to |
| * <code>packet</code> to eliminate the JNI field access calls. |
| * |
| * @param aFD the socket FileDescriptor @param packet the DatagramPacket to |
| * receive into @param data the data buffer of the packet @param offset the |
| * offset in the data buffer @param length the length of the data buffer in |
| * the packet @param receiveTimeout the maximum length of time the socket |
| * should block, reading @param peek indicates to peek at the data @return |
| * number of data received @exception IOException upon an read error or |
| * timeout |
| */ |
| static native int receiveDatagramImpl(FileDescriptor aFD, |
| DatagramPacket packet, byte[] data, int offset, int length, |
| int receiveTimeout, boolean peek) throws IOException; |
| |
| static native int receiveDatagramDirectImpl(FileDescriptor aFD, |
| DatagramPacket packet, int address, int offset, int length, |
| int receiveTimeout, boolean peek) throws IOException; |
| |
| /* |
| * Recieve data on the connected socket into the specified buffer. The |
| * packet fields <code>data</code> & <code>length</code> are passed in |
| * addition to <code>packet</code> to eliminate the JNI field access |
| * calls. |
| * |
| * @param aFD the socket FileDescriptor @param packet the DatagramPacket to |
| * receive into @param data the data buffer of the packet @param offset the |
| * offset in the data buffer @param length the length of the data buffer in |
| * the packet @param receiveTimeout the maximum length of time the socket |
| * should block, reading @param peek indicates to peek at the data @return |
| * number of data received @exception IOException upon an read error or |
| * timeout |
| */ |
| static native int recvConnectedDatagramImpl(FileDescriptor aFD, |
| DatagramPacket packet, byte[] data, int offset, int length, |
| int receiveTimeout, boolean peek) throws IOException; |
| |
| static native int recvConnectedDatagramDirectImpl(FileDescriptor aFD, |
| DatagramPacket packet, int address, int offset, int length, |
| int receiveTimeout, boolean peek) throws IOException; |
| |
| /* |
| * Send the <code>data</code> to the nominated target <code>address</code> |
| * and <code>port</code>. These values are derived from the |
| * DatagramPacket to reduce the field calls within JNI. |
| * |
| * @param fd the socket FileDescriptor @param data the data buffer of the |
| * packet @param offset the offset in the data buffer @param length the |
| * length of the data buffer in the packet @param port the target host port |
| * @param bindToDevice if bind to device @param trafficClass the traffic |
| * class to be used when the datagram is sent @param inetAddress address to |
| * connect to. @return number of data send |
| * |
| * @exception IOException upon an read error or timeout |
| */ |
| static native int sendDatagramImpl(FileDescriptor fd, |
| byte[] data, int offset, int length, int port, |
| boolean bindToDevice, int trafficClass, InetAddress inetAddress) |
| throws IOException; |
| |
| static native int sendDatagramDirectImpl(FileDescriptor fd, |
| int address, int offset, int length, int port, |
| boolean bindToDevice, int trafficClass, InetAddress inetAddress) |
| throws IOException; |
| |
| /* |
| * Send the <code>data</code> to the address and port to which the was |
| * connnected and <code>port</code>. |
| * |
| * @param fd the socket FileDescriptor @param data the data buffer of the |
| * packet @param offset the offset in the data buffer @param length the |
| * length of the data buffer in the packet @param bindToDevice not used, |
| * current kept in case needed as was the case for sendDatagramImpl @return |
| * number of data send @exception IOException upon an read error or timeout |
| */ |
| static native int sendConnectedDatagramImpl(FileDescriptor fd, |
| byte[] data, int offset, int length, boolean bindToDevice) |
| throws IOException; |
| |
| static native int sendConnectedDatagramDirectImpl(FileDescriptor fd, |
| int address, int offset, int length, boolean bindToDevice) |
| throws IOException; |
| |
| /* |
| * Answer the result of attempting to create a server stream socket in the |
| * IP stack. Any special options required for server sockets will be set by |
| * this method. |
| * |
| * @param aFD the socket FileDescriptor @param preferIPv4Stack if use IPV4 |
| * @exception SocketException if an error occurs while creating the socket |
| */ |
| static native void createServerStreamSocketImpl(FileDescriptor aFD, |
| boolean preferIPv4Stack) throws SocketException; |
| |
| /* |
| * Answer the result of attempting to create a multicast socket in the IP |
| * stack. Any special options required for server sockets will be set by |
| * this method. |
| * |
| * @param aFD the socket FileDescriptor @param preferIPv4Stack if use IPV4 |
| * @exception SocketException if an error occurs while creating the socket |
| */ |
| static native void createMulticastSocketImpl(FileDescriptor aFD, |
| boolean preferIPv4Stack) throws SocketException; |
| |
| /* |
| * Recieve at most <code>count</code> bytes into the buffer <code>data</code> |
| * at the <code>offset</code> on the socket. |
| * |
| * @param aFD the socket FileDescriptor @param data the receive buffer |
| * @param offset the offset into the buffer @param count the max number of |
| * bytes to receive @param timeout the max time the read operation should |
| * block waiting for data @return int the actual number of bytes read |
| * @throws IOException @exception SocketException if an error occurs while |
| * reading |
| */ |
| static native int receiveStreamImpl(FileDescriptor aFD, byte[] data, |
| int offset, int count, int timeout) throws IOException; |
| |
| /* |
| * Send <code>count</code> bytes from the buffer <code>data</code> at |
| * the <code>offset</code>, on the socket. |
| * |
| * @param fd |
| * |
| * @param data the send buffer @param offset the offset into the buffer |
| * @param count the number of bytes to receive @return int the actual number |
| * of bytes sent @throws IOException @exception SocketException if an error |
| * occurs while writing |
| */ |
| static native int sendStreamImpl(FileDescriptor fd, byte[] data, |
| int offset, int count) throws IOException; |
| |
| private native void shutdownInputImpl(FileDescriptor descriptor) |
| throws IOException; |
| |
| private native void shutdownOutputImpl(FileDescriptor descriptor) |
| throws IOException; |
| |
| // BEGIN android-removed |
| // static native void acceptStreamSocketImpl(FileDescriptor fdServer, |
| // SocketImpl newSocket, FileDescriptor fdnewSocket, int timeout) |
| // throws IOException; |
| // |
| // static native void createStreamSocketImpl(FileDescriptor aFD, |
| // boolean preferIPv4Stack) throws SocketException; |
| // END android-removed |
| |
| static native int sendDatagramImpl2(FileDescriptor fd, byte[] data, |
| int offset, int length, int port, InetAddress inetAddress) |
| throws IOException; |
| |
| static native int selectImpl(FileDescriptor[] readfd, |
| FileDescriptor[] writefd, int cread, int cwirte, int[] flags, |
| long timeout); |
| |
| static native InetAddress getSocketLocalAddressImpl(FileDescriptor aFD, |
| boolean preferIPv6Addresses); |
| |
| /* |
| * Query the IP stack for the local port to which this socket is bound. |
| * |
| * @param aFD the socket descriptor @param preferIPv6Addresses address |
| * preference for nodes that support both IPv4 and IPv6 @return int the |
| * local port to which the socket is bound |
| */ |
| static native int getSocketLocalPortImpl(FileDescriptor aFD, |
| boolean preferIPv6Addresses); |
| |
| /* |
| * Query the IP stack for the nominated socket option. |
| * |
| * @param aFD the socket descriptor @param opt the socket option type |
| * @return the nominated socket option value |
| * |
| * @throws SocketException if the option is invalid |
| */ |
| static native Object getSocketOptionImpl(FileDescriptor aFD, int opt) |
| throws SocketException; |
| |
| /* |
| * Set the nominated socket option in the IP stack. |
| * |
| * @param aFD the socket descriptor @param opt the option selector @param |
| * optVal the nominated option value |
| * |
| * @throws SocketException if the option is invalid or cannot be set |
| */ |
| static native void setSocketOptionImpl(FileDescriptor aFD, int opt, |
| Object optVal) throws SocketException; |
| |
| static native int getSocketFlagsImpl(); |
| |
| /* |
| * Close the socket in the IP stack. |
| * |
| * @param aFD the socket descriptor |
| */ |
| static native void socketCloseImpl(FileDescriptor aFD); |
| |
| static native InetAddress getHostByAddrImpl(byte[] addr) |
| throws UnknownHostException; |
| |
| static native InetAddress getHostByNameImpl(String addr, |
| boolean preferIPv6Addresses) throws UnknownHostException; |
| |
| native void setInetAddressImpl(InetAddress sender, byte[] address); |
| |
| // BEGIN android-removed |
| // native int isReachableByICMPImpl(InetAddress addr, InetAddress local, |
| // int ttl, int timeout); |
| // END android-removed |
| |
| native Channel inheritedChannelImpl(); |
| |
| public Channel inheritedChannel() { |
| return inheritedChannelImpl(); |
| } |
| |
| public void oneTimeInitialization(boolean jcl_supports_ipv6){ |
| if (!isNetworkInited){ |
| oneTimeInitializationImpl(jcl_supports_ipv6); |
| isNetworkInited = true; |
| } |
| } |
| |
| native void oneTimeInitializationImpl (boolean jcl_supports_ipv6); |
| } |