diff options
author | jfrijters <jfrijters> | 2010-08-27 08:58:26 +0400 |
---|---|---|
committer | jfrijters <jfrijters> | 2010-08-27 08:58:26 +0400 |
commit | 13955a090352de779a2bc53f147f6d626718b032 (patch) | |
tree | a08f42fdc1f0a4417054ed49232e360ae9873ab4 /openjdk/java/net | |
parent | a526592847a6dcc89d7d9a87255e5b416cb9396c (diff) |
Prepare for forking.
Diffstat (limited to 'openjdk/java/net')
-rw-r--r-- | openjdk/java/net/TwoStacksPlainSocketImpl.java | 206 |
1 files changed, 206 insertions, 0 deletions
diff --git a/openjdk/java/net/TwoStacksPlainSocketImpl.java b/openjdk/java/net/TwoStacksPlainSocketImpl.java new file mode 100644 index 00000000..9475bd3f --- /dev/null +++ b/openjdk/java/net/TwoStacksPlainSocketImpl.java @@ -0,0 +1,206 @@ +/* + * Copyright 2007 Sun Microsystems, Inc. All Rights Reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Sun designates this + * particular file as subject to the "Classpath" exception as provided + * by Sun in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + */ +package java.net; + +import java.io.IOException; +import java.io.FileDescriptor; + +/* + * This class defines the plain SocketImpl that is used for all + * Windows version lower than Vista. It adds support for IPv6 on + * these platforms where available. + * + * For backward compatibility Windows platforms that do not have IPv6 + * support also use this implementation, and fd1 gets set to null + * during socket creation. + * + * @author Chris Hegarty + */ + +class TwoStacksPlainSocketImpl extends AbstractPlainSocketImpl +{ + /* second fd, used for ipv6 on windows only. + * fd1 is used for listeners and for client sockets at initialization + * until the socket is connected. Up to this point fd always refers + * to the ipv4 socket and fd1 to the ipv6 socket. After the socket + * becomes connected, fd always refers to the connected socket + * (either v4 or v6) and fd1 is closed. + * + * For ServerSockets, fd always refers to the v4 listener and + * fd1 the v6 listener. + */ + private FileDescriptor fd1; + + /* + * Needed for ipv6 on windows because we need to know + * if the socket is bound to ::0 or 0.0.0.0, when a caller + * asks for it. Otherwise we don't know which socket to ask. + */ + private InetAddress anyLocalBoundAddr = null; + + /* to prevent starvation when listening on two sockets, this is + * is used to hold the id of the last socket we accepted on. + */ + private int lastfd = -1; + + static { + initProto(); + } + + public TwoStacksPlainSocketImpl() {} + + public TwoStacksPlainSocketImpl(FileDescriptor fd) { + this.fd = fd; + } + + /** + * Creates a socket with a boolean that specifies whether this + * is a stream socket (true) or an unconnected UDP socket (false). + */ + protected synchronized void create(boolean stream) throws IOException { + fd1 = new FileDescriptor(); + super.create(stream); + } + + /** + * Binds the socket to the specified address of the specified local port. + * @param address the address + * @param port the port + */ + protected synchronized void bind(InetAddress address, int lport) + throws IOException + { + super.bind(address, lport); + if (address.isAnyLocalAddress()) { + anyLocalBoundAddr = address; + } + } + + public Object getOption(int opt) throws SocketException { + if (isClosedOrPending()) { + throw new SocketException("Socket Closed"); + } + if (opt == SO_BINDADDR) { + if (fd != null && fd1 != null ) { + /* must be unbound or else bound to anyLocal */ + return anyLocalBoundAddr; + } + InetAddressContainer in = new InetAddressContainer(); + socketGetOption(opt, in); + return in.addr; + } else + return super.getOption(opt); + } + + /** + * Closes the socket. + */ + protected void close() throws IOException { + synchronized(fdLock) { + if (fd != null || fd1 != null) { + if (fdUseCount == 0) { + if (closePending) { + return; + } + closePending = true; + socketClose(); + fd = null; + fd1 = null; + return; + } else { + /* + * If a thread has acquired the fd and a close + * isn't pending then use a deferred close. + * Also decrement fdUseCount to signal the last + * thread that releases the fd to close it. + */ + if (!closePending) { + closePending = true; + fdUseCount--; + socketClose(); + } + } + } + } + } + + void reset() throws IOException { + if (fd != null || fd1 != null) { + socketClose(); + } + fd = null; + fd1 = null; + super.reset(); + } + + /* + * Return true if already closed or close is pending + */ + public boolean isClosedOrPending() { + /* + * Lock on fdLock to ensure that we wait if a + * close is in progress. + */ + synchronized (fdLock) { + if (closePending || (fd == null && fd1 == null)) { + return true; + } else { + return false; + } + } + } + + /* Native methods */ + + static native void initProto(); + + native void socketCreate(boolean isServer) throws IOException; + + native void socketConnect(InetAddress address, int port, int timeout) + throws IOException; + + native void socketBind(InetAddress address, int port) + throws IOException; + + native void socketListen(int count) throws IOException; + + native void socketAccept(SocketImpl s) throws IOException; + + native int socketAvailable() throws IOException; + + native void socketClose0(boolean useDeferredClose) throws IOException; + + native void socketShutdown(int howto) throws IOException; + + native void socketSetOption(int cmd, boolean on, Object value) + throws SocketException; + + native int socketGetOption(int opt, Object iaContainerObj) throws SocketException; + + native int socketGetOption1(int opt, Object iaContainerObj, FileDescriptor fd) + throws SocketException; + + native void socketSendUrgentData(int data) throws IOException; +} |