/*
`1.108 04/05/18
`* @(#)Socket.java
` *
` * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
`* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
`*/
`package java.net;
`import java.io.InputStream;
`import java.io.OutputStream;
`import java.io.IOException;
`import java.io.InterruptedIOException;
`import java.nio.channels.SocketChannel;
`import java.security.AccessController;
`import java.security.PrivilegedExceptionAction;
`/**
`* This class implements client sockets (also called just
`* "sockets"). A socket is an endpoint for communication
`* between two machines.
`* <p>
`* The actual work of the socket is performed by an instance of the
`* <code>SocketImpl</code> class. An application, by changing
`* the socket factory that creates the socket implementation,
`* can configure itself to create sockets appropriate to the local
`* firewall.
`*
` * @author unascribed
`* @version 1.108, 05/18/04
`* @see
` java.net.Socket#setSocketImplFactory(java.net.SocketImplFactory)
` java.net.SocketImpl
`* @see
`* @see
` java.nio.channels.SocketChannel
`* @since JDK1.0
`*/
`public
`class Socket {
` /**
`* Various states of this socket.
`*/
` private boolean created = false;
` private boolean bound = false;
` private boolean connected = false;
` private boolean closed = false;
` private Object closeLock = new Object();
` private boolean shutIn = false;
` private boolean shutOut = false;
` /**
`* The implementation of this Socket.
`*/
` SocketImpl impl;
` /**
`* Are we using an older SocketImpl?
`*/
` private boolean oldImpl = false;
` /**
`* Creates an unconnected socket, with the
`* system-default type of SocketImpl.
`*
`
`Juniper Ex. 1025-p. 1
`Juniper v Finjan
`
`

`

` * @since JDK1.1
` * @revised 1.4
` */
` public Socket() {
`setImpl();
` }
` /**
` * Creates an unconnected socket, specifying the type of proxy, if any,
` * that should be used regardless of any other settings.
` * <P>
` * If there is a security manager, its <code>checkConnect</code> method
` * is called with the proxy host address and port number
` * as its arguments. This could result in a SecurityException.
` * <P>
` * Examples:
` * <UL> <LI><code>Socket s = new Socket(Proxy.NO_PROXY);</code> will create
` * a plain socket ignoring any other proxy configuration.</LI>
` * <LI><code>Socket s = new Socket(new Proxy(Proxy.Type.SOCKS, new
`InetSocketAddress("socks.mydom.com", 1080)));</code>
` * will create a socket connecting through the specified SOCKS proxy
` * server.</LI>
` * </UL>
` *
` * @param proxy a {@link java.net.Proxy Proxy} object specifying what kind
` *
` of proxying should be used.
` * @throws IllegalArgumentException if the proxy is of an invalid type
` *
`or <code>null</code>.
` * @throws SecurityException if a security manager is present and
` *
` permission to connect to the proxy is
` *
` denied.
` * @see java.net.ProxySelector
` * @see java.net.Proxy
` *
` * @since 1.5
` */
` public Socket(Proxy proxy) {
`if (proxy != null && proxy.type() == Proxy.Type.SOCKS) {
` SecurityManager security = System.getSecurityManager();
` InetSocketAddress epoint = (InetSocketAddress) proxy.address();
` if (security != null) {
`if (epoint.isUnresolved())
` security.checkConnect(epoint.getHostName(),
` epoint.getPort());
`else
` security.checkConnect(epoint.getAddress().getHostAddress(),
` epoint.getPort());
` }
` impl = new SocksSocketImpl(proxy);
` impl.setSocket(this);
`} else {
` if (proxy == Proxy.NO_PROXY) {
`if (factory == null) {
` impl = new PlainSocketImpl();
` impl.setSocket(this);
`} else
` setImpl();
` } else
`throw new IllegalArgumentException("Invalid Proxy");
`}
`
` }
`
`Juniper Ex. 1025-p. 2
`Juniper v Finjan
`
`

`

` /**
` * Creates an unconnected Socket with a user-specified
` * SocketImpl.
` * <P>
` * @param impl an instance of a <B>SocketImpl</B>
` * the subclass wishes to use on the Socket.
` *
` * @exception SocketException if there is an error in the underlying protocol,
` * such as a TCP error.
` * @since JDK1.1
` */
` protected Socket(SocketImpl impl) throws SocketException {
`this.impl = impl;
`if (impl != null) {
` checkOldImpl();
` this.impl.setSocket(this);
`}
`
` }
` /**
` * Creates a stream socket and connects it to the specified port
` * number on the named host.
` * <p>
` * If the specified host is <tt>null</tt> it is the equivalent of
` * specifying the address as <tt>{@link java.net.InetAddress#getByName
`InetAddress.getByName}(null)</tt>.
` * In other words, it is equivalent to specifying an address of the
` * loopback interface. </p>
` * <p>
` * If the application has specified a server socket factory, that
` * factory's <code>createSocketImpl</code> method is called to create
` * the actual socket implementation. Otherwise a "plain" socket is created.
` * <p>
` * If there is a security manager, its
` * <code>checkConnect</code> method is called
` * with the host address and <code>port</code>
` * as its arguments. This could result in a SecurityException.
` *
` * @param host the host name, or <code>null</code> for the loopback address.
` * @param port the port number.
` *
` * @exception UnknownHostException if the IP address of
` * the host could not be determined.
` *
` * @exception IOException if an I/O error occurs when creating the socket.
` * @exception SecurityException if a security manager exists and its
` * <code>checkConnect</code> method doesn't allow the operation.
` * @see java.net.Socket#setSocketImplFactory(java.net.SocketImplFactory)
` * @see java.net.SocketImpl
` * @see java.net.SocketImplFactory#createSocketImpl()
` * @see SecurityManager#checkConnect
` */
` public Socket(String host, int port)
`throws UnknownHostException, IOException
` {
`this(host != null ? new InetSocketAddress(host, port) :
` new InetSocketAddress(InetAddress.getByName(null), port),
` new InetSocketAddress(0), true);
`
` }
` /**
` * Creates a stream socket and connects it to the specified port
`
`Juniper Ex. 1025-p. 3
`Juniper v Finjan
`
`

`

` * number at the specified IP address.
` * <p>
` * If the application has specified a socket factory, that factory's
` * <code>createSocketImpl</code> method is called to create the
` * actual socket implementation. Otherwise a "plain" socket is created.
` * <p>
` * If there is a security manager, its
` * <code>checkConnect</code> method is called
` * with the host address and <code>port</code>
` * as its arguments. This could result in a SecurityException.
` *
` * @param address the IP address.
` * @param port the port number.
` * @exception IOException if an I/O error occurs when creating the socket.
` * @exception SecurityException if a security manager exists and its
` * <code>checkConnect</code> method doesn't allow the operation.
` * @see java.net.Socket#setSocketImplFactory(java.net.SocketImplFactory)
` * @see java.net.SocketImpl
` * @see java.net.SocketImplFactory#createSocketImpl()
` * @see SecurityManager#checkConnect
` */
` public Socket(InetAddress address, int port) throws IOException {
`this(address != null ? new InetSocketAddress(address, port) : null,
` new InetSocketAddress(0), true);
`
` }
` /**
` * Creates a socket and connects it to the specified remote host on
` * the specified remote port. The Socket will also bind() to the local
` * address and port supplied.
` * <p>
` * If the specified host is <tt>null</tt> it is the equivalent of
` * specifying the address as <tt>{@link java.net.InetAddress#getByName
`InetAddress.getByName}(null)</tt>.
` * In other words, it is equivalent to specifying an address of the
` * loopback interface. </p>
` * <p>
` * If there is a security manager, its
` * <code>checkConnect</code> method is called
` * with the host address and <code>port</code>
` * as its arguments. This could result in a SecurityException.
` *
` * @param host the name of the remote host, or <code>null</code> for the loopback
`address.
` * @param port the remote port
` * @param localAddr the local address the socket is bound to
` * @param localPort the local port the socket is bound to
` * @exception IOException if an I/O error occurs when creating the socket.
` * @exception SecurityException if a security manager exists and its
` * <code>checkConnect</code> method doesn't allow the operation.
` * @see SecurityManager#checkConnect
` * @since JDK1.1
` */
` public Socket(String host, int port, InetAddress localAddr,
` int localPort) throws IOException {
`this(host != null ? new InetSocketAddress(host, port) :
` new InetSocketAddress(InetAddress.getByName(null), port),
` new InetSocketAddress(localAddr, localPort), true);
`
` }
` /**
` * Creates a socket and connects it to the specified remote address on
`
`Juniper Ex. 1025-p. 4
`Juniper v Finjan
`
`

`

` * the specified remote port. The Socket will also bind() to the local
` * address and port supplied.
` * <p>
` * If there is a security manager, its
` * <code>checkConnect</code> method is called
` * with the host address and <code>port</code>
` * as its arguments. This could result in a SecurityException.
` *
` * @param address the remote address
` * @param port the remote port
` * @param localAddr the local address the socket is bound to
` * @param localPort the local port the socket is bound to
` * @exception IOException if an I/O error occurs when creating the socket.
` * @exception SecurityException if a security manager exists and its
` * <code>checkConnect</code> method doesn't allow the operation.
` * @see SecurityManager#checkConnect
` * @since JDK1.1
` */
` public Socket(InetAddress address, int port, InetAddress localAddr,
` int localPort) throws IOException {
`this(address != null ? new InetSocketAddress(address, port) : null,
` new InetSocketAddress(localAddr, localPort), true);
`
` }
` /**
` * Creates a stream socket and connects it to the specified port
` * number on the named host.
` * <p>
` * If the specified host is <tt>null</tt> it is the equivalent of
` * specifying the address as <tt>{@link java.net.InetAddress#getByName
`InetAddress.getByName}(null)</tt>.
` * In other words, it is equivalent to specifying an address of the
` * loopback interface. </p>
` * <p>
` * If the stream argument is <code>true</code>, this creates a
` * stream socket. If the stream argument is <code>false</code>, it
` * creates a datagram socket.
` * <p>
` * If the application has specified a server socket factory, that
` * factory's <code>createSocketImpl</code> method is called to create
` * the actual socket implementation. Otherwise a "plain" socket is created.
` * <p>
` * If there is a security manager, its
` * <code>checkConnect</code> method is called
` * with the host address and <code>port</code>
` * as its arguments. This could result in a SecurityException.
` * <p>
` * If a UDP socket is used, TCP/IP related socket options will not apply.
` *
` * @param host the host name, or <code>null</code> for the loopback address.
` * @param port the port number.
` * @param stream a <code>boolean</code> indicating whether this is
` * a stream socket or a datagram socket.
` * @exception IOException if an I/O error occurs when creating the socket.
` * @exception SecurityException if a security manager exists and its
` * <code>checkConnect</code> method doesn't allow the operation.
` * @see java.net.Socket#setSocketImplFactory(java.net.SocketImplFactory)
` * @see java.net.SocketImpl
` * @see java.net.SocketImplFactory#createSocketImpl()
` * @see SecurityManager#checkConnect
` * @deprecated Use DatagramSocket instead for UDP transport.
` */
`
`Juniper Ex. 1025-p. 5
`Juniper v Finjan
`
`

`

` @Deprecated
` public Socket(String host, int port, boolean stream) throws IOException {
`this(host != null ? new InetSocketAddress(host, port) :
` new InetSocketAddress(InetAddress.getByName(null), port),
` new InetSocketAddress(0), stream);
`
` }
` /**
` * Creates a socket and connects it to the specified port number at
` * the specified IP address.
` * <p>
` * If the stream argument is <code>true</code>, this creates a
` * stream socket. If the stream argument is <code>false</code>, it
` * creates a datagram socket.
` * <p>
` * If the application has specified a server socket factory, that
` * factory's <code>createSocketImpl</code> method is called to create
` * the actual socket implementation. Otherwise a "plain" socket is created.
` *
` * <p>If there is a security manager, its
` * <code>checkConnect</code> method is called
` * with <code>host.getHostAddress()</code> and <code>port</code>
` * as its arguments. This could result in a SecurityException.
` * <p>
` * If UDP socket is used, TCP/IP related socket options will not apply.
` *
` * @param host the IP address.
` * @param port the port number.
` * @param stream if <code>true</code>, create a stream socket;
` * otherwise, create a datagram socket.
` * @exception IOException if an I/O error occurs when creating the socket.
` * @exception SecurityException if a security manager exists and its
` * <code>checkConnect</code> method doesn't allow the operation.
` * @see java.net.Socket#setSocketImplFactory(java.net.SocketImplFactory)
` * @see java.net.SocketImpl
` * @see java.net.SocketImplFactory#createSocketImpl()
` * @see SecurityManager#checkConnect
` * @deprecated Use DatagramSocket instead for UDP transport.
` */
` @Deprecated
` public Socket(InetAddress host, int port, boolean stream) throws IOException {
`this(host != null ? new InetSocketAddress(host, port) : null,
` new InetSocketAddress(0), stream);
`
` }
` private Socket(SocketAddress address, SocketAddress localAddr,
` boolean stream) throws IOException {
`setImpl();
`// backward compatibility
`if (address == null)
` throw new NullPointerException();
`try {
` createImpl(stream);
` if (localAddr == null)
`localAddr = new InetSocketAddress(0);
` bind(localAddr);
` if (address != null)
`connect(address);
`} catch (IOException e) {
` close();
`
`Juniper Ex. 1025-p. 6
`Juniper v Finjan
`
`

`

` throw e;
`}
`
` }
` /**
` * Creates the socket implementation.
` *
` * @param stream a <code>boolean</code> value : <code>true</code> for a TCP socket,
` *
` <code>false</code> for UDP.
` * @throws IOException if creation fails
` * @since 1.4
` */
` void createImpl(boolean stream) throws SocketException {
`if (impl == null)
` setImpl();
`try {
` impl.create(stream);
` created = true;
`} catch (IOException e) {
` throw new SocketException(e.getMessage());
`}
`
` }
` private void checkOldImpl() {
`if (impl == null)
` return;
`// SocketImpl.connect() is a protected method, therefore we need to use
`// getDeclaredMethod, therefore we need permission to access the member
`try {
` AccessController.doPrivileged(new PrivilegedExceptionAction() {
` public Object run() throws NoSuchMethodException {
`Class[] cl = new Class[2];
`cl[0] = SocketAddress.class;
`cl[1] = Integer.TYPE;
`impl.getClass().getDeclaredMethod("connect", cl);
`return null;
`
` }
`});
`} catch (java.security.PrivilegedActionException e) {
` oldImpl = true;
`}
`
` }
` /**
` * Sets impl to the system-default type of SocketImpl.
` * @since 1.4
` */
` void setImpl() {
`if (factory != null) {
` impl = factory.createSocketImpl();
` checkOldImpl();
`} else {
` // No need to do a checkOldImpl() here, we know it's an up to date
` // SocketImpl!
` impl = new SocksSocketImpl();
`f (impl != null)
` impl.setSocket(this);
`
`}i
`
` }
`
` /**
`
`Juniper Ex. 1025-p. 7
`Juniper v Finjan
`
`

`

` * Get the <code>SocketImpl</code> attached to this socket, creating
` * it if necessary.
` *
` * @return
`the <code>SocketImpl</code> attached to that ServerSocket.
` * @throws SocketException if creation fails
` * @since 1.4
` */
` SocketImpl getImpl() throws SocketException {
`if (!created)
` createImpl(true);
`return impl;
`
` }
` /**
` * Connects this socket to the server.
` *
` * @param
`endpoint the <code>SocketAddress</code>
` * @throws
`IOException if an error occurs during the connection
` * @throws java.nio.channels.IllegalBlockingModeException
` * if this socket has an associated channel,
` * and the channel is in non-blocking mode
` * @throws IllegalArgumentException if endpoint is null or is a
` * SocketAddress subclass not supported by this socket
` * @since 1.4
` * @spec JSR-51
` */
` public void connect(SocketAddress endpoint) throws IOException {
`connect(endpoint, 0);
` }
` /**
` * Connects this socket to the server with a specified timeout value.
` * A timeout of zero is interpreted as an infinite timeout. The connection
` * will then block until established or an error occurs.
` *
` * @param
`endpoint the <code>SocketAddress</code>
` * @param
`timeout the timeout value to be used in milliseconds.
` * @throws
`IOException if an error occurs during the connection
` * @throws
`SocketTimeoutException if timeout expires before connecting
` * @throws java.nio.channels.IllegalBlockingModeException
` * if this socket has an associated channel,
` * and the channel is in non-blocking mode
` * @throws IllegalArgumentException if endpoint is null or is a
` * SocketAddress subclass not supported by this socket
` * @since 1.4
` * @spec JSR-51
` */
` public void connect(SocketAddress endpoint, int timeout) throws IOException {
`if (endpoint == null)
` throw new IllegalArgumentException("connect: The address can't be null");
`if (timeout < 0)
` throw new IllegalArgumentException("connect: timeout can't be negative");
`if (isClosed())
` throw new SocketException("Socket is closed");
`if (!oldImpl && isConnected())
` throw new SocketException("already connected");
`if (!(endpoint instanceof InetSocketAddress))
` throw new IllegalArgumentException("Unsupported address type");
`
`Juniper Ex. 1025-p. 8
`Juniper v Finjan
`
`

`

`InetSocketAddress epoint = (InetSocketAddress) endpoint;
`SecurityManager security = System.getSecurityManager();
`if (security != null) {
` if (epoint.isUnresolved())
`security.checkConnect(epoint.getHostName(),
` epoint.getPort());
`security.checkConnect(epoint.getAddress().getHostAddress(),
` epoint.getPort());
`
` else
`
`}i
`
`f (!created)
` createImpl(true);
`if (!oldImpl)
` impl.connect(epoint, timeout);
`else if (timeout == 0) {
` if (epoint.isUnresolved())
`impl.connect(epoint.getAddress().getHostName(),
` epoint.getPort());
` else
`impl.connect(epoint.getAddress(), epoint.getPort());
`} else
` throw new UnsupportedOperationException("SocketImpl.connect(addr, timeout)");
`connected = true;
`/*
` * If the socket was not bound before the connect, it is now because
` * the kernel will have picked an ephemeral port & a local address
` */
`bound = true;
`
` }
` /**
` * Binds the socket to a local address.
` * <P>
` * If the address is <code>null</code>, then the system will pick up
` * an ephemeral port and a valid local address to bind the socket.
` *
` * @param
`bindpoint the <code>SocketAddress</code> to bind to
` * @throws
`IOException if the bind operation fails, or if the socket
` *
` is already bound.
` * @throws IllegalArgumentException if bindpoint is a
` * SocketAddress subclass not supported by this socket
` *
` * @since
`1.4
` * @see #isBound
` */
` public void bind(SocketAddress bindpoint) throws IOException {
`if (isClosed())
` throw new SocketException("Socket is closed");
`if (!oldImpl && isBound())
` throw new SocketException("Already bound");
`if (bindpoint != null && (!(bindpoint instanceof InetSocketAddress)))
` throw new IllegalArgumentException("Unsupported address type");
`InetSocketAddress epoint = (InetSocketAddress) bindpoint;
`if (epoint != null && epoint.isUnresolved())
` throw new SocketException("Unresolved address");
`if (bindpoint == null)
` getImpl().bind(InetAddress.anyLocalAddress(), 0);
`else
` getImpl().bind(epoint.getAddress(),
`
`Juniper Ex. 1025-p. 9
`Juniper v Finjan
`
`

`

`bound = true;
`
` epoint.getPort());
`
` }
` /**
` * set the flags after an accept() call.
` */
` final void postAccept() {
`connected = true;
`created = true;
`bound = true;
`
` }
` void setCreated() {
`created = true;
` }
` void setBound() {
`bound = true;
` }
` void setConnected() {
`connected = true;
` }
` /**
` * Returns the address to which the socket is connected.
` *
` * @return the remote IP address to which this socket is connected,
` *
`or <code>null</code> if the socket is not connected.
` */
` public InetAddress getInetAddress() {
`if (!isConnected())
` return null;
`try {
` return getImpl().getInetAddress();
`} catch (SocketException e) {
`eturn null;
`
`}r
`
` }
` /**
` * Gets the local address to which the socket is bound.
` *
` * @return the local address to which the socket is bound or
` *
` <code>InetAddress.anyLocalAddress()</code>
` *
` if the socket is not bound yet.
` * @since JDK1.1
` */
` public InetAddress getLocalAddress() {
`// This is for backward compatibility
`if (!isBound())
` return InetAddress.anyLocalAddress();
`InetAddress in = null;
`try {
` in = (InetAddress) getImpl().getOption(SocketOptions.SO_BINDADDR);
` if (in.isAnyLocalAddress()) {
`in = InetAddress.anyLocalAddress();
` }
`} catch (Exception e) {
` in = InetAddress.anyLocalAddress(); // "0.0.0.0"
`}
`
`Juniper Ex. 1025-p. 10
`Juniper v Finjan
`
`

`

`return in;
`
` }
` /**
` * Returns the remote port to which this socket is connected.
` *
` * @return the remote port number to which this socket is connected, or
` *
` 0 if the socket is not connected yet.
` */
` public int getPort() {
`if (!isConnected())
` return 0;
`try {
` return getImpl().getPort();
`} catch (SocketException e) {
` // Shouldn't happen as we're connected
`eturn -1;
`
`}r
`
` }
` /**
` * Returns the local port to which this socket is bound.
` *
` * @return the local port number to which this socket is bound or -1
` *
` if the socket is not bound yet.
` */
` public int getLocalPort() {
`if (!isBound())
` return -1;
`try {
` return getImpl().getLocalPort();
`} catch(SocketException e) {
` // shouldn't happen as we're bound
`eturn -1;
`
`}r
`
` }
` /**
` * Returns the address of the endpoint this socket is connected to, or
` * <code>null</code> if it is unconnected.
` * @return a <code>SocketAddress</code> reprensenting the remote endpoint of this
` *
` socket, or <code>null</code> if it is not connected yet.
` * @see #getInetAddress()
` * @see #getPort()
` * @see #connect(SocketAddress, int)
` * @see #connect(SocketAddress)
` * @since 1.4
` */
` public SocketAddress getRemoteSocketAddress() {
`if (!isConnected())
` return null;
`return new InetSocketAddress(getInetAddress(), getPort());
`
` }
` /**
` * Returns the address of the endpoint this socket is bound to, or
` * <code>null</code> if it is not bound yet.
` *
` * @return a <code>SocketAddress</code> representing the local endpoint of this
` *
` socket, or <code>null</code> if it is not bound yet.
` * @see #getLocalAddress()
` * @see #getLocalPort()
`
`Juniper Ex. 1025-p. 11
`Juniper v Finjan
`
`

`

` * @see #bind(SocketAddress)
` * @since 1.4
` */
` public SocketAddress getLocalSocketAddress() {
`if (!isBound())
` return null;
`return new InetSocketAddress(getLocalAddress(), getLocalPort());
`
` }
` /**
` * Returns the unique {@link java.nio.channels.SocketChannel SocketChannel}
` * object associated with this socket, if any.
` *
` * <p> A socket will have a channel if, and only if, the channel itself was
` * created via the {@link java.nio.channels.SocketChannel#open
` * SocketChannel.open} or {@link
` * java.nio.channels.ServerSocketChannel#accept ServerSocketChannel.accept}
` * methods.
` *
` * @return the socket channel associated with this socket,
` * or <tt>null</tt> if this socket was not created
` * for a channel
` *
` * @since 1.4
` * @spec JSR-51
` */
` public SocketChannel getChannel() {
`return null;
` }
` /**
` * Returns an input stream for this socket.
` *
` * <p> If this socket has an associated channel then the resulting input
` * stream delegates all of its operations to the channel. If the channel
` * is in non-blocking mode then the input stream's <tt>read</tt> operations
` * will throw an {@link java.nio.channels.IllegalBlockingModeException}.
` *
` * <p>Under abnormal conditions the underlying connection may be
` * broken by the remote host or the network software (for example
` * a connection reset in the case of TCP connections). When a
` * broken connection is detected by the network software the
` * following applies to the returned input stream :-
` *
` * <ul>
` *
` * <li><p>The network software may discard bytes that are buffered
` * by the socket. Bytes that aren't discarded by the network
` * software can be read using {@link java.io.InputStream#read read}.
` *
` * <li><p>If there are no bytes buffered on the socket, or all
` * buffered bytes have been consumed by
` * {@link java.io.InputStream#read read}, then all subsequent
` * calls to {@link java.io.InputStream#read read} will throw an
` * {@link java.io.IOException IOException}.
` *
` * <li><p>If there are no bytes buffered on the socket, and the
` * socket has not been closed using {@link #close close}, then
` * {@link java.io.InputStream#available available} will
` * return <code>0</code>.
` *
`
`Juniper Ex. 1025-p. 12
`Juniper v Finjan
`
`

`

`a
`
` * </ul>
` *
` * @return an input stream for reading bytes from this socket.
` * @exception IOException if an I/O error occurs when creating the
` * input stream, the socket is closed, the socket is
` * not connected, or the socket input has been shutdown
` * using {@link #shutdownInput()}
` *
` * @revised 1.4
` * @spec JSR-51
` */
` public InputStream getInputStream() throws IOException {
`if (isClosed())
` throw new SocketException("Socket is closed");
`if (!isConnected())
` throw new SocketException("Socket is not connected");
`if (isInputShutdown())
` throw new SocketException("Socket input is shutdown");
`final Socket s = this;
`InputStream is = null;
`try {
` is = (InputStream)
`AccessController.doPrivileged(new PrivilegedExceptionAction() {
` public Object run() throws IOException {
`return impl.getInputStream();
` }
`});
`} catch (java.security.PrivilegedActionException e) {
` throw (IOException) e.getException();
`eturn is;
`
` }
` /**
` * Returns an output stream for this socket.
` *
` * <p> If this socket has an associated channel then the resulting output
` * stream delegates all of its operations to the channel. If the channel
` * is in non-blocking mode then the output stream's <tt>write</tt>
` * operations will throw an {@link
` * java.nio.channels.IllegalBlockingModeException}.
` *
` * @return an output stream for writing bytes to this socket.
` * @exception IOException if an I/O error occurs when creating the
` * output stream or if the socket is not connected.
` * @revised 1.4
` * @spec JSR-51
` */
` public OutputStream getOutputStream() throws IOException {
`if (isClosed())
` throw new SocketException("Socket is closed");
`if (!isConnected())
` throw new SocketException("Socket is not connected");
`if (isOutputShutdown())
` throw new SocketException("Socket output is shutdown");
`final Socket s = this;
`OutputStream os = null;
`try {
` os = (OutputStream)
`AccessController.doPrivileged(new PrivilegedExceptionAction() {
` public Object run() throws IOException {
`return impl.getOutputStream();
`
`}r
`
`Juniper Ex. 1025-p. 13
`Juniper v Finjan
`
`

`

` }
`});
`} catch (java.security.PrivilegedActionException e) {
` throw (IOException) e.getException();
`eturn os;
`
`}r
`
` }
` /**
` * Enable/disable TCP_NODELAY (disable/enable Nagle's algorithm).
` *
` * @param on <code>true</code> to enable TCP_NODELAY,
` * <code>false</code> to disable.
` *
` * @exception SocketException if there is an error
` * in the underlying protocol, such as a TCP error.
` *
` * @since JDK1.1
` *
` * @see #getTcpNoDelay()
` */
` public void setTcpNoDelay(boolean on) throws SocketException {
`if (isClosed())
` throw new SocketException("Socket is closed");
`getImpl().setOption(SocketOptions.TCP_NODELAY, Boolean.valueOf(on));
`
` }
` /**
` * Tests if TCP_NODELAY is enabled.
` *
` * @return a <code>boolean</code> indicating whether or not TCP_NODELAY is enabled.
` * @exception SocketException if there is an error
` * in the underlying protocol, such as a TCP error.
` * @since JDK1.1
` * @see #setTcpNoDelay(boolean)
` */
` public boolean getTcpNoDelay() throws SocketException {
`if (isClosed())
` throw new SocketException("Socket is closed");
`return ((Boolean) getImpl().getOption(SocketOptions.TCP_NODELAY)).booleanValue();
`
` }
` /**
` * Enable/disable SO_LINGER with the specified linger time in seconds.
` * The maximum timeout value is platform specific.
` *
` * The setting only affects socket close.
` *
` * @param on whether or not to linger on.
` * @param linger how long to linger for, if on is true.
` * @exception SocketException if there is an error
` * in the underlying protocol, such as a TCP error.
` * @exception IllegalArgumentException if the linger value is negative.
` * @since JDK1.1
` * @see #getSoLinger()
` */
` public void setSoLinger(boolean on, int linger) throws SocketException {
`if (isClosed())
` throw new SocketException("Socket is closed");
`if (!on) {
` getImpl().setOption(SocketOptions.SO_LINGER, new Boolean(on));
`} else {
`
`Juniper Ex. 1025-p. 14
`Juniper v Finjan
`
`

`

` if (linger < 0) {
`throw new IllegalArgumentException("invalid value for SO_LINGER");
` }
` if (linger > 65535)
` linger = 65535;
` getImpl().setOption(SocketOptions.SO_LINGER, new Integer(linger));
`}
`
` }
` /**
` * Returns setting for SO_LINGER. -1 returns implies that the
` * option is disabled.
` *
` * The setting only affects socket close.
` *
` * @return the setting for SO_LINGER.
` * @exception SocketException if there is an error
` * in the underlying protocol, such as a TCP error.
` * @since JDK1.1
` * @see #setSoLinger(boolean, int)
` */
` public int getSoLinger() throws SocketException {
`if (isClosed())
` throw new SocketException("Socket is closed");
`Object o = getImpl().getOption(SocketOptions.SO_LINGER);
`if (o instanceof Integer) {
` return ((Integer) o).intValue();
`} else {
` return -1;
`}
`
` }
` /**
` * Send one byte of urgent data on the socket. The byte to be sent is the lowest eight
` * bits of the data parameter. The urgent byte is
` * sent after any preceding writes to the socket OutputStream
` * and before any future writes to the OutputStream.
` * @param data The byte of data to send
` * @exception IOException if there is an error
` * sending the data.
` * @since 1.4
` */
` public void sendUrgentData (int data) throws IOException {
` if (!getImpl().supportsUrgentData ()) {
` throw new SocketException ("Urgent data not supported");
` }
` getImpl().sendUrgentData (data);
` }
` /**
` * Enable/disable OOBINLINE (receipt of TCP urgent data)
` *
` * By default, this option is disabled and TCP urgent data received on a
` * socket is silently