| Frames | No Frames |
1: /* PlainSocketImpl.java -- Default socket implementation 2: Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007 3: Free Software Foundation, Inc. 4: 5: This file is part of GNU Classpath. 6: 7: GNU Classpath is free software; you can redistribute it and/or modify 8: it under the terms of the GNU General Public License as published by 9: the Free Software Foundation; either version 2, or (at your option) 10: any later version. 11: 12: GNU Classpath is distributed in the hope that it will be useful, but 13: WITHOUT ANY WARRANTY; without even the implied warranty of 14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15: General Public License for more details. 16: 17: You should have received a copy of the GNU General Public License 18: along with GNU Classpath; see the file COPYING. If not, write to the 19: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 20: 02110-1301 USA. 21: 22: Linking this library statically or dynamically with other modules is 23: making a combined work based on this library. Thus, the terms and 24: conditions of the GNU General Public License cover the whole 25: combination. 26: 27: As a special exception, the copyright holders of this library give you 28: permission to link this library with independent modules to produce an 29: executable, regardless of the license terms of these independent 30: modules, and to copy and distribute the resulting executable under 31: terms of your choice, provided that you also meet, for each linked 32: independent module, the terms and conditions of the license of that 33: module. An independent module is a module which is not derived from 34: or based on this library. If you modify this library, you may extend 35: this exception to your version of the library, but you are not 36: obligated to do so. If you do not wish to do so, delete this 37: exception statement from your version. */ 38: 39: 40: package gnu.java.net; 41: 42: import gnu.classpath.Configuration; 43: 44: import java.io.IOException; 45: import java.io.InputStream; 46: import java.io.OutputStream; 47: import java.net.InetAddress; 48: import java.net.InetSocketAddress; 49: import java.net.SocketAddress; 50: import java.net.SocketException; 51: import java.net.SocketImpl; 52: import java.net.SocketOptions; 53: 54: /** 55: * Written using on-line Java Platform 1.2 API Specification, as well 56: * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998). 57: * Status: Believed complete and correct. 58: */ 59: 60: /** 61: * Unless the application installs its own SocketImplFactory, this is the 62: * default socket implemetation that will be used. It simply uses a 63: * combination of Java and native routines to implement standard BSD 64: * style sockets of family AF_INET and types SOCK_STREAM and SOCK_DGRAM 65: * 66: * @author Per Bothner (bothner@cygnus.com) 67: * @author Nic Ferrier (nferrier@tapsellferrier.co.uk) 68: * @author Aaron M. Renn (arenn@urbanophile.com) 69: */ 70: public final class PlainSocketImpl extends SocketImpl 71: { 72: // Static initializer to load native library. 73: static 74: { 75: if (Configuration.INIT_LOAD_LIBRARY) 76: { 77: System.loadLibrary("javanet"); 78: } 79: } 80: 81: // These fields are mirrored for use in native code to avoid cpp conflicts 82: // when the #defines in system header files are the same as the public fields. 83: static final int _Jv_TCP_NODELAY_ = SocketOptions.TCP_NODELAY, 84: _Jv_SO_BINDADDR_ = SocketOptions.SO_BINDADDR, 85: _Jv_SO_REUSEADDR_ = SocketOptions.SO_REUSEADDR, 86: _Jv_SO_BROADCAST_ = SocketOptions.SO_BROADCAST, 87: _Jv_SO_OOBINLINE_ = SocketOptions.SO_OOBINLINE, 88: _Jv_IP_MULTICAST_IF_ = SocketOptions.IP_MULTICAST_IF, 89: _Jv_IP_MULTICAST_IF2_ = SocketOptions.IP_MULTICAST_IF2, 90: _Jv_IP_MULTICAST_LOOP_ = SocketOptions.IP_MULTICAST_LOOP, 91: _Jv_IP_TOS_ = SocketOptions.IP_TOS, 92: _Jv_SO_LINGER_ = SocketOptions.SO_LINGER, 93: _Jv_SO_TIMEOUT_ = SocketOptions.SO_TIMEOUT, 94: _Jv_SO_SNDBUF_ = SocketOptions.SO_SNDBUF, 95: _Jv_SO_RCVBUF_ = SocketOptions.SO_RCVBUF, 96: _Jv_SO_KEEPALIVE_ = SocketOptions.SO_KEEPALIVE; 97: 98: /** 99: * The OS file handle representing the socket. 100: * This is used for reads and writes to/from the socket and 101: * to close it. 102: * 103: * When the socket is closed this is reset to -1. 104: */ 105: int native_fd = -1; 106: 107: // This value is set/read by setOption/getOption. 108: int timeout = 0; 109: 110: // localAddress cache 111: InetAddress localAddress; 112: 113: // Local address as an InetSocketAddress. 114: InetSocketAddress localSocketAddress; 115: 116: /** 117: * A cached copy of the in stream for reading from the socket. 118: */ 119: private InputStream in; 120: 121: /** 122: * A cached copy of the out stream for writing to the socket. 123: */ 124: private OutputStream out; 125: 126: /** 127: * Indicates whether a channel initiated whatever operation 128: * is being invoked on this socket. 129: */ 130: private boolean inChannelOperation; 131: 132: /** 133: * Indicates whether we should ignore whether any associated 134: * channel is set to non-blocking mode. Certain operations 135: * throw an <code>IllegalBlockingModeException</code> if the 136: * associated channel is in non-blocking mode, <i>except</i> 137: * if the operation is invoked by the channel itself. 138: */ 139: public final boolean isInChannelOperation() 140: { 141: return inChannelOperation; 142: } 143: 144: /** 145: * Sets our indicator of whether an I/O operation is being 146: * initiated by a channel. 147: */ 148: public final void setInChannelOperation(boolean b) 149: { 150: inChannelOperation = b; 151: } 152: 153: /** 154: * Default do nothing constructor 155: */ 156: public PlainSocketImpl() 157: { 158: } 159: 160: protected void finalize() throws Throwable 161: { 162: synchronized (this) 163: { 164: if (native_fd != -1) 165: try 166: { 167: close(); 168: } 169: catch (IOException ex) 170: { 171: } 172: } 173: super.finalize(); 174: } 175: 176: public int getNativeFD() 177: { 178: return native_fd; 179: } 180: 181: /** 182: * Sets the specified option on a socket to the passed in object. For 183: * options that take an integer argument, the passed in object is an 184: * Integer. The option_id parameter is one of the defined constants in 185: * this interface. 186: * 187: * @param option_id The identifier of the option 188: * @param val The value to set the option to 189: * 190: * @exception SocketException If an error occurs 191: */ 192: public native void setOption(int optID, Object value) throws SocketException; 193: 194: /** 195: * Returns the current setting of the specified option. The Object returned 196: * will be an Integer for options that have integer values. The option_id 197: * is one of the defined constants in this interface. 198: * 199: * @param option_id The option identifier 200: * 201: * @return The current value of the option 202: * 203: * @exception SocketException If an error occurs 204: */ 205: public native Object getOption(int optID) throws SocketException; 206: 207: /** 208: * Flushes the input stream and closes it. If you read from the input stream 209: * after calling this method a <code>IOException</code> will be thrown. 210: * 211: * @throws IOException if an error occurs 212: */ 213: public native void shutdownInput() throws IOException; 214: 215: /** 216: * Flushes the output stream and closes it. If you write to the output stream 217: * after calling this method a <code>IOException</code> will be thrown. 218: * 219: * @throws IOException if an error occurs 220: */ 221: public native void shutdownOutput() throws IOException; 222: 223: /** 224: * Creates a new socket that is not bound to any local address/port and 225: * is not connected to any remote address/port. This will be created as 226: * a stream socket if the stream parameter is true, or a datagram socket 227: * if the stream parameter is false. 228: * 229: * @param stream true for a stream socket, false for a datagram socket 230: */ 231: // FIXME: this is public for nio ... but this is just a hack 232: // until we upgrade to Classpath's nio. 233: public native void create(boolean stream) throws IOException; 234: 235: /** 236: * Connects to the remote hostname and port specified as arguments. 237: * 238: * @param hostname The remote hostname to connect to 239: * @param port The remote port to connect to 240: * 241: * @exception IOException If an error occurs 242: */ 243: protected void connect(String host, int port) throws IOException 244: { 245: connect(InetAddress.getByName(host), port); 246: } 247: 248: /** 249: * Connects to the remote address and port specified as arguments. 250: * 251: * @param addr The remote address to connect to 252: * @param port The remote port to connect to 253: * 254: * @exception IOException If an error occurs 255: */ 256: protected void connect(InetAddress host, int port) throws IOException 257: { 258: connect (new InetSocketAddress (host, port), 0); 259: } 260: 261: /** 262: * Connects to the remote socket address with a specified timeout. 263: * 264: * @param timeout The timeout to use for this connect, 0 means infinite. 265: * 266: * @exception IOException If an error occurs 267: */ 268: protected native void connect(SocketAddress addr, int timeout) throws IOException; 269: 270: /** 271: * Binds to the specified port on the specified addr. Note that this addr 272: * must represent a local IP address. **** How bind to INADDR_ANY? **** 273: * 274: * @param addr The address to bind to 275: * @param port The port number to bind to 276: * 277: * @exception IOException If an error occurs 278: */ 279: protected native void bind(InetAddress host, int port) 280: throws IOException; 281: 282: /** 283: * Starts listening for connections on a socket. The queuelen parameter 284: * is how many pending connections will queue up waiting to be serviced 285: * before being accept'ed. If the queue of pending requests exceeds this 286: * number, additional connections will be refused. 287: * 288: * @param queuelen The length of the pending connection queue 289: * 290: * @exception IOException If an error occurs 291: */ 292: protected native void listen(int queuelen) 293: throws IOException; 294: 295: /** 296: * Accepts a new connection on this socket and returns in in the 297: * passed in SocketImpl. 298: * 299: * @param impl The SocketImpl object to accept this connection. 300: */ 301: protected void accept(SocketImpl impl) 302: throws IOException 303: { 304: accept((PlainSocketImpl) impl); 305: } 306: 307: private native void accept(PlainSocketImpl impl) 308: throws IOException; 309: 310: /** 311: * Returns the number of bytes that the caller can read from this socket 312: * without blocking. 313: * 314: * @return The number of readable bytes before blocking 315: * 316: * @exception IOException If an error occurs 317: */ 318: protected native int available() throws IOException; 319: 320: /** 321: * Closes the socket. This will cause any InputStream or OutputStream 322: * objects for this Socket to be closed as well. 323: * <p> 324: * Note that if the SO_LINGER option is set on this socket, then the 325: * operation could block. 326: * 327: * @exception IOException If an error occurs 328: */ 329: protected native void close() throws IOException; 330: 331: protected native void sendUrgentData(int data) throws IOException; 332: 333: public synchronized InetSocketAddress getLocalAddress() 334: { 335: if (localSocketAddress == null) 336: { 337: try 338: { 339: localSocketAddress 340: = new InetSocketAddress ((InetAddress) getOption(SocketOptions.SO_BINDADDR), 341: localport == -1 ? 0 : localport); 342: } 343: catch (SocketException _) 344: { 345: return null; 346: } 347: } 348: return localSocketAddress; 349: } 350: 351: /** 352: * Returns an InputStream object for reading from this socket. This will 353: * be an instance of SocketInputStream. 354: * 355: * @return An input stream attached to the socket. 356: * 357: * @exception IOException If an error occurs 358: */ 359: protected synchronized InputStream getInputStream() throws IOException 360: { 361: if (in == null) 362: in = new SocketInputStream(); 363: 364: return in; 365: } 366: 367: /** 368: * Returns an OutputStream object for writing to this socket. This will 369: * be an instance of SocketOutputStream. 370: * 371: * @return An output stream attached to the socket. 372: * 373: * @exception IOException If an error occurs 374: */ 375: protected synchronized OutputStream getOutputStream() throws IOException 376: { 377: if (out == null) 378: out = new SocketOutputStream(); 379: 380: return out; 381: } 382: 383: /** 384: * This class contains an implementation of <code>InputStream</code> for 385: * sockets. It in an internal only class used by <code>PlainSocketImpl</code>. 386: * 387: * @author Nic Ferrier <nferrier@tapsellferrier.co.uk> 388: */ 389: final class SocketInputStream 390: extends InputStream 391: { 392: /** 393: * Returns the number of bytes available to be read before blocking 394: */ 395: public int available() throws IOException 396: { 397: return PlainSocketImpl.this.available(); 398: } 399: 400: /** 401: * This method not only closes the stream, it closes the underlying socket 402: * (and thus any connection) and invalidates any other Input/Output streams 403: * for the underlying impl object 404: */ 405: public void close() throws IOException 406: { 407: PlainSocketImpl.this.close(); 408: } 409: 410: /** 411: * Reads the next byte of data and returns it as an int. 412: * 413: * @return The byte read (as an int) or -1 if end of stream); 414: * 415: * @exception IOException If an error occurs. 416: */ 417: public native int read() throws IOException; 418: 419: /** 420: * Reads up to len bytes of data into the caller supplied buffer starting 421: * at offset bytes from the start of the buffer 422: * 423: * @param buf The buffer 424: * @param offset Offset into the buffer to start reading from 425: * @param len The number of bytes to read 426: * 427: * @return The number of bytes actually read or -1 if end of stream 428: * 429: * @exception IOException If an error occurs. 430: */ 431: public native int read(byte[] buf, int offset, int len) throws IOException; 432: } 433: 434: /** 435: * This class is used internally by <code>PlainSocketImpl</code> to be the 436: * <code>OutputStream</code> subclass returned by its 437: * <code>getOutputStream method</code>. It expects only to be used in that 438: * context. 439: * 440: * @author Nic Ferrier <nferrier@tapsellferrier.co.uk> 441: */ 442: final class SocketOutputStream 443: extends OutputStream 444: { 445: /** 446: * This method closes the stream and the underlying socket connection. This 447: * action also effectively closes any other InputStream or OutputStream 448: * object associated with the connection. 449: * 450: * @exception IOException If an error occurs 451: */ 452: public void close() throws IOException 453: { 454: PlainSocketImpl.this.close(); 455: } 456: 457: /** 458: * Writes a byte (passed in as an int) to the given output stream 459: * 460: * @param b The byte to write 461: * 462: * @exception IOException If an error occurs 463: */ 464: public native void write(int b) throws IOException; 465: 466: /** 467: * Writes len number of bytes from the array buf to the stream starting 468: * at offset bytes into the buffer. 469: * 470: * @param buf The buffer 471: * @param offset Offset into the buffer to start writing from 472: * @param len The number of bytes to write 473: * 474: * @exception IOException If an error occurs. 475: */ 476: public native void write(byte[] buf, int offset, int len) throws IOException; 477: } 478: }