IllegalBlockingModeException if the
* associated channel is in non-blocking mode, except
* if the operation is invoked by the channel itself.
*/
public final boolean isInChannelOperation()
{
return inChannelOperation;
}
/**
* Sets our indicator of whether an I/O operation is being
* initiated by a channel.
*/
public final void setInChannelOperation(boolean b)
{
inChannelOperation = b;
}
/**
* Default do nothing constructor
*/
public PlainSocketImpl()
{
}
protected void finalize() throws Throwable
{
synchronized (this)
{
if (native_fd != -1)
try
{
close();
}
catch (IOException ex)
{
}
}
super.finalize();
}
public int getNativeFD()
{
return native_fd;
}
/**
* Sets the specified option on a socket to the passed in object. For
* options that take an integer argument, the passed in object is an
* Integer. The option_id parameter is one of the defined constants in
* this interface.
*
* @param option_id The identifier of the option
* @param val The value to set the option to
*
* @exception SocketException If an error occurs
*/
public native void setOption(int optID, Object value) throws SocketException;
/**
* Returns the current setting of the specified option. The Object returned
* will be an Integer for options that have integer values. The option_id
* is one of the defined constants in this interface.
*
* @param option_id The option identifier
*
* @return The current value of the option
*
* @exception SocketException If an error occurs
*/
public native Object getOption(int optID) throws SocketException;
/**
* Flushes the input stream and closes it. If you read from the input stream
* after calling this method a IOException will be thrown.
*
* @throws IOException if an error occurs
*/
public native void shutdownInput() throws IOException;
/**
* Flushes the output stream and closes it. If you write to the output stream
* after calling this method a IOException will be thrown.
*
* @throws IOException if an error occurs
*/
public native void shutdownOutput() throws IOException;
/**
* Creates a new socket that is not bound to any local address/port and
* is not connected to any remote address/port. This will be created as
* a stream socket if the stream parameter is true, or a datagram socket
* if the stream parameter is false.
*
* @param stream true for a stream socket, false for a datagram socket
*/
// FIXME: this is public for nio ... but this is just a hack
// until we upgrade to Classpath's nio.
public native void create(boolean stream) throws IOException;
/**
* Connects to the remote hostname and port specified as arguments.
*
* @param hostname The remote hostname to connect to
* @param port The remote port to connect to
*
* @exception IOException If an error occurs
*/
protected void connect(String host, int port) throws IOException
{
connect(InetAddress.getByName(host), port);
}
/**
* Connects to the remote address and port specified as arguments.
*
* @param addr The remote address to connect to
* @param port The remote port to connect to
*
* @exception IOException If an error occurs
*/
protected void connect(InetAddress host, int port) throws IOException
{
connect (new InetSocketAddress (host, port), 0);
}
/**
* Connects to the remote socket address with a specified timeout.
*
* @param timeout The timeout to use for this connect, 0 means infinite.
*
* @exception IOException If an error occurs
*/
protected native void connect(SocketAddress addr, int timeout) throws IOException;
/**
* Binds to the specified port on the specified addr. Note that this addr
* must represent a local IP address. **** How bind to INADDR_ANY? ****
*
* @param addr The address to bind to
* @param port The port number to bind to
*
* @exception IOException If an error occurs
*/
protected native void bind(InetAddress host, int port)
throws IOException;
/**
* Starts listening for connections on a socket. The queuelen parameter
* is how many pending connections will queue up waiting to be serviced
* before being accept'ed. If the queue of pending requests exceeds this
* number, additional connections will be refused.
*
* @param queuelen The length of the pending connection queue
*
* @exception IOException If an error occurs
*/
protected native void listen(int queuelen)
throws IOException;
/**
* Accepts a new connection on this socket and returns in in the
* passed in SocketImpl.
*
* @param impl The SocketImpl object to accept this connection.
*/
protected void accept(SocketImpl impl)
throws IOException
{
accept((PlainSocketImpl) impl);
}
private native void accept(PlainSocketImpl impl)
throws IOException;
/**
* Returns the number of bytes that the caller can read from this socket
* without blocking.
*
* @return The number of readable bytes before blocking
*
* @exception IOException If an error occurs
*/
protected native int available() throws IOException;
/**
* Closes the socket. This will cause any InputStream or OutputStream
* objects for this Socket to be closed as well.
*
* Note that if the SO_LINGER option is set on this socket, then the
* operation could block.
*
* @exception IOException If an error occurs
*/
protected native void close() throws IOException;
protected native void sendUrgentData(int data) throws IOException;
public synchronized InetSocketAddress getLocalAddress()
{
if (localSocketAddress == null)
{
try
{
localSocketAddress
= new InetSocketAddress ((InetAddress) getOption(SocketOptions.SO_BINDADDR),
localport == -1 ? 0 : localport);
}
catch (SocketException _)
{
return null;
}
}
return localSocketAddress;
}
/**
* Returns an InputStream object for reading from this socket. This will
* be an instance of SocketInputStream.
*
* @return An input stream attached to the socket.
*
* @exception IOException If an error occurs
*/
protected synchronized InputStream getInputStream() throws IOException
{
if (in == null)
in = new SocketInputStream();
return in;
}
/**
* Returns an OutputStream object for writing to this socket. This will
* be an instance of SocketOutputStream.
*
* @return An output stream attached to the socket.
*
* @exception IOException If an error occurs
*/
protected synchronized OutputStream getOutputStream() throws IOException
{
if (out == null)
out = new SocketOutputStream();
return out;
}
/**
* This class contains an implementation of InputStream for
* sockets. It in an internal only class used by PlainSocketImpl.
*
* @author Nic Ferrier PlainSocketImpl to be the
* OutputStream subclass returned by its
* getOutputStream method. It expects only to be used in that
* context.
*
* @author Nic Ferrier