1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340
/* * @(#)SocketImpl.java 1.45 07/03/08 * * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package java.net; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.io.FileDescriptor; /** * The abstract class <code>SocketImpl</code> is a common superclass * of all classes that actually implement sockets. It is used to * create both client and server sockets. * <p> * A "plain" socket implements these methods exactly as * described, without attempting to go through a firewall or proxy. * * @author unascribed * @version 1.45, 03/08/07 * @since JDK1.0 */ public abstract class SocketImpl implements SocketOptions { /** * The actual Socket object. */ Socket socket = null; ServerSocket serverSocket = null; /** * The file descriptor object for this socket. */ protected FileDescriptor fd; /** * The IP address of the remote end of this socket. */ protected InetAddress address; /** * The port number on the remote host to which this socket is connected. */ protected int port; /** * The local port number to which this socket is connected. */ protected int localport; /** * Creates either a stream or a datagram socket. * * @param stream if <code>true</code>, create a stream socket; * otherwise, create a datagram socket. * @exception IOException if an I/O error occurs while creating the * socket. */ protected abstract void create(boolean stream) throws IOException; /** * Connects this socket to the specified port on the named host. * * @param host the name of the remote host. * @param port the port number. * @exception IOException if an I/O error occurs when connecting to the * remote host. */ protected abstract void connect(String host, int port) throws IOException; /** * Connects this socket to the specified port number on the specified host. * * @param address the IP address of the remote host. * @param port the port number. * @exception IOException if an I/O error occurs when attempting a * connection. */ protected abstract void connect(InetAddress address, int port) throws IOException; /** * Connects this socket to the specified port number on the specified host. * A timeout of zero is interpreted as an infinite timeout. The connection * will then block until established or an error occurs. * * @param address the Socket address of the remote host. * @param timeout the timeout value, in milliseconds, or zero for no timeout. * @exception IOException if an I/O error occurs when attempting a * connection. * @since 1.4 */ protected abstract void connect(SocketAddress address, int timeout) throws IOException; /** * Binds this socket to the specified local IP address and port number. * * @param host an IP address that belongs to a local interface. * @param port the port number. * @exception IOException if an I/O error occurs when binding this socket. */ protected abstract void bind(InetAddress host, int port) throws IOException; /** * Sets the maximum queue length for incoming connection indications * (a request to connect) to the <code>count</code> argument. If a * connection indication arrives when the queue is full, the * connection is refused. * * @param backlog the maximum length of the queue. * @exception IOException if an I/O error occurs when creating the queue. */ protected abstract void listen(int backlog) throws IOException; /** * Accepts a connection. * * @param s the accepted connection. * @exception IOException if an I/O error occurs when accepting the * connection. */ protected abstract void accept(SocketImpl s) throws IOException; /** * Returns an input stream for this socket. * * @return a stream for reading from this socket. * @exception IOException if an I/O error occurs when creating the * input stream. */ protected abstract InputStream getInputStream() throws IOException; /** * Returns an output stream for this socket. * * @return an output stream for writing to this socket. * @exception IOException if an I/O error occurs when creating the * output stream. */ protected abstract OutputStream getOutputStream() throws IOException; /** * Returns the number of bytes that can be read from this socket * without blocking. * * @return the number of bytes that can be read from this socket * without blocking. * @exception IOException if an I/O error occurs when determining the * number of bytes available. */ protected abstract int available() throws IOException; /** * Closes this socket. * * @exception IOException if an I/O error occurs when closing this socket. */ protected abstract void close() throws IOException; /** * Places the input stream for this socket at "end of stream". * Any data sent to this socket is acknowledged and then * silently discarded. * * If you read from a socket input stream after invoking * shutdownInput() on the socket, the stream will return EOF. * * @exception IOException if an I/O error occurs when shutting down this * socket. * @see java.net.Socket#shutdownOutput() * @see java.net.Socket#close() * @see java.net.Socket#setSoLinger(boolean, int) * @since 1.3 */ protected void shutdownInput() throws IOException { throw new IOException("Method not implemented!"); } /** * Disables the output stream for this socket. * For a TCP socket, any previously written data will be sent * followed by TCP's normal connection termination sequence. * * If you write to a socket output stream after invoking * shutdownOutput() on the socket, the stream will throw * an IOException. * * @exception IOException if an I/O error occurs when shutting down this * socket. * @see java.net.Socket#shutdownInput() * @see java.net.Socket#close() * @see java.net.Socket#setSoLinger(boolean, int) * @since 1.3 */ protected void shutdownOutput() throws IOException { throw new IOException("Method not implemented!"); } /** * Returns the value of this socket's <code>fd</code> field. * * @return the value of this socket's <code>fd</code> field. * @see java.net.SocketImpl#fd */ protected FileDescriptor getFileDescriptor() { return fd; } /** * Returns the value of this socket's <code>address</code> field. * * @return the value of this socket's <code>address</code> field. * @see java.net.SocketImpl#address */ protected InetAddress getInetAddress() { return address; } /** * Returns the value of this socket's <code>port</code> field. * * @return the value of this socket's <code>port</code> field. * @see java.net.SocketImpl#port */ protected int getPort() { return port; } /** * Returns whether or not this SocketImpl supports sending * urgent data. By default, false is returned * unless the method is overridden in a sub-class * * @return true if urgent data supported * @see java.net.SocketImpl#address * @since 1.4 */ protected boolean supportsUrgentData () { return false; // must be overridden in sub-class } /** * Send one byte of urgent data on the socket. * The byte to be sent is the low eight bits of the parameter * @param data The byte of data to send * @exception IOException if there is an error * sending the data. * @since 1.4 */ protected abstract void sendUrgentData (int data) throws IOException; /** * Returns the value of this socket's <code>localport</code> field. * * @return the value of this socket's <code>localport</code> field. * @see java.net.SocketImpl#localport */ protected int getLocalPort() { return localport; } void setSocket(Socket soc) { this.socket = soc; } Socket getSocket() { return socket; } void setServerSocket(ServerSocket soc) { this.serverSocket = soc; } ServerSocket getServerSocket() { return serverSocket; } /** * Returns the address and port of this socket as a <code>String</code>. * * @return a string representation of this socket. */ public String toString() { return "Socket[addr=" + getInetAddress() + ",port=" + getPort() + ",localport=" + getLocalPort() + "]"; } void reset() throws IOException { address = null; port = 0; localport = 0; } /** * Sets performance preferences for this socket. * * <p> Sockets use the TCP/IP protocol by default. Some implementations * may offer alternative protocols which have different performance * characteristics than TCP/IP. This method allows the application to * express its own preferences as to how these tradeoffs should be made * when the implementation chooses from the available protocols. * * <p> Performance preferences are described by three integers * whose values indicate the relative importance of short connection time, * low latency, and high bandwidth. The absolute values of the integers * are irrelevant; in order to choose a protocol the values are simply * compared, with larger values indicating stronger preferences. Negative * values represent a lower priority than positive values. If the * application prefers short connection time over both low latency and high * bandwidth, for example, then it could invoke this method with the values * <tt>(1, 0, 0)</tt>. If the application prefers high bandwidth above low * latency, and low latency above short connection time, then it could * invoke this method with the values <tt>(0, 1, 2)</tt>. * * By default, this method does nothing, unless it is overridden in a * a sub-class. * * @param connectionTime * An <tt>int</tt> expressing the relative importance of a short * connection time * * @param latency * An <tt>int</tt> expressing the relative importance of low * latency * * @param bandwidth * An <tt>int</tt> expressing the relative importance of high * bandwidth * * @since 1.5 */ protected void setPerformancePreferences(int connectionTime, int latency, int bandwidth) { /* Not implemented yet */ } }