plan9-archive/inferno-java

java/pkg/java/net/AbstractPlainDatagramSocketImpl.class+0−0

Binary file not shown.

java/pkg/java/net/AbstractPlainDatagramSocketImpl.java+352−0

@@ -0,0 +1,352 @@
	1	+/*
	2	+ * Copyright (c) 1996, 2011, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+package java.net;
	26	+
	27	+import java.io.FileDescriptor;
	28	+import java.io.IOException;
	29	+import java.io.InterruptedIOException;
	30	+import java.util.Enumeration;
	31	+import sun.net.ResourceManager;
	32	+
	33	+/**
	34	+ * Abstract datagram and multicast socket implementation base class.
	35	+ * Note: This is not a public class, so that applets cannot call
	36	+ * into the implementation directly and hence cannot bypass the
	37	+ * security checks present in the DatagramSocket and MulticastSocket
	38	+ * classes.
	39	+ *
	40	+ * @author Pavani Diwanji
	41	+ */
	42	+
	43	+abstract class AbstractPlainDatagramSocketImpl extends DatagramSocketImpl
	44	+{
	45	+ /* timeout value for receive() */
	46	+ int timeout = 0;
	47	+ boolean connected = false;
	48	+ private int trafficClass = 0;
	49	+ private InetAddress connectedAddress = null;
	50	+ private int connectedPort = -1;
	51	+
	52	+ /* cached socket options */
	53	+ private int multicastInterface = 0;
	54	+ private boolean loopbackMode = true;
	55	+ private int ttl = -1;
	56	+
	57	+ /**
	58	+ * Load net library into runtime.
	59	+ */
	60	+ static {
	61	+ java.security.AccessController.doPrivileged(
	62	+ new sun.security.action.LoadLibraryAction("net"));
	63	+ }
	64	+
	65	+ /**
	66	+ * Creates a datagram socket
	67	+ */
	68	+ protected synchronized void create() throws SocketException {
	69	+ fd = new FileDescriptor();
	70	+ ResourceManager.beforeUdpCreate();
	71	+ try {
	72	+ datagramSocketCreate();
	73	+ } catch (SocketException ioe) {
	74	+ ResourceManager.afterUdpClose();
	75	+ fd = null;
	76	+ throw ioe;
	77	+ }
	78	+ }
	79	+
	80	+ /**
	81	+ * Binds a datagram socket to a local port.
	82	+ */
	83	+ protected synchronized void bind(int lport, InetAddress laddr)
	84	+ throws SocketException {
	85	+ bind0(lport, laddr);
	86	+ }
	87	+
	88	+ protected abstract void bind0(int lport, InetAddress laddr)
	89	+ throws SocketException;
	90	+
	91	+ /**
	92	+ * Sends a datagram packet. The packet contains the data and the
	93	+ * destination address to send the packet to.
	94	+ * @param packet to be sent.
	95	+ */
	96	+ protected abstract void send(DatagramPacket p) throws IOException;
	97	+
	98	+ /**
	99	+ * Connects a datagram socket to a remote destination. This associates the remote
	100	+ * address with the local socket so that datagrams may only be sent to this destination
	101	+ * and received from this destination.
	102	+ * @param address the remote InetAddress to connect to
	103	+ * @param port the remote port number
	104	+ */
	105	+ protected void connect(InetAddress address, int port) throws SocketException {
	106	+ connect0(address, port);
	107	+ connectedAddress = address;
	108	+ connectedPort = port;
	109	+ connected = true;
	110	+ }
	111	+
	112	+ /**
	113	+ * Disconnects a previously connected socket. Does nothing if the socket was
	114	+ * not connected already.
	115	+ */
	116	+ protected void disconnect() {
	117	+ disconnect0(connectedAddress.family);
	118	+ connected = false;
	119	+ connectedAddress = null;
	120	+ connectedPort = -1;
	121	+ }
	122	+
	123	+ /**
	124	+ * Peek at the packet to see who it is from.
	125	+ * @param return the address which the packet came from.
	126	+ */
	127	+ protected abstract int peek(InetAddress i) throws IOException;
	128	+ protected abstract int peekData(DatagramPacket p) throws IOException;
	129	+ /**
	130	+ * Receive the datagram packet.
	131	+ * @param Packet Received.
	132	+ */
	133	+ protected synchronized void receive(DatagramPacket p)
	134	+ throws IOException {
	135	+ receive0(p);
	136	+ }
	137	+
	138	+ protected abstract void receive0(DatagramPacket p)
	139	+ throws IOException;
	140	+
	141	+ /**
	142	+ * Set the TTL (time-to-live) option.
	143	+ * @param TTL to be set.
	144	+ */
	145	+ protected abstract void setTimeToLive(int ttl) throws IOException;
	146	+
	147	+ /**
	148	+ * Get the TTL (time-to-live) option.
	149	+ */
	150	+ protected abstract int getTimeToLive() throws IOException;
	151	+
	152	+ /**
	153	+ * Set the TTL (time-to-live) option.
	154	+ * @param TTL to be set.
	155	+ */
	156	+ protected abstract void setTTL(byte ttl) throws IOException;
	157	+
	158	+ /**
	159	+ * Get the TTL (time-to-live) option.
	160	+ */
	161	+ protected abstract byte getTTL() throws IOException;
	162	+
	163	+ /**
	164	+ * Join the multicast group.
	165	+ * @param multicast address to join.
	166	+ */
	167	+ protected void join(InetAddress inetaddr) throws IOException {
	168	+ join(inetaddr, null);
	169	+ }
	170	+
	171	+ /**
	172	+ * Leave the multicast group.
	173	+ * @param multicast address to leave.
	174	+ */
	175	+ protected void leave(InetAddress inetaddr) throws IOException {
	176	+ leave(inetaddr, null);
	177	+ }
	178	+ /**
	179	+ * Join the multicast group.
	180	+ * @param multicast address to join.
	181	+ * @param netIf specifies the local interface to receive multicast
	182	+ * datagram packets
	183	+ * @throws IllegalArgumentException if mcastaddr is null or is a
	184	+ * SocketAddress subclass not supported by this socket
	185	+ * @since 1.4
	186	+ */
	187	+
	188	+ protected void joinGroup(SocketAddress mcastaddr, NetworkInterface netIf)
	189	+ throws IOException {
	190	+ if (mcastaddr == null \|\| !(mcastaddr instanceof InetSocketAddress))
	191	+ throw new IllegalArgumentException("Unsupported address type");
	192	+ join(((InetSocketAddress)mcastaddr).getAddress(), netIf);
	193	+ }
	194	+
	195	+ protected abstract void join(InetAddress inetaddr, NetworkInterface netIf)
	196	+ throws IOException;
	197	+
	198	+ /**
	199	+ * Leave the multicast group.
	200	+ * @param multicast address to leave.
	201	+ * @param netIf specified the local interface to leave the group at
	202	+ * @throws IllegalArgumentException if mcastaddr is null or is a
	203	+ * SocketAddress subclass not supported by this socket
	204	+ * @since 1.4
	205	+ */
	206	+ protected void leaveGroup(SocketAddress mcastaddr, NetworkInterface netIf)
	207	+ throws IOException {
	208	+ if (mcastaddr == null \|\| !(mcastaddr instanceof InetSocketAddress))
	209	+ throw new IllegalArgumentException("Unsupported address type");
	210	+ leave(((InetSocketAddress)mcastaddr).getAddress(), netIf);
	211	+ }
	212	+
	213	+ protected abstract void leave(InetAddress inetaddr, NetworkInterface netIf)
	214	+ throws IOException;
	215	+
	216	+ /**
	217	+ * Close the socket.
	218	+ */
	219	+ protected void close() {
	220	+ if (fd != null) {
	221	+ datagramSocketClose();
	222	+ ResourceManager.afterUdpClose();
	223	+ fd = null;
	224	+ }
	225	+ }
	226	+
	227	+ protected boolean isClosed() {
	228	+ return (fd == null) ? true : false;
	229	+ }
	230	+
	231	+ protected void finalize() {
	232	+ close();
	233	+ }
	234	+
	235	+ /**
	236	+ * set a value - since we only support (setting) binary options
	237	+ * here, o must be a Boolean
	238	+ */
	239	+
	240	+ public void setOption(int optID, Object o) throws SocketException {
	241	+ if (isClosed()) {
	242	+ throw new SocketException("Socket Closed");
	243	+ }
	244	+ switch (optID) {
	245	+ /* check type safety b4 going native. These should never
	246	+ * fail, since only java.Socket* has access to
	247	+ * PlainSocketImpl.setOption().
	248	+ */
	249	+ case SO_TIMEOUT:
	250	+ if (o == null \|\| !(o instanceof Integer)) {
	251	+ throw new SocketException("bad argument for SO_TIMEOUT");
	252	+ }
	253	+ int tmp = ((Integer) o).intValue();
	254	+ if (tmp < 0)
	255	+ throw new IllegalArgumentException("timeout < 0");
	256	+ timeout = tmp;
	257	+ return;
	258	+ case IP_TOS:
	259	+ if (o == null \|\| !(o instanceof Integer)) {
	260	+ throw new SocketException("bad argument for IP_TOS");
	261	+ }
	262	+ trafficClass = ((Integer)o).intValue();
	263	+ break;
	264	+ case SO_REUSEADDR:
	265	+ if (o == null \|\| !(o instanceof Boolean)) {
	266	+ throw new SocketException("bad argument for SO_REUSEADDR");
	267	+ }
	268	+ break;
	269	+ case SO_BROADCAST:
	270	+ if (o == null \|\| !(o instanceof Boolean)) {
	271	+ throw new SocketException("bad argument for SO_BROADCAST");
	272	+ }
	273	+ break;
	274	+ case SO_BINDADDR:
	275	+ throw new SocketException("Cannot re-bind Socket");
	276	+ case SO_RCVBUF:
	277	+ case SO_SNDBUF:
	278	+ if (o == null \|\| !(o instanceof Integer) \|\|
	279	+ ((Integer)o).intValue() < 0) {
	280	+ throw new SocketException("bad argument for SO_SNDBUF or " +
	281	+ "SO_RCVBUF");
	282	+ }
	283	+ break;
	284	+ case IP_MULTICAST_IF:
	285	+ if (o == null \|\| !(o instanceof InetAddress))
	286	+ throw new SocketException("bad argument for IP_MULTICAST_IF");
	287	+ break;
	288	+ case IP_MULTICAST_IF2:
	289	+ if (o == null \|\| !(o instanceof NetworkInterface))
	290	+ throw new SocketException("bad argument for IP_MULTICAST_IF2");
	291	+ break;
	292	+ case IP_MULTICAST_LOOP:
	293	+ if (o == null \|\| !(o instanceof Boolean))
	294	+ throw new SocketException("bad argument for IP_MULTICAST_LOOP");
	295	+ break;
	296	+ default:
	297	+ throw new SocketException("invalid option: " + optID);
	298	+ }
	299	+ socketSetOption(optID, o);
	300	+ }
	301	+
	302	+ /*
	303	+ * get option's state - set or not
	304	+ */
	305	+
	306	+ public Object getOption(int optID) throws SocketException {
	307	+ if (isClosed()) {
	308	+ throw new SocketException("Socket Closed");
	309	+ }
	310	+
	311	+ Object result;
	312	+
	313	+ switch (optID) {
	314	+ case SO_TIMEOUT:
	315	+ result = new Integer(timeout);
	316	+ break;
	317	+
	318	+ case IP_TOS:
	319	+ result = socketGetOption(optID);
	320	+ if ( ((Integer)result).intValue() == -1) {
	321	+ result = new Integer(trafficClass);
	322	+ }
	323	+ break;
	324	+
	325	+ case SO_BINDADDR:
	326	+ case IP_MULTICAST_IF:
	327	+ case IP_MULTICAST_IF2:
	328	+ case SO_RCVBUF:
	329	+ case SO_SNDBUF:
	330	+ case IP_MULTICAST_LOOP:
	331	+ case SO_REUSEADDR:
	332	+ case SO_BROADCAST:
	333	+ result = socketGetOption(optID);
	334	+ break;
	335	+
	336	+ default:
	337	+ throw new SocketException("invalid option: " + optID);
	338	+ }
	339	+
	340	+ return result;
	341	+ }
	342	+
	343	+ protected abstract void datagramSocketCreate() throws SocketException;
	344	+ protected abstract void datagramSocketClose();
	345	+ protected abstract void socketSetOption(int opt, Object val)
	346	+ throws SocketException;
	347	+ protected abstract Object socketGetOption(int opt) throws SocketException;
	348	+
	349	+ protected abstract void connect0(InetAddress address, int port) throws SocketException;
	350	+ protected abstract void disconnect0(int family);
	351	+
	352	+}

java/pkg/java/net/AbstractPlainSocketImpl.class+0−0

Binary file not shown.

java/pkg/java/net/AbstractPlainSocketImpl.java+716−0

@@ -0,0 +1,716 @@
	1	+/*
	2	+ * Copyright (c) 1995, 2011, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.io.IOException;
	29	+import java.io.InputStream;
	30	+import java.io.OutputStream;
	31	+import java.io.FileDescriptor;
	32	+
	33	+import sun.net.ConnectionResetException;
	34	+import sun.net.NetHooks;
	35	+import sun.net.ResourceManager;
	36	+
	37	+/**
	38	+ * Default Socket Implementation. This implementation does
	39	+ * not implement any security checks.
	40	+ * Note this class should <b>NOT</b> be public.
	41	+ *
	42	+ * @author Steven B. Byrne
	43	+ */
	44	+abstract class AbstractPlainSocketImpl extends SocketImpl
	45	+{
	46	+ /* instance variable for SO_TIMEOUT */
	47	+ int timeout; // timeout in millisec
	48	+ // traffic class
	49	+ private int trafficClass;
	50	+
	51	+ private boolean shut_rd = false;
	52	+ private boolean shut_wr = false;
	53	+
	54	+ private SocketInputStream socketInputStream = null;
	55	+
	56	+ /* number of threads using the FileDescriptor */
	57	+ protected int fdUseCount = 0;
	58	+
	59	+ /* lock when increment/decrementing fdUseCount */
	60	+ protected final Object fdLock = new Object();
	61	+
	62	+ /* indicates a close is pending on the file descriptor */
	63	+ protected boolean closePending = false;
	64	+
	65	+ /* indicates connection reset state */
	66	+ private int CONNECTION_NOT_RESET = 0;
	67	+ private int CONNECTION_RESET_PENDING = 1;
	68	+ private int CONNECTION_RESET = 2;
	69	+ private int resetState;
	70	+ private final Object resetLock = new Object();
	71	+
	72	+ /* whether this Socket is a stream (TCP) socket or not (UDP)
	73	+ */
	74	+ private boolean stream;
	75	+
	76	+ /**
	77	+ * Load net library into runtime.
	78	+ */
	79	+ static {
	80	+ java.security.AccessController.doPrivileged(
	81	+ new sun.security.action.LoadLibraryAction("net"));
	82	+ }
	83	+
	84	+ /**
	85	+ * Creates a socket with a boolean that specifies whether this
	86	+ * is a stream socket (true) or an unconnected UDP socket (false).
	87	+ */
	88	+ protected synchronized void create(boolean stream) throws IOException {
	89	+ fd = new FileDescriptor();
	90	+ this.stream = stream;
	91	+ if (!stream) {
	92	+ ResourceManager.beforeUdpCreate();
	93	+ try {
	94	+ socketCreate(false);
	95	+ } catch (IOException ioe) {
	96	+ ResourceManager.afterUdpClose();
	97	+ fd = null;
	98	+ throw ioe;
	99	+ }
	100	+ } else {
	101	+ socketCreate(true);
	102	+ }
	103	+ if (socket != null)
	104	+ socket.setCreated();
	105	+ if (serverSocket != null)
	106	+ serverSocket.setCreated();
	107	+ }
	108	+
	109	+ /**
	110	+ * Creates a socket and connects it to the specified port on
	111	+ * the specified host.
	112	+ * @param host the specified host
	113	+ * @param port the specified port
	114	+ */
	115	+ protected void connect(String host, int port)
	116	+ throws UnknownHostException, IOException
	117	+ {
	118	+ boolean connected = false;
	119	+ try {
	120	+ InetAddress address = InetAddress.getByName(host);
	121	+ this.port = port;
	122	+ this.address = address;
	123	+
	124	+ connectToAddress(address, port, timeout);
	125	+ connected = true;
	126	+ } finally {
	127	+ if (!connected) {
	128	+ try {
	129	+ close();
	130	+ } catch (IOException ioe) {
	131	+ /* Do nothing. If connect threw an exception then
	132	+ it will be passed up the call stack */
	133	+ }
	134	+ }
	135	+ }
	136	+ }
	137	+
	138	+ /**
	139	+ * Creates a socket and connects it to the specified address on
	140	+ * the specified port.
	141	+ * @param address the address
	142	+ * @param port the specified port
	143	+ */
	144	+ protected void connect(InetAddress address, int port) throws IOException {
	145	+ this.port = port;
	146	+ this.address = address;
	147	+
	148	+ try {
	149	+ connectToAddress(address, port, timeout);
	150	+ return;
	151	+ } catch (IOException e) {
	152	+ // everything failed
	153	+ close();
	154	+ throw e;
	155	+ }
	156	+ }
	157	+
	158	+ /**
	159	+ * Creates a socket and connects it to the specified address on
	160	+ * the specified port.
	161	+ * @param address the address
	162	+ * @param timeout the timeout value in milliseconds, or zero for no timeout.
	163	+ * @throws IOException if connection fails
	164	+ * @throws IllegalArgumentException if address is null or is a
	165	+ * SocketAddress subclass not supported by this socket
	166	+ * @since 1.4
	167	+ */
	168	+ protected void connect(SocketAddress address, int timeout)
	169	+ throws IOException {
	170	+ boolean connected = false;
	171	+ try {
	172	+ if (address == null \|\| !(address instanceof InetSocketAddress))
	173	+ throw new IllegalArgumentException("unsupported address type");
	174	+ InetSocketAddress addr = (InetSocketAddress) address;
	175	+ if (addr.isUnresolved())
	176	+ throw new UnknownHostException(addr.getHostName());
	177	+ this.port = addr.getPort();
	178	+ this.address = addr.getAddress();
	179	+
	180	+ connectToAddress(this.address, port, timeout);
	181	+ connected = true;
	182	+ } finally {
	183	+ if (!connected) {
	184	+ try {
	185	+ close();
	186	+ } catch (IOException ioe) {
	187	+ /* Do nothing. If connect threw an exception then
	188	+ it will be passed up the call stack */
	189	+ }
	190	+ }
	191	+ }
	192	+ }
	193	+
	194	+ private void connectToAddress(InetAddress address, int port, int timeout) throws IOException {
	195	+ if (address.isAnyLocalAddress()) {
	196	+ doConnect(InetAddress.getLocalHost(), port, timeout);
	197	+ } else {
	198	+ doConnect(address, port, timeout);
	199	+ }
	200	+ }
	201	+
	202	+ public void setOption(int opt, Object val) throws SocketException {
	203	+ if (isClosedOrPending()) {
	204	+ throw new SocketException("Socket Closed");
	205	+ }
	206	+ boolean on = true;
	207	+ switch (opt) {
	208	+ /* check type safety b4 going native. These should never
	209	+ * fail, since only java.Socket* has access to
	210	+ * PlainSocketImpl.setOption().
	211	+ */
	212	+ case SO_LINGER:
	213	+ if (val == null \|\| (!(val instanceof Integer) && !(val instanceof Boolean)))
	214	+ throw new SocketException("Bad parameter for option");
	215	+ if (val instanceof Boolean) {
	216	+ /* true only if disabling - enabling should be Integer */
	217	+ on = false;
	218	+ }
	219	+ break;
	220	+ case SO_TIMEOUT:
	221	+ if (val == null \|\| (!(val instanceof Integer)))
	222	+ throw new SocketException("Bad parameter for SO_TIMEOUT");
	223	+ int tmp = ((Integer) val).intValue();
	224	+ if (tmp < 0)
	225	+ throw new IllegalArgumentException("timeout < 0");
	226	+ timeout = tmp;
	227	+ break;
	228	+ case IP_TOS:
	229	+ if (val == null \|\| !(val instanceof Integer)) {
	230	+ throw new SocketException("bad argument for IP_TOS");
	231	+ }
	232	+ trafficClass = ((Integer)val).intValue();
	233	+ break;
	234	+ case SO_BINDADDR:
	235	+ throw new SocketException("Cannot re-bind socket");
	236	+ case TCP_NODELAY:
	237	+ if (val == null \|\| !(val instanceof Boolean))
	238	+ throw new SocketException("bad parameter for TCP_NODELAY");
	239	+ on = ((Boolean)val).booleanValue();
	240	+ break;
	241	+ case SO_SNDBUF:
	242	+ case SO_RCVBUF:
	243	+ if (val == null \|\| !(val instanceof Integer) \|\|
	244	+ !(((Integer)val).intValue() > 0)) {
	245	+ throw new SocketException("bad parameter for SO_SNDBUF " +
	246	+ "or SO_RCVBUF");
	247	+ }
	248	+ break;
	249	+ case SO_KEEPALIVE:
	250	+ if (val == null \|\| !(val instanceof Boolean))
	251	+ throw new SocketException("bad parameter for SO_KEEPALIVE");
	252	+ on = ((Boolean)val).booleanValue();
	253	+ break;
	254	+ case SO_OOBINLINE:
	255	+ if (val == null \|\| !(val instanceof Boolean))
	256	+ throw new SocketException("bad parameter for SO_OOBINLINE");
	257	+ on = ((Boolean)val).booleanValue();
	258	+ break;
	259	+ case SO_REUSEADDR:
	260	+ if (val == null \|\| !(val instanceof Boolean))
	261	+ throw new SocketException("bad parameter for SO_REUSEADDR");
	262	+ on = ((Boolean)val).booleanValue();
	263	+ break;
	264	+ default:
	265	+ throw new SocketException("unrecognized TCP option: " + opt);
	266	+ }
	267	+ socketSetOption(opt, on, val);
	268	+ }
	269	+ public Object getOption(int opt) throws SocketException {
	270	+ if (isClosedOrPending()) {
	271	+ throw new SocketException("Socket Closed");
	272	+ }
	273	+ if (opt == SO_TIMEOUT) {
	274	+ return new Integer(timeout);
	275	+ }
	276	+ int ret = 0;
	277	+ /*
	278	+ * The native socketGetOption() knows about 3 options.
	279	+ * The 32 bit value it returns will be interpreted according
	280	+ * to what we're asking. A return of -1 means it understands
	281	+ * the option but its turned off. It will raise a SocketException
	282	+ * if "opt" isn't one it understands.
	283	+ */
	284	+
	285	+ switch (opt) {
	286	+ case TCP_NODELAY:
	287	+ ret = socketGetOption(opt, null);
	288	+ return Boolean.valueOf(ret != -1);
	289	+ case SO_OOBINLINE:
	290	+ ret = socketGetOption(opt, null);
	291	+ return Boolean.valueOf(ret != -1);
	292	+ case SO_LINGER:
	293	+ ret = socketGetOption(opt, null);
	294	+ return (ret == -1) ? Boolean.FALSE: (Object)(new Integer(ret));
	295	+ case SO_REUSEADDR:
	296	+ ret = socketGetOption(opt, null);
	297	+ return Boolean.valueOf(ret != -1);
	298	+ case SO_BINDADDR:
	299	+ InetAddressContainer in = new InetAddressContainer();
	300	+ ret = socketGetOption(opt, in);
	301	+ return in.addr;
	302	+ case SO_SNDBUF:
	303	+ case SO_RCVBUF:
	304	+ ret = socketGetOption(opt, null);
	305	+ return new Integer(ret);
	306	+ case IP_TOS:
	307	+ ret = socketGetOption(opt, null);
	308	+ if (ret == -1) { // ipv6 tos
	309	+ return new Integer(trafficClass);
	310	+ } else {
	311	+ return new Integer(ret);
	312	+ }
	313	+ case SO_KEEPALIVE:
	314	+ ret = socketGetOption(opt, null);
	315	+ return Boolean.valueOf(ret != -1);
	316	+ // should never get here
	317	+ default:
	318	+ return null;
	319	+ }
	320	+ }
	321	+
	322	+ /**
	323	+ * The workhorse of the connection operation. Tries several times to
	324	+ * establish a connection to the given <host, port>. If unsuccessful,
	325	+ * throws an IOException indicating what went wrong.
	326	+ */
	327	+
	328	+ synchronized void doConnect(InetAddress address, int port, int timeout) throws IOException {
	329	+ synchronized (fdLock) {
	330	+ if (!closePending && (socket == null \|\| !socket.isBound())) {
	331	+ NetHooks.beforeTcpConnect(fd, address, port);
	332	+ }
	333	+ }
	334	+ try {
	335	+ acquireFD();
	336	+ try {
	337	+ socketConnect(address, port, timeout);
	338	+ /* socket may have been closed during poll/select */
	339	+ synchronized (fdLock) {
	340	+ if (closePending) {
	341	+ throw new SocketException ("Socket closed");
	342	+ }
	343	+ }
	344	+ // If we have a ref. to the Socket, then sets the flags
	345	+ // created, bound & connected to true.
	346	+ // This is normally done in Socket.connect() but some
	347	+ // subclasses of Socket may call impl.connect() directly!
	348	+ if (socket != null) {
	349	+ socket.setBound();
	350	+ socket.setConnected();
	351	+ }
	352	+ } finally {
	353	+ releaseFD();
	354	+ }
	355	+ } catch (IOException e) {
	356	+ close();
	357	+ throw e;
	358	+ }
	359	+ }
	360	+
	361	+ /**
	362	+ * Binds the socket to the specified address of the specified local port.
	363	+ * @param address the address
	364	+ * @param port the port
	365	+ */
	366	+ protected synchronized void bind(InetAddress address, int lport)
	367	+ throws IOException
	368	+ {
	369	+ synchronized (fdLock) {
	370	+ if (!closePending && (socket == null \|\| !socket.isBound())) {
	371	+ NetHooks.beforeTcpBind(fd, address, lport);
	372	+ }
	373	+ }
	374	+ socketBind(address, lport);
	375	+ if (socket != null)
	376	+ socket.setBound();
	377	+ if (serverSocket != null)
	378	+ serverSocket.setBound();
	379	+ }
	380	+
	381	+ /**
	382	+ * Listens, for a specified amount of time, for connections.
	383	+ * @param count the amount of time to listen for connections
	384	+ */
	385	+ protected synchronized void listen(int count) throws IOException {
	386	+ socketListen(count);
	387	+ }
	388	+
	389	+ /**
	390	+ * Accepts connections.
	391	+ * @param s the connection
	392	+ */
	393	+ protected void accept(SocketImpl s) throws IOException {
	394	+ acquireFD();
	395	+ try {
	396	+ socketAccept(s);
	397	+ } finally {
	398	+ releaseFD();
	399	+ }
	400	+ }
	401	+
	402	+ /**
	403	+ * Gets an InputStream for this socket.
	404	+ */
	405	+ protected synchronized InputStream getInputStream() throws IOException {
	406	+ if (isClosedOrPending()) {
	407	+ throw new IOException("Socket Closed");
	408	+ }
	409	+ if (shut_rd) {
	410	+ throw new IOException("Socket input is shutdown");
	411	+ }
	412	+ if (socketInputStream == null) {
	413	+ socketInputStream = new SocketInputStream(this);
	414	+ }
	415	+ return socketInputStream;
	416	+ }
	417	+
	418	+ void setInputStream(SocketInputStream in) {
	419	+ socketInputStream = in;
	420	+ }
	421	+
	422	+ /**
	423	+ * Gets an OutputStream for this socket.
	424	+ */
	425	+ protected synchronized OutputStream getOutputStream() throws IOException {
	426	+ if (isClosedOrPending()) {
	427	+ throw new IOException("Socket Closed");
	428	+ }
	429	+ if (shut_wr) {
	430	+ throw new IOException("Socket output is shutdown");
	431	+ }
	432	+ return new SocketOutputStream(this);
	433	+ }
	434	+
	435	+ void setFileDescriptor(FileDescriptor fd) {
	436	+ this.fd = fd;
	437	+ }
	438	+
	439	+ void setAddress(InetAddress address) {
	440	+ this.address = address;
	441	+ }
	442	+
	443	+ void setPort(int port) {
	444	+ this.port = port;
	445	+ }
	446	+
	447	+ void setLocalPort(int localport) {
	448	+ this.localport = localport;
	449	+ }
	450	+
	451	+ /**
	452	+ * Returns the number of bytes that can be read without blocking.
	453	+ */
	454	+ protected synchronized int available() throws IOException {
	455	+ if (isClosedOrPending()) {
	456	+ throw new IOException("Stream closed.");
	457	+ }
	458	+
	459	+ /*
	460	+ * If connection has been reset then return 0 to indicate
	461	+ * there are no buffered bytes.
	462	+ */
	463	+ if (isConnectionReset()) {
	464	+ return 0;
	465	+ }
	466	+
	467	+ /*
	468	+ * If no bytes available and we were previously notified
	469	+ * of a connection reset then we move to the reset state.
	470	+ *
	471	+ * If are notified of a connection reset then check
	472	+ * again if there are bytes buffered on the socket.
	473	+ */
	474	+ int n = 0;
	475	+ try {
	476	+ n = socketAvailable();
	477	+ if (n == 0 && isConnectionResetPending()) {
	478	+ setConnectionReset();
	479	+ }
	480	+ } catch (ConnectionResetException exc1) {
	481	+ setConnectionResetPending();
	482	+ try {
	483	+ n = socketAvailable();
	484	+ if (n == 0) {
	485	+ setConnectionReset();
	486	+ }
	487	+ } catch (ConnectionResetException exc2) {
	488	+ }
	489	+ }
	490	+ return n;
	491	+ }
	492	+
	493	+ /**
	494	+ * Closes the socket.
	495	+ */
	496	+ protected void close() throws IOException {
	497	+ synchronized(fdLock) {
	498	+ if (fd != null) {
	499	+ if (!stream) {
	500	+ ResourceManager.afterUdpClose();
	501	+ }
	502	+ if (fdUseCount == 0) {
	503	+ if (closePending) {
	504	+ return;
	505	+ }
	506	+ closePending = true;
	507	+ /*
	508	+ * We close the FileDescriptor in two-steps - first the
	509	+ * "pre-close" which closes the socket but doesn't
	510	+ * release the underlying file descriptor. This operation
	511	+ * may be lengthy due to untransmitted data and a long
	512	+ * linger interval. Once the pre-close is done we do the
	513	+ * actual socket to release the fd.
	514	+ */
	515	+ try {
	516	+ socketPreClose();
	517	+ } finally {
	518	+ socketClose();
	519	+ }
	520	+ fd = null;
	521	+ return;
	522	+ } else {
	523	+ /*
	524	+ * If a thread has acquired the fd and a close
	525	+ * isn't pending then use a deferred close.
	526	+ * Also decrement fdUseCount to signal the last
	527	+ * thread that releases the fd to close it.
	528	+ */
	529	+ if (!closePending) {
	530	+ closePending = true;
	531	+ fdUseCount--;
	532	+ socketPreClose();
	533	+ }
	534	+ }
	535	+ }
	536	+ }
	537	+ }
	538	+
	539	+ void reset() throws IOException {
	540	+ if (fd != null) {
	541	+ socketClose();
	542	+ }
	543	+ fd = null;
	544	+ super.reset();
	545	+ }
	546	+
	547	+
	548	+ /**
	549	+ * Shutdown read-half of the socket connection;
	550	+ */
	551	+ protected void shutdownInput() throws IOException {
	552	+ if (fd != null) {
	553	+ socketShutdown(SHUT_RD);
	554	+ if (socketInputStream != null) {
	555	+ socketInputStream.setEOF(true);
	556	+ }
	557	+ shut_rd = true;
	558	+ }
	559	+ }
	560	+
	561	+ /**
	562	+ * Shutdown write-half of the socket connection;
	563	+ */
	564	+ protected void shutdownOutput() throws IOException {
	565	+ if (fd != null) {
	566	+ socketShutdown(SHUT_WR);
	567	+ shut_wr = true;
	568	+ }
	569	+ }
	570	+
	571	+ protected boolean supportsUrgentData () {
	572	+ return true;
	573	+ }
	574	+
	575	+ protected void sendUrgentData (int data) throws IOException {
	576	+ if (fd == null) {
	577	+ throw new IOException("Socket Closed");
	578	+ }
	579	+ socketSendUrgentData (data);
	580	+ }
	581	+
	582	+ /**
	583	+ * Cleans up if the user forgets to close it.
	584	+ */
	585	+ protected void finalize() throws IOException {
	586	+ close();
	587	+ }
	588	+
	589	+ /*
	590	+ * "Acquires" and returns the FileDescriptor for this impl
	591	+ *
	592	+ * A corresponding releaseFD is required to "release" the
	593	+ * FileDescriptor.
	594	+ */
	595	+ FileDescriptor acquireFD() {
	596	+ synchronized (fdLock) {
	597	+ fdUseCount++;
	598	+ return fd;
	599	+ }
	600	+ }
	601	+
	602	+ /*
	603	+ * "Release" the FileDescriptor for this impl.
	604	+ *
	605	+ * If the use count goes to -1 then the socket is closed.
	606	+ */
	607	+ void releaseFD() {
	608	+ synchronized (fdLock) {
	609	+ fdUseCount--;
	610	+ if (fdUseCount == -1) {
	611	+ if (fd != null) {
	612	+ try {
	613	+ socketClose();
	614	+ } catch (IOException e) {
	615	+ } finally {
	616	+ fd = null;
	617	+ }
	618	+ }
	619	+ }
	620	+ }
	621	+ }
	622	+
	623	+ public boolean isConnectionReset() {
	624	+ synchronized (resetLock) {
	625	+ return (resetState == CONNECTION_RESET);
	626	+ }
	627	+ }
	628	+
	629	+ public boolean isConnectionResetPending() {
	630	+ synchronized (resetLock) {
	631	+ return (resetState == CONNECTION_RESET_PENDING);
	632	+ }
	633	+ }
	634	+
	635	+ public void setConnectionReset() {
	636	+ synchronized (resetLock) {
	637	+ resetState = CONNECTION_RESET;
	638	+ }
	639	+ }
	640	+
	641	+ public void setConnectionResetPending() {
	642	+ synchronized (resetLock) {
	643	+ if (resetState == CONNECTION_NOT_RESET) {
	644	+ resetState = CONNECTION_RESET_PENDING;
	645	+ }
	646	+ }
	647	+
	648	+ }
	649	+
	650	+ /*
	651	+ * Return true if already closed or close is pending
	652	+ */
	653	+ public boolean isClosedOrPending() {
	654	+ /*
	655	+ * Lock on fdLock to ensure that we wait if a
	656	+ * close is in progress.
	657	+ */
	658	+ synchronized (fdLock) {
	659	+ if (closePending \|\| (fd == null)) {
	660	+ return true;
	661	+ } else {
	662	+ return false;
	663	+ }
	664	+ }
	665	+ }
	666	+
	667	+ /*
	668	+ * Return the current value of SO_TIMEOUT
	669	+ */
	670	+ public int getTimeout() {
	671	+ return timeout;
	672	+ }
	673	+
	674	+ /*
	675	+ * "Pre-close" a socket by dup'ing the file descriptor - this enables
	676	+ * the socket to be closed without releasing the file descriptor.
	677	+ */
	678	+ private void socketPreClose() throws IOException {
	679	+ socketClose0(true);
	680	+ }
	681	+
	682	+ /*
	683	+ * Close the socket (and release the file descriptor).
	684	+ */
	685	+ protected void socketClose() throws IOException {
	686	+ socketClose0(false);
	687	+ }
	688	+
	689	+ abstract void socketCreate(boolean isServer) throws IOException;
	690	+ abstract void socketConnect(InetAddress address, int port, int timeout)
	691	+ throws IOException;
	692	+ abstract void socketBind(InetAddress address, int port)
	693	+ throws IOException;
	694	+ abstract void socketListen(int count)
	695	+ throws IOException;
	696	+ abstract void socketAccept(SocketImpl s)
	697	+ throws IOException;
	698	+ abstract int socketAvailable()
	699	+ throws IOException;
	700	+ abstract void socketClose0(boolean useDeferredClose)
	701	+ throws IOException;
	702	+ abstract void socketShutdown(int howto)
	703	+ throws IOException;
	704	+ abstract void socketSetOption(int cmd, boolean on, Object value)
	705	+ throws SocketException;
	706	+ abstract int socketGetOption(int opt, Object iaContainerObj) throws SocketException;
	707	+ abstract void socketSendUrgentData(int data)
	708	+ throws IOException;
	709	+
	710	+ public final static int SHUT_RD = 0;
	711	+ public final static int SHUT_WR = 1;
	712	+}
	713	+
	714	+class InetAddressContainer {
	715	+ InetAddress addr;
	716	+}

java/pkg/java/net/Authenticator$RequestorType.class+0−0

Binary file not shown.

java/pkg/java/net/Authenticator.class+0−0

Binary file not shown.

java/pkg/java/net/Authenticator.java+425−0

@@ -0,0 +1,425 @@
	1	+/*
	2	+ * Copyright (c) 1997, 2004, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+/**
	29	+ * The class Authenticator represents an object that knows how to obtain
	30	+ * authentication for a network connection. Usually, it will do this
	31	+ * by prompting the user for information.
	32	+ * <p>
	33	+ * Applications use this class by overriding {@link
	34	+ * #getPasswordAuthentication()} in a sub-class. This method will
	35	+ * typically use the various getXXX() accessor methods to get information
	36	+ * about the entity requesting authentication. It must then acquire a
	37	+ * username and password either by interacting with the user or through
	38	+ * some other non-interactive means. The credentials are then returned
	39	+ * as a {@link PasswordAuthentication} return value.
	40	+ * <p>
	41	+ * An instance of this concrete sub-class is then registered
	42	+ * with the system by calling {@link #setDefault(Authenticator)}.
	43	+ * When authentication is required, the system will invoke one of the
	44	+ * requestPasswordAuthentication() methods which in turn will call the
	45	+ * getPasswordAuthentication() method of the registered object.
	46	+ * <p>
	47	+ * All methods that request authentication have a default implementation
	48	+ * that fails.
	49	+ *
	50	+ * @see java.net.Authenticator#setDefault(java.net.Authenticator)
	51	+ * @see java.net.Authenticator#getPasswordAuthentication()
	52	+ *
	53	+ * @author Bill Foote
	54	+ * @since 1.2
	55	+ */
	56	+
	57	+// There are no abstract methods, but to be useful the user must
	58	+// subclass.
	59	+public abstract
	60	+class Authenticator {
	61	+
	62	+ // The system-wide authenticator object. See setDefault().
	63	+ private static Authenticator theAuthenticator;
	64	+
	65	+ private String requestingHost;
	66	+ private InetAddress requestingSite;
	67	+ private int requestingPort;
	68	+ private String requestingProtocol;
	69	+ private String requestingPrompt;
	70	+ private String requestingScheme;
	71	+ private URL requestingURL;
	72	+ private RequestorType requestingAuthType;
	73	+
	74	+ /**
	75	+ * The type of the entity requesting authentication.
	76	+ *
	77	+ * @since 1.5
	78	+ */
	79	+ public enum RequestorType {
	80	+ /**
	81	+ * Entity requesting authentication is a HTTP proxy server.
	82	+ */
	83	+ PROXY,
	84	+ /**
	85	+ * Entity requesting authentication is a HTTP origin server.
	86	+ */
	87	+ SERVER
	88	+ }
	89	+
	90	+ private void reset() {
	91	+ requestingHost = null;
	92	+ requestingSite = null;
	93	+ requestingPort = -1;
	94	+ requestingProtocol = null;
	95	+ requestingPrompt = null;
	96	+ requestingScheme = null;
	97	+ requestingURL = null;
	98	+ requestingAuthType = RequestorType.SERVER;
	99	+ }
	100	+
	101	+
	102	+ /**
	103	+ * Sets the authenticator that will be used by the networking code
	104	+ * when a proxy or an HTTP server asks for authentication.
	105	+ * <p>
	106	+ * First, if there is a security manager, its <code>checkPermission</code>
	107	+ * method is called with a
	108	+ * <code>NetPermission("setDefaultAuthenticator")</code> permission.
	109	+ * This may result in a java.lang.SecurityException.
	110	+ *
	111	+ * @param a The authenticator to be set. If a is <code>null</code> then
	112	+ * any previously set authenticator is removed.
	113	+ *
	114	+ * @throws SecurityException
	115	+ * if a security manager exists and its
	116	+ * <code>checkPermission</code> method doesn't allow
	117	+ * setting the default authenticator.
	118	+ *
	119	+ * @see SecurityManager#checkPermission
	120	+ * @see java.net.NetPermission
	121	+ */
	122	+ public synchronized static void setDefault(Authenticator a) {
	123	+ SecurityManager sm = System.getSecurityManager();
	124	+ if (sm != null) {
	125	+ NetPermission setDefaultPermission
	126	+ = new NetPermission("setDefaultAuthenticator");
	127	+ sm.checkPermission(setDefaultPermission);
	128	+ }
	129	+
	130	+ theAuthenticator = a;
	131	+ }
	132	+
	133	+ /**
	134	+ * Ask the authenticator that has been registered with the system
	135	+ * for a password.
	136	+ * <p>
	137	+ * First, if there is a security manager, its <code>checkPermission</code>
	138	+ * method is called with a
	139	+ * <code>NetPermission("requestPasswordAuthentication")</code> permission.
	140	+ * This may result in a java.lang.SecurityException.
	141	+ *
	142	+ * @param addr The InetAddress of the site requesting authorization,
	143	+ * or null if not known.
	144	+ * @param port the port for the requested connection
	145	+ * @param protocol The protocol that's requesting the connection
	146	+ * ({@link java.net.Authenticator#getRequestingProtocol()})
	147	+ * @param prompt A prompt string for the user
	148	+ * @param scheme The authentication scheme
	149	+ *
	150	+ * @return The username/password, or null if one can't be gotten.
	151	+ *
	152	+ * @throws SecurityException
	153	+ * if a security manager exists and its
	154	+ * <code>checkPermission</code> method doesn't allow
	155	+ * the password authentication request.
	156	+ *
	157	+ * @see SecurityManager#checkPermission
	158	+ * @see java.net.NetPermission
	159	+ */
	160	+ public static PasswordAuthentication requestPasswordAuthentication(
	161	+ InetAddress addr,
	162	+ int port,
	163	+ String protocol,
	164	+ String prompt,
	165	+ String scheme) {
	166	+
	167	+ SecurityManager sm = System.getSecurityManager();
	168	+ if (sm != null) {
	169	+ NetPermission requestPermission
	170	+ = new NetPermission("requestPasswordAuthentication");
	171	+ sm.checkPermission(requestPermission);
	172	+ }
	173	+
	174	+ Authenticator a = theAuthenticator;
	175	+ if (a == null) {
	176	+ return null;
	177	+ } else {
	178	+ synchronized(a) {
	179	+ a.reset();
	180	+ a.requestingSite = addr;
	181	+ a.requestingPort = port;
	182	+ a.requestingProtocol = protocol;
	183	+ a.requestingPrompt = prompt;
	184	+ a.requestingScheme = scheme;
	185	+ return a.getPasswordAuthentication();
	186	+ }
	187	+ }
	188	+ }
	189	+
	190	+ /**
	191	+ * Ask the authenticator that has been registered with the system
	192	+ * for a password. This is the preferred method for requesting a password
	193	+ * because the hostname can be provided in cases where the InetAddress
	194	+ * is not available.
	195	+ * <p>
	196	+ * First, if there is a security manager, its <code>checkPermission</code>
	197	+ * method is called with a
	198	+ * <code>NetPermission("requestPasswordAuthentication")</code> permission.
	199	+ * This may result in a java.lang.SecurityException.
	200	+ *
	201	+ * @param host The hostname of the site requesting authentication.
	202	+ * @param addr The InetAddress of the site requesting authentication,
	203	+ * or null if not known.
	204	+ * @param port the port for the requested connection.
	205	+ * @param protocol The protocol that's requesting the connection
	206	+ * ({@link java.net.Authenticator#getRequestingProtocol()})
	207	+ * @param prompt A prompt string for the user which identifies the authentication realm.
	208	+ * @param scheme The authentication scheme
	209	+ *
	210	+ * @return The username/password, or null if one can't be gotten.
	211	+ *
	212	+ * @throws SecurityException
	213	+ * if a security manager exists and its
	214	+ * <code>checkPermission</code> method doesn't allow
	215	+ * the password authentication request.
	216	+ *
	217	+ * @see SecurityManager#checkPermission
	218	+ * @see java.net.NetPermission
	219	+ * @since 1.4
	220	+ */
	221	+ public static PasswordAuthentication requestPasswordAuthentication(
	222	+ String host,
	223	+ InetAddress addr,
	224	+ int port,
	225	+ String protocol,
	226	+ String prompt,
	227	+ String scheme) {
	228	+
	229	+ SecurityManager sm = System.getSecurityManager();
	230	+ if (sm != null) {
	231	+ NetPermission requestPermission
	232	+ = new NetPermission("requestPasswordAuthentication");
	233	+ sm.checkPermission(requestPermission);
	234	+ }
	235	+
	236	+ Authenticator a = theAuthenticator;
	237	+ if (a == null) {
	238	+ return null;
	239	+ } else {
	240	+ synchronized(a) {
	241	+ a.reset();
	242	+ a.requestingHost = host;
	243	+ a.requestingSite = addr;
	244	+ a.requestingPort = port;
	245	+ a.requestingProtocol = protocol;
	246	+ a.requestingPrompt = prompt;
	247	+ a.requestingScheme = scheme;
	248	+ return a.getPasswordAuthentication();
	249	+ }
	250	+ }
	251	+ }
	252	+
	253	+ /**
	254	+ * Ask the authenticator that has been registered with the system
	255	+ * for a password.
	256	+ * <p>
	257	+ * First, if there is a security manager, its <code>checkPermission</code>
	258	+ * method is called with a
	259	+ * <code>NetPermission("requestPasswordAuthentication")</code> permission.
	260	+ * This may result in a java.lang.SecurityException.
	261	+ *
	262	+ * @param host The hostname of the site requesting authentication.
	263	+ * @param addr The InetAddress of the site requesting authorization,
	264	+ * or null if not known.
	265	+ * @param port the port for the requested connection
	266	+ * @param protocol The protocol that's requesting the connection
	267	+ * ({@link java.net.Authenticator#getRequestingProtocol()})
	268	+ * @param prompt A prompt string for the user
	269	+ * @param scheme The authentication scheme
	270	+ * @param url The requesting URL that caused the authentication
	271	+ * @param reqType The type (server or proxy) of the entity requesting
	272	+ * authentication.
	273	+ *
	274	+ * @return The username/password, or null if one can't be gotten.
	275	+ *
	276	+ * @throws SecurityException
	277	+ * if a security manager exists and its
	278	+ * <code>checkPermission</code> method doesn't allow
	279	+ * the password authentication request.
	280	+ *
	281	+ * @see SecurityManager#checkPermission
	282	+ * @see java.net.NetPermission
	283	+ *
	284	+ * @since 1.5
	285	+ */
	286	+ public static PasswordAuthentication requestPasswordAuthentication(
	287	+ String host,
	288	+ InetAddress addr,
	289	+ int port,
	290	+ String protocol,
	291	+ String prompt,
	292	+ String scheme,
	293	+ URL url,
	294	+ RequestorType reqType) {
	295	+
	296	+ SecurityManager sm = System.getSecurityManager();
	297	+ if (sm != null) {
	298	+ NetPermission requestPermission
	299	+ = new NetPermission("requestPasswordAuthentication");
	300	+ sm.checkPermission(requestPermission);
	301	+ }
	302	+
	303	+ Authenticator a = theAuthenticator;
	304	+ if (a == null) {
	305	+ return null;
	306	+ } else {
	307	+ synchronized(a) {
	308	+ a.reset();
	309	+ a.requestingHost = host;
	310	+ a.requestingSite = addr;
	311	+ a.requestingPort = port;
	312	+ a.requestingProtocol = protocol;
	313	+ a.requestingPrompt = prompt;
	314	+ a.requestingScheme = scheme;
	315	+ a.requestingURL = url;
	316	+ a.requestingAuthType = reqType;
	317	+ return a.getPasswordAuthentication();
	318	+ }
	319	+ }
	320	+ }
	321	+
	322	+ /**
	323	+ * Gets the <code>hostname</code> of the
	324	+ * site or proxy requesting authentication, or <code>null</code>
	325	+ * if not available.
	326	+ *
	327	+ * @return the hostname of the connection requiring authentication, or null
	328	+ * if it's not available.
	329	+ * @since 1.4
	330	+ */
	331	+ protected final String getRequestingHost() {
	332	+ return requestingHost;
	333	+ }
	334	+
	335	+ /**
	336	+ * Gets the <code>InetAddress</code> of the
	337	+ * site requesting authorization, or <code>null</code>
	338	+ * if not available.
	339	+ *
	340	+ * @return the InetAddress of the site requesting authorization, or null
	341	+ * if it's not available.
	342	+ */
	343	+ protected final InetAddress getRequestingSite() {
	344	+ return requestingSite;
	345	+ }
	346	+
	347	+ /**
	348	+ * Gets the port number for the requested connection.
	349	+ * @return an <code>int</code> indicating the
	350	+ * port for the requested connection.
	351	+ */
	352	+ protected final int getRequestingPort() {
	353	+ return requestingPort;
	354	+ }
	355	+
	356	+ /**
	357	+ * Give the protocol that's requesting the connection. Often this
	358	+ * will be based on a URL, but in a future JDK it could be, for
	359	+ * example, "SOCKS" for a password-protected SOCKS5 firewall.
	360	+ *
	361	+ * @return the protcol, optionally followed by "/version", where
	362	+ * version is a version number.
	363	+ *
	364	+ * @see java.net.URL#getProtocol()
	365	+ */
	366	+ protected final String getRequestingProtocol() {
	367	+ return requestingProtocol;
	368	+ }
	369	+
	370	+ /**
	371	+ * Gets the prompt string given by the requestor.
	372	+ *
	373	+ * @return the prompt string given by the requestor (realm for
	374	+ * http requests)
	375	+ */
	376	+ protected final String getRequestingPrompt() {
	377	+ return requestingPrompt;
	378	+ }
	379	+
	380	+ /**
	381	+ * Gets the scheme of the requestor (the HTTP scheme
	382	+ * for an HTTP firewall, for example).
	383	+ *
	384	+ * @return the scheme of the requestor
	385	+ *
	386	+ */
	387	+ protected final String getRequestingScheme() {
	388	+ return requestingScheme;
	389	+ }
	390	+
	391	+ /**
	392	+ * Called when password authorization is needed. Subclasses should
	393	+ * override the default implementation, which returns null.
	394	+ * @return The PasswordAuthentication collected from the
	395	+ * user, or null if none is provided.
	396	+ */
	397	+ protected PasswordAuthentication getPasswordAuthentication() {
	398	+ return null;
	399	+ }
	400	+
	401	+ /**
	402	+ * Returns the URL that resulted in this
	403	+ * request for authentication.
	404	+ *
	405	+ * @since 1.5
	406	+ *
	407	+ * @return the requesting URL
	408	+ *
	409	+ */
	410	+ protected URL getRequestingURL () {
	411	+ return requestingURL;
	412	+ }
	413	+
	414	+ /**
	415	+ * Returns whether the requestor is a Proxy or a Server.
	416	+ *
	417	+ * @since 1.5
	418	+ *
	419	+ * @return the authentication type of the requestor
	420	+ *
	421	+ */
	422	+ protected RequestorType getRequestorType () {
	423	+ return requestingAuthType;
	424	+ }
	425	+}

java/pkg/java/net/BindException.class+0−0

Binary file not shown.

java/pkg/java/net/BindException.java+54−0

@@ -0,0 +1,54 @@
	1	+/*
	2	+ * Copyright (c) 1996, 2008, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+/**
	29	+ * Signals that an error occurred while attempting to bind a
	30	+ * socket to a local address and port. Typically, the port is
	31	+ * in use, or the requested local address could not be assigned.
	32	+ *
	33	+ * @since JDK1.1
	34	+ */
	35	+
	36	+public class BindException extends SocketException {
	37	+ private static final long serialVersionUID = -5945005768251722951L;
	38	+
	39	+ /**
	40	+ * Constructs a new BindException with the specified detail
	41	+ * message as to why the bind error occurred.
	42	+ * A detail message is a String that gives a specific
	43	+ * description of this error.
	44	+ * @param msg the detail message
	45	+ */
	46	+ public BindException(String msg) {
	47	+ super(msg);
	48	+ }
	49	+
	50	+ /**
	51	+ * Construct a new BindException with no detailed message.
	52	+ */
	53	+ public BindException() {}
	54	+}

java/pkg/java/net/CacheRequest.class+0−0

Binary file not shown.

java/pkg/java/net/CacheRequest.java+63−0

@@ -0,0 +1,63 @@
	1	+/*
	2	+ * Copyright (c) 2003, 2004, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.io.OutputStream;
	29	+import java.io.IOException;
	30	+
	31	+/**
	32	+ * Represents channels for storing resources in the
	33	+ * ResponseCache. Instances of such a class provide an
	34	+ * OutputStream object which is called by protocol handlers to
	35	+ * store the resource data into the cache, and also an abort() method
	36	+ * which allows a cache store operation to be interrupted and
	37	+ * abandoned. If an IOException is encountered while reading the
	38	+ * response or writing to the cache, the current cache store operation
	39	+ * will be aborted.
	40	+ *
	41	+ * @author Yingxian Wang
	42	+ * @since 1.5
	43	+ */
	44	+public abstract class CacheRequest {
	45	+
	46	+ /**
	47	+ * Returns an OutputStream to which the response body can be
	48	+ * written.
	49	+ *
	50	+ * @return an OutputStream to which the response body can
	51	+ * be written
	52	+ * @throws IOException if an I/O error occurs while
	53	+ * writing the response body
	54	+ */
	55	+ public abstract OutputStream getBody() throws IOException;
	56	+
	57	+ /**
	58	+ * Aborts the attempt to cache the response. If an IOException is
	59	+ * encountered while reading the response or writing to the cache,
	60	+ * the current cache store operation will be abandoned.
	61	+ */
	62	+ public abstract void abort();
	63	+}

java/pkg/java/net/CacheResponse.class+0−0

Binary file not shown.

java/pkg/java/net/CacheResponse.java+64−0

@@ -0,0 +1,64 @@
	1	+/*
	2	+ * Copyright (c) 2003, 2004, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.io.InputStream;
	29	+import java.util.Map;
	30	+import java.util.List;
	31	+import java.io.IOException;
	32	+
	33	+/**
	34	+ * Represent channels for retrieving resources from the
	35	+ * ResponseCache. Instances of such a class provide an
	36	+ * InputStream that returns the entity body, and also a
	37	+ * getHeaders() method which returns the associated response headers.
	38	+ *
	39	+ * @author Yingxian Wang
	40	+ * @since 1.5
	41	+ */
	42	+public abstract class CacheResponse {
	43	+
	44	+ /**
	45	+ * Returns the response headers as a Map.
	46	+ *
	47	+ * @return An immutable Map from response header field names to
	48	+ * lists of field values. The status line has null as its
	49	+ * field name.
	50	+ * @throws IOException if an I/O error occurs
	51	+ * while getting the response headers
	52	+ */
	53	+ public abstract Map<String, List<String>> getHeaders() throws IOException;
	54	+
	55	+ /**
	56	+ * Returns the response body as an InputStream.
	57	+ *
	58	+ * @return an InputStream from which the response body can
	59	+ * be accessed
	60	+ * @throws IOException if an I/O error occurs while
	61	+ * getting the response body
	62	+ */
	63	+ public abstract InputStream getBody() throws IOException;
	64	+}

java/pkg/java/net/ConnectException.class+0−0

Binary file not shown.

java/pkg/java/net/ConnectException.java+54−0

@@ -0,0 +1,54 @@
	1	+/*
	2	+ * Copyright (c) 1996, 2008, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+/**
	29	+ * Signals that an error occurred while attempting to connect a
	30	+ * socket to a remote address and port. Typically, the connection
	31	+ * was refused remotely (e.g., no process is listening on the
	32	+ * remote address/port).
	33	+ *
	34	+ * @since JDK1.1
	35	+ */
	36	+public class ConnectException extends SocketException {
	37	+ private static final long serialVersionUID = 3831404271622369215L;
	38	+
	39	+ /**
	40	+ * Constructs a new ConnectException with the specified detail
	41	+ * message as to why the connect error occurred.
	42	+ * A detail message is a String that gives a specific
	43	+ * description of this error.
	44	+ * @param msg the detail message
	45	+ */
	46	+ public ConnectException(String msg) {
	47	+ super(msg);
	48	+ }
	49	+
	50	+ /**
	51	+ * Construct a new ConnectException with no detailed message.
	52	+ */
	53	+ public ConnectException() {}
	54	+}

java/pkg/java/net/ContentHandler.class+0−0

Binary file not shown.

java/pkg/java/net/ContentHandler.java+110−0

@@ -0,0 +1,110 @@
	1	+/*
	2	+ * Copyright (c) 1995, 2006, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.io.IOException;
	29	+
	30	+/**
	31	+ * The abstract class <code>ContentHandler</code> is the superclass
	32	+ * of all classes that read an <code>Object</code> from a
	33	+ * <code>URLConnection</code>.
	34	+ * <p>
	35	+ * An application does not generally call the
	36	+ * <code>getContent</code> method in this class directly. Instead, an
	37	+ * application calls the <code>getContent</code> method in class
	38	+ * <code>URL</code> or in <code>URLConnection</code>.
	39	+ * The application's content handler factory (an instance of a class that
	40	+ * implements the interface <code>ContentHandlerFactory</code> set
	41	+ * up by a call to <code>setContentHandler</code>) is
	42	+ * called with a <code>String</code> giving the MIME type of the
	43	+ * object being received on the socket. The factory returns an
	44	+ * instance of a subclass of <code>ContentHandler</code>, and its
	45	+ * <code>getContent</code> method is called to create the object.
	46	+ * <p>
	47	+ * If no content handler could be found, URLConnection will
	48	+ * look for a content handler in a user-defineable set of places.
	49	+ * By default it looks in sun.net.www.content, but users can define a
	50	+ * vertical-bar delimited set of class prefixes to search through in
	51	+ * addition by defining the java.content.handler.pkgs property.
	52	+ * The class name must be of the form:
	53	+ * <pre>
	54	+ * {package-prefix}.{major}.{minor}
	55	+ * e.g.
	56	+ * YoyoDyne.experimental.text.plain
	57	+ * </pre>
	58	+ * If the loading of the content handler class would be performed by
	59	+ * a classloader that is outside of the delegation chain of the caller,
	60	+ * the JVM will need the RuntimePermission "getClassLoader".
	61	+ *
	62	+ * @author James Gosling
	63	+ * @see java.net.ContentHandler#getContent(java.net.URLConnection)
	64	+ * @see java.net.ContentHandlerFactory
	65	+ * @see java.net.URL#getContent()
	66	+ * @see java.net.URLConnection
	67	+ * @see java.net.URLConnection#getContent()
	68	+ * @see java.net.URLConnection#setContentHandlerFactory(java.net.ContentHandlerFactory)
	69	+ * @since JDK1.0
	70	+ */
	71	+abstract public class ContentHandler {
	72	+ /**
	73	+ * Given a URL connect stream positioned at the beginning of the
	74	+ * representation of an object, this method reads that stream and
	75	+ * creates an object from it.
	76	+ *
	77	+ * @param urlc a URL connection.
	78	+ * @return the object read by the <code>ContentHandler</code>.
	79	+ * @exception IOException if an I/O error occurs while reading the object.
	80	+ */
	81	+ abstract public Object getContent(URLConnection urlc) throws IOException;
	82	+
	83	+ /**
	84	+ * Given a URL connect stream positioned at the beginning of the
	85	+ * representation of an object, this method reads that stream and
	86	+ * creates an object that matches one of the types specified.
	87	+ *
	88	+ * The default implementation of this method should call getContent()
	89	+ * and screen the return type for a match of the suggested types.
	90	+ *
	91	+ * @param urlc a URL connection.
	92	+ * @param classes an array of types requested
	93	+ * @return the object read by the <code>ContentHandler</code> that is
	94	+ * the first match of the suggested types.
	95	+ * null if none of the requested are supported.
	96	+ * @exception IOException if an I/O error occurs while reading the object.
	97	+ * @since 1.3
	98	+ */
	99	+ public Object getContent(URLConnection urlc, Class[] classes) throws IOException {
	100	+ Object obj = getContent(urlc);
	101	+
	102	+ for (int i = 0; i < classes.length; i++) {
	103	+ if (classes[i].isInstance(obj)) {
	104	+ return obj;
	105	+ }
	106	+ }
	107	+ return null;
	108	+ }
	109	+
	110	+}

java/pkg/java/net/ContentHandlerFactory.class+0−0

Binary file not shown.

java/pkg/java/net/ContentHandlerFactory.java+54−0

@@ -0,0 +1,54 @@
	1	+/*
	2	+ * Copyright (c) 1995, 1997, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+/**
	29	+ * This interface defines a factory for content handlers. An
	30	+ * implementation of this interface should map a MIME type into an
	31	+ * instance of <code>ContentHandler</code>.
	32	+ * <p>
	33	+ * This interface is used by the <code>URLStreamHandler</code> class
	34	+ * to create a <code>ContentHandler</code> for a MIME type.
	35	+ *
	36	+ * @author James Gosling
	37	+ * @see java.net.ContentHandler
	38	+ * @see java.net.URLStreamHandler
	39	+ * @since JDK1.0
	40	+ */
	41	+public interface ContentHandlerFactory {
	42	+ /**
	43	+ * Creates a new <code>ContentHandler</code> to read an object from
	44	+ * a <code>URLStreamHandler</code>.
	45	+ *
	46	+ * @param mimetype the MIME type for which a content handler is desired.
	47	+
	48	+ * @return a new <code>ContentHandler</code> to read an object from a
	49	+ * <code>URLStreamHandler</code>.
	50	+ * @see java.net.ContentHandler
	51	+ * @see java.net.URLStreamHandler
	52	+ */
	53	+ ContentHandler createContentHandler(String mimetype);
	54	+}

java/pkg/java/net/CookieHandler.class+0−0

Binary file not shown.

java/pkg/java/net/CookieHandler.java+150−0

@@ -0,0 +1,150 @@
	1	+/*
	2	+ * Copyright (c) 2003, 2008, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.util.Map;
	29	+import java.util.List;
	30	+import java.io.IOException;
	31	+import sun.security.util.SecurityConstants;
	32	+
	33	+/**
	34	+ * A CookieHandler object provides a callback mechanism to hook up a
	35	+ * HTTP state management policy implementation into the HTTP protocol
	36	+ * handler. The HTTP state management mechanism specifies a way to
	37	+ * create a stateful session with HTTP requests and responses.
	38	+ *
	39	+ * <p>A system-wide CookieHandler that to used by the HTTP protocol
	40	+ * handler can be registered by doing a
	41	+ * CookieHandler.setDefault(CookieHandler). The currently registered
	42	+ * CookieHandler can be retrieved by calling
	43	+ * CookieHandler.getDefault().
	44	+ *
	45	+ * For more information on HTTP state management, see <a
	46	+ * href="http://www.ietf.org/rfc/rfc2965.txt"><i>RFC 2965: HTTP
	47	+ * State Management Mechanism</i></a>
	48	+ *
	49	+ * @author Yingxian Wang
	50	+ * @since 1.5
	51	+ */
	52	+public abstract class CookieHandler {
	53	+ /**
	54	+ * The system-wide cookie handler that will apply cookies to the
	55	+ * request headers and manage cookies from the response headers.
	56	+ *
	57	+ * @see setDefault(CookieHandler)
	58	+ * @see getDefault()
	59	+ */
	60	+ private static CookieHandler cookieHandler;
	61	+
	62	+ /**
	63	+ * Gets the system-wide cookie handler.
	64	+ *
	65	+ * @return the system-wide cookie handler; A null return means
	66	+ * there is no system-wide cookie handler currently set.
	67	+ * @throws SecurityException
	68	+ * If a security manager has been installed and it denies
	69	+ * {@link NetPermission}<tt>("getCookieHandler")</tt>
	70	+ * @see #setDefault(CookieHandler)
	71	+ */
	72	+ public synchronized static CookieHandler getDefault() {
	73	+ SecurityManager sm = System.getSecurityManager();
	74	+ if (sm != null) {
	75	+ sm.checkPermission(SecurityConstants.GET_COOKIEHANDLER_PERMISSION);
	76	+ }
	77	+ return cookieHandler;
	78	+ }
	79	+
	80	+ /**
	81	+ * Sets (or unsets) the system-wide cookie handler.
	82	+ *
	83	+ * Note: non-standard http protocol handlers may ignore this setting.
	84	+ *
	85	+ * @param cHandler The HTTP cookie handler, or
	86	+ * <code>null</code> to unset.
	87	+ * @throws SecurityException
	88	+ * If a security manager has been installed and it denies
	89	+ * {@link NetPermission}<tt>("setCookieHandler")</tt>
	90	+ * @see #getDefault()
	91	+ */
	92	+ public synchronized static void setDefault(CookieHandler cHandler) {
	93	+ SecurityManager sm = System.getSecurityManager();
	94	+ if (sm != null) {
	95	+ sm.checkPermission(SecurityConstants.SET_COOKIEHANDLER_PERMISSION);
	96	+ }
	97	+ cookieHandler = cHandler;
	98	+ }
	99	+
	100	+ /**
	101	+ * Gets all the applicable cookies from a cookie cache for the
	102	+ * specified uri in the request header.
	103	+ *
	104	+ * <P>The {@code URI} passed as an argument specifies the intended use for
	105	+ * the cookies. In particular the scheme should reflect whether the cookies
	106	+ * will be sent over http, https or used in another context like javascript.
	107	+ * The host part should reflect either the destination of the cookies or
	108	+ * their origin in the case of javascript.</P>
	109	+ * <P>It is up to the implementation to take into account the {@code URI} and
	110	+ * the cookies attributes and security settings to determine which ones
	111	+ * should be returned.</P>
	112	+ *
	113	+ * <P>HTTP protocol implementers should make sure that this method is
	114	+ * called after all request headers related to choosing cookies
	115	+ * are added, and before the request is sent.</P>
	116	+ *
	117	+ * @param uri a <code>URI</code> representing the intended use for the
	118	+ * cookies
	119	+ * @param requestHeaders - a Map from request header
	120	+ * field names to lists of field values representing
	121	+ * the current request headers
	122	+ * @return an immutable map from state management headers, with
	123	+ * field names "Cookie" or "Cookie2" to a list of
	124	+ * cookies containing state information
	125	+ *
	126	+ * @throws IOException if an I/O error occurs
	127	+ * @throws IllegalArgumentException if either argument is null
	128	+ * @see #put(URI, Map)
	129	+ */
	130	+ public abstract Map<String, List<String>>
	131	+ get(URI uri, Map<String, List<String>> requestHeaders)
	132	+ throws IOException;
	133	+
	134	+ /**
	135	+ * Sets all the applicable cookies, examples are response header
	136	+ * fields that are named Set-Cookie2, present in the response
	137	+ * headers into a cookie cache.
	138	+ *
	139	+ * @param uri a <code>URI</code> where the cookies come from
	140	+ * @param responseHeaders an immutable map from field names to
	141	+ * lists of field values representing the response
	142	+ * header fields returned
	143	+ * @throws IOException if an I/O error occurs
	144	+ * @throws IllegalArgumentException if either argument is null
	145	+ * @see #get(URI, Map)
	146	+ */
	147	+ public abstract void
	148	+ put(URI uri, Map<String, List<String>> responseHeaders)
	149	+ throws IOException;
	150	+}

java/pkg/java/net/CookieManager$CookiePathComparator.class+0−0

Binary file not shown.

java/pkg/java/net/CookieManager.class+0−0

Binary file not shown.

java/pkg/java/net/CookieManager.java+446−0

@@ -0,0 +1,446 @@
	1	+/*
	2	+ * Copyright (c) 2005, 2008, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.util.Map;
	29	+import java.util.List;
	30	+import java.util.Collections;
	31	+import java.util.Comparator;
	32	+import java.io.IOException;
	33	+import sun.util.logging.PlatformLogger;
	34	+
	35	+/**
	36	+ * CookieManager provides a concrete implementation of {@link CookieHandler},
	37	+ * which separates the storage of cookies from the policy surrounding accepting
	38	+ * and rejecting cookies. A CookieManager is initialized with a {@link CookieStore}
	39	+ * which manages storage, and a {@link CookiePolicy} object, which makes
	40	+ * policy decisions on cookie acceptance/rejection.
	41	+ *
	42	+ * <p> The HTTP cookie management in java.net package looks like:
	43	+ * <blockquote>
	44	+ * <pre>
	45	+ * use
	46	+ * CookieHandler <------- HttpURLConnection
	47	+ * ^
	48	+ * \| impl
	49	+ * \| use
	50	+ * CookieManager -------> CookiePolicy
	51	+ * \| use
	52	+ * \|--------> HttpCookie
	53	+ * \| ^
	54	+ * \| \| use
	55	+ * \| use \|
	56	+ * \|--------> CookieStore
	57	+ * ^
	58	+ * \| impl
	59	+ * \|
	60	+ * Internal in-memory implementation
	61	+ * </pre>
	62	+ * <ul>
	63	+ * <li>
	64	+ * CookieHandler is at the core of cookie management. User can call
	65	+ * CookieHandler.setDefault to set a concrete CookieHanlder implementation
	66	+ * to be used.
	67	+ * </li>
	68	+ * <li>
	69	+ * CookiePolicy.shouldAccept will be called by CookieManager.put to see whether
	70	+ * or not one cookie should be accepted and put into cookie store. User can use
	71	+ * any of three pre-defined CookiePolicy, namely ACCEPT_ALL, ACCEPT_NONE and
	72	+ * ACCEPT_ORIGINAL_SERVER, or user can define his own CookiePolicy implementation
	73	+ * and tell CookieManager to use it.
	74	+ * </li>
	75	+ * <li>
	76	+ * CookieStore is the place where any accepted HTTP cookie is stored in.
	77	+ * If not specified when created, a CookieManager instance will use an internal
	78	+ * in-memory implementation. Or user can implements one and tell CookieManager
	79	+ * to use it.
	80	+ * </li>
	81	+ * <li>
	82	+ * Currently, only CookieStore.add(URI, HttpCookie) and CookieStore.get(URI)
	83	+ * are used by CookieManager. Others are for completeness and might be needed
	84	+ * by a more sophisticated CookieStore implementation, e.g. a NetscapeCookieSotre.
	85	+ * </li>
	86	+ * </ul>
	87	+ * </blockquote>
	88	+ *
	89	+ * <p>There're various ways user can hook up his own HTTP cookie management behavior, e.g.
	90	+ * <blockquote>
	91	+ * <ul>
	92	+ * <li>Use CookieHandler.setDefault to set a brand new {@link CookieHandler} implementation
	93	+ * <li>Let CookieManager be the default {@link CookieHandler} implementation,
	94	+ * but implement user's own {@link CookieStore} and {@link CookiePolicy}
	95	+ * and tell default CookieManager to use them:
	96	+ * <blockquote><pre>
	97	+ * // this should be done at the beginning of an HTTP session
	98	+ * CookieHandler.setDefault(new CookieManager(new MyCookieStore(), new MyCookiePolicy()));
	99	+ * </pre></blockquote>
	100	+ * <li>Let CookieManager be the default {@link CookieHandler} implementation, but
	101	+ * use customized {@link CookiePolicy}:
	102	+ * <blockquote><pre>
	103	+ * // this should be done at the beginning of an HTTP session
	104	+ * CookieHandler.setDefault(new CookieManager());
	105	+ * // this can be done at any point of an HTTP session
	106	+ * ((CookieManager)CookieHandler.getDefault()).setCookiePolicy(new MyCookiePolicy());
	107	+ * </pre></blockquote>
	108	+ * </ul>
	109	+ * </blockquote>
	110	+ *
	111	+ * <p>The implementation conforms to <a href="http://www.ietf.org/rfc/rfc2965.txt">RFC 2965</a>, section 3.3.
	112	+ *
	113	+ * @see CookiePolicy
	114	+ * @author Edward Wang
	115	+ * @since 1.6
	116	+ */
	117	+public class CookieManager extends CookieHandler
	118	+{
	119	+ /* ---------------- Fields -------------- */
	120	+
	121	+ private CookiePolicy policyCallback;
	122	+
	123	+
	124	+ private CookieStore cookieJar = null;
	125	+
	126	+
	127	+ /* ---------------- Ctors -------------- */
	128	+
	129	+ /**
	130	+ * Create a new cookie manager.
	131	+ *
	132	+ * <p>This constructor will create new cookie manager with default
	133	+ * cookie store and accept policy. The effect is same as
	134	+ * <tt>CookieManager(null, null)</tt>.
	135	+ */
	136	+ public CookieManager() {
	137	+ this(null, null);
	138	+ }
	139	+
	140	+
	141	+ /**
	142	+ * Create a new cookie manager with specified cookie store and cookie policy.
	143	+ *
	144	+ * @param store a <tt>CookieStore</tt> to be used by cookie manager.
	145	+ * if <tt>null</tt>, cookie manager will use a default one,
	146	+ * which is an in-memory CookieStore implmentation.
	147	+ * @param cookiePolicy a <tt>CookiePolicy</tt> instance
	148	+ * to be used by cookie manager as policy callback.
	149	+ * if <tt>null</tt>, ACCEPT_ORIGINAL_SERVER will
	150	+ * be used.
	151	+ */
	152	+ public CookieManager(CookieStore store,
	153	+ CookiePolicy cookiePolicy)
	154	+ {
	155	+ // use default cookie policy if not specify one
	156	+ policyCallback = (cookiePolicy == null) ? CookiePolicy.ACCEPT_ORIGINAL_SERVER
	157	+ : cookiePolicy;
	158	+
	159	+ // if not specify CookieStore to use, use default one
	160	+ if (store == null) {
	161	+ cookieJar = new InMemoryCookieStore();
	162	+ } else {
	163	+ cookieJar = store;
	164	+ }
	165	+ }
	166	+
	167	+
	168	+ /* ---------------- Public operations -------------- */
	169	+
	170	+ /**
	171	+ * To set the cookie policy of this cookie manager.
	172	+ *
	173	+ * <p> A instance of <tt>CookieManager</tt> will have
	174	+ * cookie policy ACCEPT_ORIGINAL_SERVER by default. Users always
	175	+ * can call this method to set another cookie policy.
	176	+ *
	177	+ * @param cookiePolicy the cookie policy. Can be <tt>null</tt>, which
	178	+ * has no effects on current cookie policy.
	179	+ */
	180	+ public void setCookiePolicy(CookiePolicy cookiePolicy) {
	181	+ if (cookiePolicy != null) policyCallback = cookiePolicy;
	182	+ }
	183	+
	184	+
	185	+ /**
	186	+ * To retrieve current cookie store.
	187	+ *
	188	+ * @return the cookie store currently used by cookie manager.
	189	+ */
	190	+ public CookieStore getCookieStore() {
	191	+ return cookieJar;
	192	+ }
	193	+
	194	+
	195	+ public Map<String, List<String>>
	196	+ get(URI uri, Map<String, List<String>> requestHeaders)
	197	+ throws IOException
	198	+ {
	199	+ // pre-condition check
	200	+ if (uri == null \|\| requestHeaders == null) {
	201	+ throw new IllegalArgumentException("Argument is null");
	202	+ }
	203	+
	204	+ Map<String, List<String>> cookieMap =
	205	+ new java.util.HashMap<String, List<String>>();
	206	+ // if there's no default CookieStore, no way for us to get any cookie
	207	+ if (cookieJar == null)
	208	+ return Collections.unmodifiableMap(cookieMap);
	209	+
	210	+ boolean secureLink = "https".equalsIgnoreCase(uri.getScheme());
	211	+ List<HttpCookie> cookies = new java.util.ArrayList<HttpCookie>();
	212	+ String path = uri.getPath();
	213	+ if (path == null \|\| path.isEmpty()) {
	214	+ path = "/";
	215	+ }
	216	+ for (HttpCookie cookie : cookieJar.get(uri)) {
	217	+ // apply path-matches rule (RFC 2965 sec. 3.3.4)
	218	+ // and check for the possible "secure" tag (i.e. don't send
	219	+ // 'secure' cookies over unsecure links)
	220	+ if (pathMatches(path, cookie.getPath()) &&
	221	+ (secureLink \|\| !cookie.getSecure())) {
	222	+ // Enforce httponly attribute
	223	+ if (cookie.isHttpOnly()) {
	224	+ String s = uri.getScheme();
	225	+ if (!"http".equalsIgnoreCase(s) && !"https".equalsIgnoreCase(s)) {
	226	+ continue;
	227	+ }
	228	+ }
	229	+ // Let's check the authorize port list if it exists
	230	+ String ports = cookie.getPortlist();
	231	+ if (ports != null && !ports.isEmpty()) {
	232	+ int port = uri.getPort();
	233	+ if (port == -1) {
	234	+ port = "https".equals(uri.getScheme()) ? 443 : 80;
	235	+ }
	236	+ if (isInPortList(ports, port)) {
	237	+ cookies.add(cookie);
	238	+ }
	239	+ } else {
	240	+ cookies.add(cookie);
	241	+ }
	242	+ }
	243	+ }
	244	+
	245	+ // apply sort rule (RFC 2965 sec. 3.3.4)
	246	+ List<String> cookieHeader = sortByPath(cookies);
	247	+
	248	+ cookieMap.put("Cookie", cookieHeader);
	249	+ return Collections.unmodifiableMap(cookieMap);
	250	+ }
	251	+
	252	+
	253	+ public void
	254	+ put(URI uri, Map<String, List<String>> responseHeaders)
	255	+ throws IOException
	256	+ {
	257	+ // pre-condition check
	258	+ if (uri == null \|\| responseHeaders == null) {
	259	+ throw new IllegalArgumentException("Argument is null");
	260	+ }
	261	+
	262	+
	263	+ // if there's no default CookieStore, no need to remember any cookie
	264	+ if (cookieJar == null)
	265	+ return;
	266	+
	267	+ PlatformLogger logger = PlatformLogger.getLogger("java.net.CookieManager");
	268	+ for (String headerKey : responseHeaders.keySet()) {
	269	+ // RFC 2965 3.2.2, key must be 'Set-Cookie2'
	270	+ // we also accept 'Set-Cookie' here for backward compatibility
	271	+ if (headerKey == null
	272	+ \|\| !(headerKey.equalsIgnoreCase("Set-Cookie2")
	273	+ \|\| headerKey.equalsIgnoreCase("Set-Cookie")
	274	+ )
	275	+ )
	276	+ {
	277	+ continue;
	278	+ }
	279	+
	280	+ for (String headerValue : responseHeaders.get(headerKey)) {
	281	+ try {
	282	+ List<HttpCookie> cookies;
	283	+ try {
	284	+ cookies = HttpCookie.parse(headerValue);
	285	+ } catch (IllegalArgumentException e) {
	286	+ // Bogus header, make an empty list and log the error
	287	+ cookies = java.util.Collections.EMPTY_LIST;
	288	+ if (logger.isLoggable(PlatformLogger.SEVERE)) {
	289	+ logger.severe("Invalid cookie for " + uri + ": " + headerValue);
	290	+ }
	291	+ }
	292	+ for (HttpCookie cookie : cookies) {
	293	+ if (cookie.getPath() == null) {
	294	+ // If no path is specified, then by default
	295	+ // the path is the directory of the page/doc
	296	+ String path = uri.getPath();
	297	+ if (!path.endsWith("/")) {
	298	+ int i = path.lastIndexOf("/");
	299	+ if (i > 0) {
	300	+ path = path.substring(0, i + 1);
	301	+ } else {
	302	+ path = "/";
	303	+ }
	304	+ }
	305	+ cookie.setPath(path);
	306	+ }
	307	+
	308	+ // As per RFC 2965, section 3.3.1:
	309	+ // Domain Defaults to the effective request-host. (Note that because
	310	+ // there is no dot at the beginning of effective request-host,
	311	+ // the default Domain can only domain-match itself.)
	312	+ if (cookie.getDomain() == null) {
	313	+ cookie.setDomain(uri.getHost());
	314	+ }
	315	+ String ports = cookie.getPortlist();
	316	+ if (ports != null) {
	317	+ int port = uri.getPort();
	318	+ if (port == -1) {
	319	+ port = "https".equals(uri.getScheme()) ? 443 : 80;
	320	+ }
	321	+ if (ports.isEmpty()) {
	322	+ // Empty port list means this should be restricted
	323	+ // to the incoming URI port
	324	+ cookie.setPortlist("" + port );
	325	+ if (shouldAcceptInternal(uri, cookie)) {
	326	+ cookieJar.add(uri, cookie);
	327	+ }
	328	+ } else {
	329	+ // Only store cookies with a port list
	330	+ // IF the URI port is in that list, as per
	331	+ // RFC 2965 section 3.3.2
	332	+ if (isInPortList(ports, port) &&
	333	+ shouldAcceptInternal(uri, cookie)) {
	334	+ cookieJar.add(uri, cookie);
	335	+ }
	336	+ }
	337	+ } else {
	338	+ if (shouldAcceptInternal(uri, cookie)) {
	339	+ cookieJar.add(uri, cookie);
	340	+ }
	341	+ }
	342	+ }
	343	+ } catch (IllegalArgumentException e) {
	344	+ // invalid set-cookie header string
	345	+ // no-op
	346	+ }
	347	+ }
	348	+ }
	349	+ }
	350	+
	351	+
	352	+ /* ---------------- Private operations -------------- */
	353	+
	354	+ // to determine whether or not accept this cookie
	355	+ private boolean shouldAcceptInternal(URI uri, HttpCookie cookie) {
	356	+ try {
	357	+ return policyCallback.shouldAccept(uri, cookie);
	358	+ } catch (Exception ignored) { // pretect against malicious callback
	359	+ return false;
	360	+ }
	361	+ }
	362	+
	363	+
	364	+ static private boolean isInPortList(String lst, int port) {
	365	+ int i = lst.indexOf(",");
	366	+ int val = -1;
	367	+ while (i > 0) {
	368	+ try {
	369	+ val = Integer.parseInt(lst.substring(0, i));
	370	+ if (val == port) {
	371	+ return true;
	372	+ }
	373	+ } catch (NumberFormatException numberFormatException) {
	374	+ }
	375	+ lst = lst.substring(i+1);
	376	+ i = lst.indexOf(",");
	377	+ }
	378	+ if (!lst.isEmpty()) {
	379	+ try {
	380	+ val = Integer.parseInt(lst);
	381	+ if (val == port) {
	382	+ return true;
	383	+ }
	384	+ } catch (NumberFormatException numberFormatException) {
	385	+ }
	386	+ }
	387	+ return false;
	388	+ }
	389	+
	390	+ /*
	391	+ * path-matches algorithm, as defined by RFC 2965
	392	+ */
	393	+ private boolean pathMatches(String path, String pathToMatchWith) {
	394	+ if (path == pathToMatchWith)
	395	+ return true;
	396	+ if (path == null \|\| pathToMatchWith == null)
	397	+ return false;
	398	+ if (path.startsWith(pathToMatchWith))
	399	+ return true;
	400	+
	401	+ return false;
	402	+ }
	403	+
	404	+
	405	+ /*
	406	+ * sort cookies with respect to their path: those with more specific Path attributes
	407	+ * precede those with less specific, as defined in RFC 2965 sec. 3.3.4
	408	+ */
	409	+ private List<String> sortByPath(List<HttpCookie> cookies) {
	410	+ Collections.sort(cookies, new CookiePathComparator());
	411	+
	412	+ List<String> cookieHeader = new java.util.ArrayList<String>();
	413	+ for (HttpCookie cookie : cookies) {
	414	+ // Netscape cookie spec and RFC 2965 have different format of Cookie
	415	+ // header; RFC 2965 requires a leading $Version="1" string while Netscape
	416	+ // does not.
	417	+ // The workaround here is to add a $Version="1" string in advance
	418	+ if (cookies.indexOf(cookie) == 0 && cookie.getVersion() > 0) {
	419	+ cookieHeader.add("$Version=\"1\"");
	420	+ }
	421	+
	422	+ cookieHeader.add(cookie.toString());
	423	+ }
	424	+ return cookieHeader;
	425	+ }
	426	+
	427	+
	428	+ static class CookiePathComparator implements Comparator<HttpCookie> {
	429	+ public int compare(HttpCookie c1, HttpCookie c2) {
	430	+ if (c1 == c2) return 0;
	431	+ if (c1 == null) return -1;
	432	+ if (c2 == null) return 1;
	433	+
	434	+ // path rule only applies to the cookies with same name
	435	+ if (!c1.getName().equals(c2.getName())) return 0;
	436	+
	437	+ // those with more specific Path attributes precede those with less specific
	438	+ if (c1.getPath().startsWith(c2.getPath()))
	439	+ return -1;
	440	+ else if (c2.getPath().startsWith(c1.getPath()))
	441	+ return 1;
	442	+ else
	443	+ return 0;
	444	+ }
	445	+ }
	446	+}

java/pkg/java/net/CookiePolicy$1.class+0−0

Binary file not shown.

java/pkg/java/net/CookiePolicy$2.class+0−0

Binary file not shown.

java/pkg/java/net/CookiePolicy$3.class+0−0

Binary file not shown.

java/pkg/java/net/CookiePolicy.class+0−0

Binary file not shown.

java/pkg/java/net/CookiePolicy.java+76−0

@@ -0,0 +1,76 @@
	1	+/*
	2	+ * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+/**
	29	+ * CookiePolicy implementations decide which cookies should be accepted
	30	+ * and which should be rejected. Three pre-defined policy implementations
	31	+ * are provided, namely ACCEPT_ALL, ACCEPT_NONE and ACCEPT_ORIGINAL_SERVER.
	32	+ *
	33	+ * <p>See RFC 2965 sec. 3.3 & 7 for more detail.
	34	+ *
	35	+ * @author Edward Wang
	36	+ * @since 1.6
	37	+ */
	38	+public interface CookiePolicy {
	39	+ /**
	40	+ * One pre-defined policy which accepts all cookies.
	41	+ */
	42	+ public static final CookiePolicy ACCEPT_ALL = new CookiePolicy(){
	43	+ public boolean shouldAccept(URI uri, HttpCookie cookie) {
	44	+ return true;
	45	+ }
	46	+ };
	47	+
	48	+ /**
	49	+ * One pre-defined policy which accepts no cookies.
	50	+ */
	51	+ public static final CookiePolicy ACCEPT_NONE = new CookiePolicy(){
	52	+ public boolean shouldAccept(URI uri, HttpCookie cookie) {
	53	+ return false;
	54	+ }
	55	+ };
	56	+
	57	+ /**
	58	+ * One pre-defined policy which only accepts cookies from original server.
	59	+ */
	60	+ public static final CookiePolicy ACCEPT_ORIGINAL_SERVER = new CookiePolicy(){
	61	+ public boolean shouldAccept(URI uri, HttpCookie cookie) {
	62	+ return HttpCookie.domainMatches(cookie.getDomain(), uri.getHost());
	63	+ }
	64	+ };
	65	+
	66	+
	67	+ /**
	68	+ * Will be called to see whether or not this cookie should be accepted.
	69	+ *
	70	+ * @param uri the URI to consult accept policy with
	71	+ * @param cookie the HttpCookie object in question
	72	+ * @return <tt>true</tt> if this cookie should be accepted;
	73	+ * otherwise, <tt>false</tt>
	74	+ */
	75	+ public boolean shouldAccept(URI uri, HttpCookie cookie);
	76	+}

java/pkg/java/net/CookieStore.class+0−0

Binary file not shown.

java/pkg/java/net/CookieStore.java+127−0

@@ -0,0 +1,127 @@
	1	+/*
	2	+ * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.util.List;
	29	+import java.util.Map;
	30	+
	31	+/**
	32	+ * A CookieStore object represents a storage for cookie. Can store and retrieve
	33	+ * cookies.
	34	+ *
	35	+ * <p>{@link CookieManager} will call <tt>CookieStore.add</tt> to save cookies
	36	+ * for every incoming HTTP response, and call <tt>CookieStore.get</tt> to
	37	+ * retrieve cookie for every outgoing HTTP request. A CookieStore
	38	+ * is responsible for removing HttpCookie instances which have expired.
	39	+ *
	40	+ * @author Edward Wang
	41	+ * @since 1.6
	42	+ */
	43	+public interface CookieStore {
	44	+ /**
	45	+ * Adds one HTTP cookie to the store. This is called for every
	46	+ * incoming HTTP response.
	47	+ *
	48	+ * <p>A cookie to store may or may not be associated with an URI. If it
	49	+ * is not associated with an URI, the cookie's domain and path attribute
	50	+ * will indicate where it comes from. If it is associated with an URI and
	51	+ * its domain and path attribute are not speicifed, given URI will indicate
	52	+ * where this cookie comes from.
	53	+ *
	54	+ * <p>If a cookie corresponding to the given URI already exists,
	55	+ * then it is replaced with the new one.
	56	+ *
	57	+ * @param uri the uri this cookie associated with.
	58	+ * if <tt>null</tt>, this cookie will not be associated
	59	+ * with an URI
	60	+ * @param cookie the cookie to store
	61	+ *
	62	+ * @throws NullPointerException if <tt>cookie</tt> is <tt>null</tt>
	63	+ *
	64	+ * @see #get
	65	+ *
	66	+ */
	67	+ public void add(URI uri, HttpCookie cookie);
	68	+
	69	+
	70	+ /**
	71	+ * Retrieve cookies associated with given URI, or whose domain matches the
	72	+ * given URI. Only cookies that have not expired are returned.
	73	+ * This is called for every outgoing HTTP request.
	74	+ *
	75	+ * @return an immutable list of HttpCookie,
	76	+ * return empty list if no cookies match the given URI
	77	+ *
	78	+ * @throws NullPointerException if <tt>uri</tt> is <tt>null</tt>
	79	+ *
	80	+ * @see #add
	81	+ *
	82	+ */
	83	+ public List<HttpCookie> get(URI uri);
	84	+
	85	+
	86	+ /**
	87	+ * Get all not-expired cookies in cookie store.
	88	+ *
	89	+ * @return an immutable list of http cookies;
	90	+ * return empty list if there's no http cookie in store
	91	+ */
	92	+ public List<HttpCookie> getCookies();
	93	+
	94	+
	95	+ /**
	96	+ * Get all URIs which identify the cookies in this cookie store.
	97	+ *
	98	+ * @return an immutable list of URIs;
	99	+ * return empty list if no cookie in this cookie store
	100	+ * is associated with an URI
	101	+ */
	102	+ public List<URI> getURIs();
	103	+
	104	+
	105	+ /**
	106	+ * Remove a cookie from store.
	107	+ *
	108	+ * @param uri the uri this cookie associated with.
	109	+ * if <tt>null</tt>, the cookie to be removed is not associated
	110	+ * with an URI when added; if not <tt>null</tt>, the cookie
	111	+ * to be removed is associated with the given URI when added.
	112	+ * @param cookie the cookie to remove
	113	+ *
	114	+ * @return <tt>true</tt> if this store contained the specified cookie
	115	+ *
	116	+ * @throws NullPointerException if <tt>cookie</tt> is <tt>null</tt>
	117	+ */
	118	+ public boolean remove(URI uri, HttpCookie cookie);
	119	+
	120	+
	121	+ /**
	122	+ * Remove all cookies in this cookie store.
	123	+ *
	124	+ * @return <tt>true</tt> if this store changed as a result of the call
	125	+ */
	126	+ public boolean removeAll();
	127	+}

java/pkg/java/net/DatagramPacket.class+0−0

Binary file not shown.

java/pkg/java/net/DatagramPacket.java+385−0

@@ -0,0 +1,385 @@
	1	+/*
	2	+ * Copyright (c) 1995, 2006, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+/**
	29	+ * This class represents a datagram packet.
	30	+ * <p>
	31	+ * Datagram packets are used to implement a connectionless packet
	32	+ * delivery service. Each message is routed from one machine to
	33	+ * another based solely on information contained within that packet.
	34	+ * Multiple packets sent from one machine to another might be routed
	35	+ * differently, and might arrive in any order. Packet delivery is
	36	+ * not guaranteed.
	37	+ *
	38	+ * @author Pavani Diwanji
	39	+ * @author Benjamin Renaud
	40	+ * @since JDK1.0
	41	+ */
	42	+public final
	43	+class DatagramPacket {
	44	+
	45	+ /**
	46	+ * Perform class initialization
	47	+ */
	48	+ static {
	49	+ java.security.AccessController.doPrivileged(
	50	+ new sun.security.action.LoadLibraryAction("net"));
	51	+ init();
	52	+ }
	53	+
	54	+ /*
	55	+ * The fields of this class are package-private since DatagramSocketImpl
	56	+ * classes needs to access them.
	57	+ */
	58	+ byte[] buf;
	59	+ int offset;
	60	+ int length;
	61	+ int bufLength;
	62	+ InetAddress address;
	63	+ int port;
	64	+
	65	+ /**
	66	+ * Constructs a <code>DatagramPacket</code> for receiving packets of
	67	+ * length <code>length</code>, specifying an offset into the buffer.
	68	+ * <p>
	69	+ * The <code>length</code> argument must be less than or equal to
	70	+ * <code>buf.length</code>.
	71	+ *
	72	+ * @param buf buffer for holding the incoming datagram.
	73	+ * @param offset the offset for the buffer
	74	+ * @param length the number of bytes to read.
	75	+ *
	76	+ * @since 1.2
	77	+ */
	78	+ public DatagramPacket(byte buf[], int offset, int length) {
	79	+ setData(buf, offset, length);
	80	+ this.address = null;
	81	+ this.port = -1;
	82	+ }
	83	+
	84	+ /**
	85	+ * Constructs a <code>DatagramPacket</code> for receiving packets of
	86	+ * length <code>length</code>.
	87	+ * <p>
	88	+ * The <code>length</code> argument must be less than or equal to
	89	+ * <code>buf.length</code>.
	90	+ *
	91	+ * @param buf buffer for holding the incoming datagram.
	92	+ * @param length the number of bytes to read.
	93	+ */
	94	+ public DatagramPacket(byte buf[], int length) {
	95	+ this (buf, 0, length);
	96	+ }
	97	+
	98	+ /**
	99	+ * Constructs a datagram packet for sending packets of length
	100	+ * <code>length</code> with offset <code>ioffset</code>to the
	101	+ * specified port number on the specified host. The
	102	+ * <code>length</code> argument must be less than or equal to
	103	+ * <code>buf.length</code>.
	104	+ *
	105	+ * @param buf the packet data.
	106	+ * @param offset the packet data offset.
	107	+ * @param length the packet data length.
	108	+ * @param address the destination address.
	109	+ * @param port the destination port number.
	110	+ * @see java.net.InetAddress
	111	+ *
	112	+ * @since 1.2
	113	+ */
	114	+ public DatagramPacket(byte buf[], int offset, int length,
	115	+ InetAddress address, int port) {
	116	+ setData(buf, offset, length);
	117	+ setAddress(address);
	118	+ setPort(port);
	119	+ }
	120	+
	121	+ /**
	122	+ * Constructs a datagram packet for sending packets of length
	123	+ * <code>length</code> with offset <code>ioffset</code>to the
	124	+ * specified port number on the specified host. The
	125	+ * <code>length</code> argument must be less than or equal to
	126	+ * <code>buf.length</code>.
	127	+ *
	128	+ * @param buf the packet data.
	129	+ * @param offset the packet data offset.
	130	+ * @param length the packet data length.
	131	+ * @param address the destination socket address.
	132	+ * @throws IllegalArgumentException if address type is not supported
	133	+ * @see java.net.InetAddress
	134	+ *
	135	+ * @since 1.4
	136	+ */
	137	+ public DatagramPacket(byte buf[], int offset, int length,
	138	+ SocketAddress address) throws SocketException {
	139	+ setData(buf, offset, length);
	140	+ setSocketAddress(address);
	141	+ }
	142	+
	143	+ /**
	144	+ * Constructs a datagram packet for sending packets of length
	145	+ * <code>length</code> to the specified port number on the specified
	146	+ * host. The <code>length</code> argument must be less than or equal
	147	+ * to <code>buf.length</code>.
	148	+ *
	149	+ * @param buf the packet data.
	150	+ * @param length the packet length.
	151	+ * @param address the destination address.
	152	+ * @param port the destination port number.
	153	+ * @see java.net.InetAddress
	154	+ */
	155	+ public DatagramPacket(byte buf[], int length,
	156	+ InetAddress address, int port) {
	157	+ this(buf, 0, length, address, port);
	158	+ }
	159	+
	160	+ /**
	161	+ * Constructs a datagram packet for sending packets of length
	162	+ * <code>length</code> to the specified port number on the specified
	163	+ * host. The <code>length</code> argument must be less than or equal
	164	+ * to <code>buf.length</code>.
	165	+ *
	166	+ * @param buf the packet data.
	167	+ * @param length the packet length.
	168	+ * @param address the destination address.
	169	+ * @throws IllegalArgumentException if address type is not supported
	170	+ * @since 1.4
	171	+ * @see java.net.InetAddress
	172	+ */
	173	+ public DatagramPacket(byte buf[], int length,
	174	+ SocketAddress address) throws SocketException {
	175	+ this(buf, 0, length, address);
	176	+ }
	177	+
	178	+ /**
	179	+ * Returns the IP address of the machine to which this datagram is being
	180	+ * sent or from which the datagram was received.
	181	+ *
	182	+ * @return the IP address of the machine to which this datagram is being
	183	+ * sent or from which the datagram was received.
	184	+ * @see java.net.InetAddress
	185	+ * @see #setAddress(java.net.InetAddress)
	186	+ */
	187	+ public synchronized InetAddress getAddress() {
	188	+ return address;
	189	+ }
	190	+
	191	+ /**
	192	+ * Returns the port number on the remote host to which this datagram is
	193	+ * being sent or from which the datagram was received.
	194	+ *
	195	+ * @return the port number on the remote host to which this datagram is
	196	+ * being sent or from which the datagram was received.
	197	+ * @see #setPort(int)
	198	+ */
	199	+ public synchronized int getPort() {
	200	+ return port;
	201	+ }
	202	+
	203	+ /**
	204	+ * Returns the data buffer. The data received or the data to be sent
	205	+ * starts from the <code>offset</code> in the buffer,
	206	+ * and runs for <code>length</code> long.
	207	+ *
	208	+ * @return the buffer used to receive or send data
	209	+ * @see #setData(byte[], int, int)
	210	+ */
	211	+ public synchronized byte[] getData() {
	212	+ return buf;
	213	+ }
	214	+
	215	+ /**
	216	+ * Returns the offset of the data to be sent or the offset of the
	217	+ * data received.
	218	+ *
	219	+ * @return the offset of the data to be sent or the offset of the
	220	+ * data received.
	221	+ *
	222	+ * @since 1.2
	223	+ */
	224	+ public synchronized int getOffset() {
	225	+ return offset;
	226	+ }
	227	+
	228	+ /**
	229	+ * Returns the length of the data to be sent or the length of the
	230	+ * data received.
	231	+ *
	232	+ * @return the length of the data to be sent or the length of the
	233	+ * data received.
	234	+ * @see #setLength(int)
	235	+ */
	236	+ public synchronized int getLength() {
	237	+ return length;
	238	+ }
	239	+
	240	+ /**
	241	+ * Set the data buffer for this packet. This sets the
	242	+ * data, length and offset of the packet.
	243	+ *
	244	+ * @param buf the buffer to set for this packet
	245	+ *
	246	+ * @param offset the offset into the data
	247	+ *
	248	+ * @param length the length of the data
	249	+ * and/or the length of the buffer used to receive data
	250	+ *
	251	+ * @exception NullPointerException if the argument is null
	252	+ *
	253	+ * @see #getData
	254	+ * @see #getOffset
	255	+ * @see #getLength
	256	+ *
	257	+ * @since 1.2
	258	+ */
	259	+ public synchronized void setData(byte[] buf, int offset, int length) {
	260	+ /* this will check to see if buf is null */
	261	+ if (length < 0 \|\| offset < 0 \|\|
	262	+ (length + offset) < 0 \|\|
	263	+ ((length + offset) > buf.length)) {
	264	+ throw new IllegalArgumentException("illegal length or offset");
	265	+ }
	266	+ this.buf = buf;
	267	+ this.length = length;
	268	+ this.bufLength = length;
	269	+ this.offset = offset;
	270	+ }
	271	+
	272	+ /**
	273	+ * Sets the IP address of the machine to which this datagram
	274	+ * is being sent.
	275	+ * @param iaddr the <code>InetAddress</code>
	276	+ * @since JDK1.1
	277	+ * @see #getAddress()
	278	+ */
	279	+ public synchronized void setAddress(InetAddress iaddr) {
	280	+ address = iaddr;
	281	+ }
	282	+
	283	+ /**
	284	+ * Sets the port number on the remote host to which this datagram
	285	+ * is being sent.
	286	+ * @param iport the port number
	287	+ * @since JDK1.1
	288	+ * @see #getPort()
	289	+ */
	290	+ public synchronized void setPort(int iport) {
	291	+ if (iport < 0 \|\| iport > 0xFFFF) {
	292	+ throw new IllegalArgumentException("Port out of range:"+ iport);
	293	+ }
	294	+ port = iport;
	295	+ }
	296	+
	297	+ /**
	298	+ * Sets the SocketAddress (usually IP address + port number) of the remote
	299	+ * host to which this datagram is being sent.
	300	+ *
	301	+ * @param address the <code>SocketAddress</code>
	302	+ * @throws IllegalArgumentException if address is null or is a
	303	+ * SocketAddress subclass not supported by this socket
	304	+ *
	305	+ * @since 1.4
	306	+ * @see #getSocketAddress
	307	+ */
	308	+ public synchronized void setSocketAddress(SocketAddress address) {
	309	+ if (address == null \|\| !(address instanceof InetSocketAddress))
	310	+ throw new IllegalArgumentException("unsupported address type");
	311	+ InetSocketAddress addr = (InetSocketAddress) address;
	312	+ if (addr.isUnresolved())
	313	+ throw new IllegalArgumentException("unresolved address");
	314	+ setAddress(addr.getAddress());
	315	+ setPort(addr.getPort());
	316	+ }
	317	+
	318	+ /**
	319	+ * Gets the SocketAddress (usually IP address + port number) of the remote
	320	+ * host that this packet is being sent to or is coming from.
	321	+ *
	322	+ * @return the <code>SocketAddress</code>
	323	+ * @since 1.4
	324	+ * @see #setSocketAddress
	325	+ */
	326	+ public synchronized SocketAddress getSocketAddress() {
	327	+ return new InetSocketAddress(getAddress(), getPort());
	328	+ }
	329	+
	330	+ /**
	331	+ * Set the data buffer for this packet. With the offset of
	332	+ * this DatagramPacket set to 0, and the length set to
	333	+ * the length of <code>buf</code>.
	334	+ *
	335	+ * @param buf the buffer to set for this packet.
	336	+ *
	337	+ * @exception NullPointerException if the argument is null.
	338	+ *
	339	+ * @see #getLength
	340	+ * @see #getData
	341	+ *
	342	+ * @since JDK1.1
	343	+ */
	344	+ public synchronized void setData(byte[] buf) {
	345	+ if (buf == null) {
	346	+ throw new NullPointerException("null packet buffer");
	347	+ }
	348	+ this.buf = buf;
	349	+ this.offset = 0;
	350	+ this.length = buf.length;
	351	+ this.bufLength = buf.length;
	352	+ }
	353	+
	354	+ /**
	355	+ * Set the length for this packet. The length of the packet is
	356	+ * the number of bytes from the packet's data buffer that will be
	357	+ * sent, or the number of bytes of the packet's data buffer that
	358	+ * will be used for receiving data. The length must be lesser or
	359	+ * equal to the offset plus the length of the packet's buffer.
	360	+ *
	361	+ * @param length the length to set for this packet.
	362	+ *
	363	+ * @exception IllegalArgumentException if the length is negative
	364	+ * of if the length is greater than the packet's data buffer
	365	+ * length.
	366	+ *
	367	+ * @see #getLength
	368	+ * @see #setData
	369	+ *
	370	+ * @since JDK1.1
	371	+ */
	372	+ public synchronized void setLength(int length) {
	373	+ if ((length + offset) > buf.length \|\| length < 0 \|\|
	374	+ (length + offset) < 0) {
	375	+ throw new IllegalArgumentException("illegal length");
	376	+ }
	377	+ this.length = length;
	378	+ this.bufLength = this.length;
	379	+ }
	380	+
	381	+ /**
	382	+ * Perform class load-time initializations.
	383	+ */
	384	+ private native static void init();
	385	+}

java/pkg/java/net/DatagramSocket$1.class+0−0

Binary file not shown.

java/pkg/java/net/DatagramSocket.class+0−0

Binary file not shown.

java/pkg/java/net/DatagramSocket.java+1257−0

@@ -0,0 +1,1257 @@
	1	+/*
	2	+ * Copyright (c) 1995, 2010, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.io.FileDescriptor;
	29	+import java.io.IOException;
	30	+import java.io.InterruptedIOException;
	31	+import java.nio.channels.DatagramChannel;
	32	+import java.security.AccessController;
	33	+import java.security.PrivilegedExceptionAction;
	34	+
	35	+/**
	36	+ * This class represents a socket for sending and receiving datagram packets.
	37	+ *
	38	+ * <p>A datagram socket is the sending or receiving point for a packet
	39	+ * delivery service. Each packet sent or received on a datagram socket
	40	+ * is individually addressed and routed. Multiple packets sent from
	41	+ * one machine to another may be routed differently, and may arrive in
	42	+ * any order.
	43	+ *
	44	+ * <p> Where possible, a newly constructed {@code DatagramSocket} has the
	45	+ * {@link SocketOptions#SO_BROADCAST SO_BROADCAST} socket option enabled so as
	46	+ * to allow the transmission of broadcast datagrams. In order to receive
	47	+ * broadcast packets a DatagramSocket should be bound to the wildcard address.
	48	+ * In some implementations, broadcast packets may also be received when
	49	+ * a DatagramSocket is bound to a more specific address.
	50	+ * <p>
	51	+ * Example:
	52	+ * <code>
	53	+ * DatagramSocket s = new DatagramSocket(null);
	54	+ * s.bind(new InetSocketAddress(8888));
	55	+ * </code>
	56	+ * Which is equivalent to:
	57	+ * <code>
	58	+ * DatagramSocket s = new DatagramSocket(8888);
	59	+ * </code>
	60	+ * Both cases will create a DatagramSocket able to receive broadcasts on
	61	+ * UDP port 8888.
	62	+ *
	63	+ * @author Pavani Diwanji
	64	+ * @see java.net.DatagramPacket
	65	+ * @see java.nio.channels.DatagramChannel
	66	+ * @since JDK1.0
	67	+ */
	68	+public
	69	+class DatagramSocket implements java.io.Closeable {
	70	+ /**
	71	+ * Various states of this socket.
	72	+ */
	73	+ private boolean created = false;
	74	+ private boolean bound = false;
	75	+ private boolean closed = false;
	76	+ private Object closeLock = new Object();
	77	+
	78	+ /*
	79	+ * The implementation of this DatagramSocket.
	80	+ */
	81	+ DatagramSocketImpl impl;
	82	+
	83	+ /**
	84	+ * Are we using an older DatagramSocketImpl?
	85	+ */
	86	+ boolean oldImpl = false;
	87	+
	88	+ /*
	89	+ * Connection state:
	90	+ * ST_NOT_CONNECTED = socket not connected
	91	+ * ST_CONNECTED = socket connected
	92	+ * ST_CONNECTED_NO_IMPL = socket connected but not at impl level
	93	+ */
	94	+ static final int ST_NOT_CONNECTED = 0;
	95	+ static final int ST_CONNECTED = 1;
	96	+ static final int ST_CONNECTED_NO_IMPL = 2;
	97	+
	98	+ int connectState = ST_NOT_CONNECTED;
	99	+
	100	+ /*
	101	+ * Connected address & port
	102	+ */
	103	+ InetAddress connectedAddress = null;
	104	+ int connectedPort = -1;
	105	+
	106	+ /**
	107	+ * Connects this socket to a remote socket address (IP address + port number).
	108	+ * Binds socket if not already bound.
	109	+ * <p>
	110	+ * @param addr The remote address.
	111	+ * @param port The remote port
	112	+ * @throws SocketException if binding the socket fails.
	113	+ */
	114	+ private synchronized void connectInternal(InetAddress address, int port) throws SocketException {
	115	+ if (port < 0 \|\| port > 0xFFFF) {
	116	+ throw new IllegalArgumentException("connect: " + port);
	117	+ }
	118	+ if (address == null) {
	119	+ throw new IllegalArgumentException("connect: null address");
	120	+ }
	121	+ checkAddress (address, "connect");
	122	+ if (isClosed())
	123	+ return;
	124	+ SecurityManager security = System.getSecurityManager();
	125	+ if (security != null) {
	126	+ if (address.isMulticastAddress()) {
	127	+ security.checkMulticast(address);
	128	+ } else {
	129	+ security.checkConnect(address.getHostAddress(), port);
	130	+ security.checkAccept(address.getHostAddress(), port);
	131	+ }
	132	+ }
	133	+
	134	+ if (!isBound())
	135	+ bind(new InetSocketAddress(0));
	136	+
	137	+ // old impls do not support connect/disconnect
	138	+ if (oldImpl) {
	139	+ connectState = ST_CONNECTED_NO_IMPL;
	140	+ } else {
	141	+ try {
	142	+ getImpl().connect(address, port);
	143	+
	144	+ // socket is now connected by the impl
	145	+ connectState = ST_CONNECTED;
	146	+ } catch (SocketException se) {
	147	+
	148	+ // connection will be emulated by DatagramSocket
	149	+ connectState = ST_CONNECTED_NO_IMPL;
	150	+ }
	151	+ }
	152	+
	153	+ connectedAddress = address;
	154	+ connectedPort = port;
	155	+ }
	156	+
	157	+
	158	+ /**
	159	+ * Constructs a datagram socket and binds it to any available port
	160	+ * on the local host machine. The socket will be bound to the
	161	+ * {@link InetAddress#isAnyLocalAddress wildcard} address,
	162	+ * an IP address chosen by the kernel.
	163	+ *
	164	+ * <p>If there is a security manager,
	165	+ * its <code>checkListen</code> method is first called
	166	+ * with 0 as its argument to ensure the operation is allowed.
	167	+ * This could result in a SecurityException.
	168	+ *
	169	+ * @exception SocketException if the socket could not be opened,
	170	+ * or the socket could not bind to the specified local port.
	171	+ * @exception SecurityException if a security manager exists and its
	172	+ * <code>checkListen</code> method doesn't allow the operation.
	173	+ *
	174	+ * @see SecurityManager#checkListen
	175	+ */
	176	+ public DatagramSocket() throws SocketException {
	177	+ // create a datagram socket.
	178	+ createImpl();
	179	+ try {
	180	+ bind(new InetSocketAddress(0));
	181	+ } catch (SocketException se) {
	182	+ throw se;
	183	+ } catch(IOException e) {
	184	+ throw new SocketException(e.getMessage());
	185	+ }
	186	+ }
	187	+
	188	+ /**
	189	+ * Creates an unbound datagram socket with the specified
	190	+ * DatagramSocketImpl.
	191	+ *
	192	+ * @param impl an instance of a <B>DatagramSocketImpl</B>
	193	+ * the subclass wishes to use on the DatagramSocket.
	194	+ * @since 1.4
	195	+ */
	196	+ protected DatagramSocket(DatagramSocketImpl impl) {
	197	+ if (impl == null)
	198	+ throw new NullPointerException();
	199	+ this.impl = impl;
	200	+ checkOldImpl();
	201	+ }
	202	+
	203	+ /**
	204	+ * Creates a datagram socket, bound to the specified local
	205	+ * socket address.
	206	+ * <p>
	207	+ * If, if the address is <code>null</code>, creates an unbound socket.
	208	+ * <p>
	209	+ * <p>If there is a security manager,
	210	+ * its <code>checkListen</code> method is first called
	211	+ * with the port from the socket address
	212	+ * as its argument to ensure the operation is allowed.
	213	+ * This could result in a SecurityException.
	214	+ *
	215	+ * @param bindaddr local socket address to bind, or <code>null</code>
	216	+ * for an unbound socket.
	217	+ *
	218	+ * @exception SocketException if the socket could not be opened,
	219	+ * or the socket could not bind to the specified local port.
	220	+ * @exception SecurityException if a security manager exists and its
	221	+ * <code>checkListen</code> method doesn't allow the operation.
	222	+ *
	223	+ * @see SecurityManager#checkListen
	224	+ * @since 1.4
	225	+ */
	226	+ public DatagramSocket(SocketAddress bindaddr) throws SocketException {
	227	+ // create a datagram socket.
	228	+ createImpl();
	229	+ if (bindaddr != null) {
	230	+ bind(bindaddr);
	231	+ }
	232	+ }
	233	+
	234	+ /**
	235	+ * Constructs a datagram socket and binds it to the specified port
	236	+ * on the local host machine. The socket will be bound to the
	237	+ * {@link InetAddress#isAnyLocalAddress wildcard} address,
	238	+ * an IP address chosen by the kernel.
	239	+ *
	240	+ * <p>If there is a security manager,
	241	+ * its <code>checkListen</code> method is first called
	242	+ * with the <code>port</code> argument
	243	+ * as its argument to ensure the operation is allowed.
	244	+ * This could result in a SecurityException.
	245	+ *
	246	+ * @param port port to use.
	247	+ * @exception SocketException if the socket could not be opened,
	248	+ * or the socket could not bind to the specified local port.
	249	+ * @exception SecurityException if a security manager exists and its
	250	+ * <code>checkListen</code> method doesn't allow the operation.
	251	+ *
	252	+ * @see SecurityManager#checkListen
	253	+ */
	254	+ public DatagramSocket(int port) throws SocketException {
	255	+ this(port, null);
	256	+ }
	257	+
	258	+ /**
	259	+ * Creates a datagram socket, bound to the specified local
	260	+ * address. The local port must be between 0 and 65535 inclusive.
	261	+ * If the IP address is 0.0.0.0, the socket will be bound to the
	262	+ * {@link InetAddress#isAnyLocalAddress wildcard} address,
	263	+ * an IP address chosen by the kernel.
	264	+ *
	265	+ * <p>If there is a security manager,
	266	+ * its <code>checkListen</code> method is first called
	267	+ * with the <code>port</code> argument
	268	+ * as its argument to ensure the operation is allowed.
	269	+ * This could result in a SecurityException.
	270	+ *
	271	+ * @param port local port to use
	272	+ * @param laddr local address to bind
	273	+ *
	274	+ * @exception SocketException if the socket could not be opened,
	275	+ * or the socket could not bind to the specified local port.
	276	+ * @exception SecurityException if a security manager exists and its
	277	+ * <code>checkListen</code> method doesn't allow the operation.
	278	+ *
	279	+ * @see SecurityManager#checkListen
	280	+ * @since JDK1.1
	281	+ */
	282	+ public DatagramSocket(int port, InetAddress laddr) throws SocketException {
	283	+ this(new InetSocketAddress(laddr, port));
	284	+ }
	285	+
	286	+ private void checkOldImpl() {
	287	+ if (impl == null)
	288	+ return;
	289	+ // DatagramSocketImpl.peekdata() is a protected method, therefore we need to use
	290	+ // getDeclaredMethod, therefore we need permission to access the member
	291	+ try {
	292	+ AccessController.doPrivileged(
	293	+ new PrivilegedExceptionAction<Void>() {
	294	+ public Void run() throws NoSuchMethodException {
	295	+ Class[] cl = new Class[1];
	296	+ cl[0] = DatagramPacket.class;
	297	+ impl.getClass().getDeclaredMethod("peekData", cl);
	298	+ return null;
	299	+ }
	300	+ });
	301	+ } catch (java.security.PrivilegedActionException e) {
	302	+ oldImpl = true;
	303	+ }
	304	+ }
	305	+
	306	+ static Class implClass = null;
	307	+
	308	+ void createImpl() throws SocketException {
	309	+ if (impl == null) {
	310	+ if (factory != null) {
	311	+ impl = factory.createDatagramSocketImpl();
	312	+ checkOldImpl();
	313	+ } else {
	314	+ boolean isMulticast = (this instanceof MulticastSocket) ? true : false;
	315	+ impl = DefaultDatagramSocketImplFactory.createDatagramSocketImpl(isMulticast);
	316	+
	317	+ checkOldImpl();
	318	+ }
	319	+ }
	320	+ // creates a udp socket
	321	+ impl.create();
	322	+ created = true;
	323	+ }
	324	+
	325	+ /**
	326	+ * Get the <code>DatagramSocketImpl</code> attached to this socket,
	327	+ * creating it if necessary.
	328	+ *
	329	+ * @return the <code>DatagramSocketImpl</code> attached to that
	330	+ * DatagramSocket
	331	+ * @throws SocketException if creation fails.
	332	+ * @since 1.4
	333	+ */
	334	+ DatagramSocketImpl getImpl() throws SocketException {
	335	+ if (!created)
	336	+ createImpl();
	337	+ return impl;
	338	+ }
	339	+
	340	+ /**
	341	+ * Binds this DatagramSocket to a specific address & port.
	342	+ * <p>
	343	+ * If the address is <code>null</code>, then the system will pick up
	344	+ * an ephemeral port and a valid local address to bind the socket.
	345	+ *<p>
	346	+ * @param addr The address & port to bind to.
	347	+ * @throws SocketException if any error happens during the bind, or if the
	348	+ * socket is already bound.
	349	+ * @throws SecurityException if a security manager exists and its
	350	+ * <code>checkListen</code> method doesn't allow the operation.
	351	+ * @throws IllegalArgumentException if addr is a SocketAddress subclass
	352	+ * not supported by this socket.
	353	+ * @since 1.4
	354	+ */
	355	+ public synchronized void bind(SocketAddress addr) throws SocketException {
	356	+ if (isClosed())
	357	+ throw new SocketException("Socket is closed");
	358	+ if (isBound())
	359	+ throw new SocketException("already bound");
	360	+ if (addr == null)
	361	+ addr = new InetSocketAddress(0);
	362	+ if (!(addr instanceof InetSocketAddress))
	363	+ throw new IllegalArgumentException("Unsupported address type!");
	364	+ InetSocketAddress epoint = (InetSocketAddress) addr;
	365	+ if (epoint.isUnresolved())
	366	+ throw new SocketException("Unresolved address");
	367	+ InetAddress iaddr = epoint.getAddress();
	368	+ int port = epoint.getPort();
	369	+ checkAddress(iaddr, "bind");
	370	+ SecurityManager sec = System.getSecurityManager();
	371	+ if (sec != null) {
	372	+ sec.checkListen(port);
	373	+ }
	374	+ try {
	375	+ getImpl().bind(port, iaddr);
	376	+ } catch (SocketException e) {
	377	+ getImpl().close();
	378	+ throw e;
	379	+ }
	380	+ bound = true;
	381	+ }
	382	+
	383	+ void checkAddress (InetAddress addr, String op) {
	384	+ if (addr == null) {
	385	+ return;
	386	+ }
	387	+ if (!(addr instanceof Inet4Address \|\| addr instanceof Inet6Address)) {
	388	+ throw new IllegalArgumentException(op + ": invalid address type");
	389	+ }
	390	+ }
	391	+
	392	+ /**
	393	+ * Connects the socket to a remote address for this socket. When a
	394	+ * socket is connected to a remote address, packets may only be
	395	+ * sent to or received from that address. By default a datagram
	396	+ * socket is not connected.
	397	+ *
	398	+ * <p>If the remote destination to which the socket is connected does not
	399	+ * exist, or is otherwise unreachable, and if an ICMP destination unreachable
	400	+ * packet has been received for that address, then a subsequent call to
	401	+ * send or receive may throw a PortUnreachableException. Note, there is no
	402	+ * guarantee that the exception will be thrown.
	403	+ *
	404	+ * <p> If a security manager has been installed then it is invoked to check
	405	+ * access to the remote address. Specifically, if the given {@code address}
	406	+ * is a {@link InetAddress#isMulticastAddress multicast address},
	407	+ * the security manager's {@link
	408	+ * java.lang.SecurityManager#checkMulticast(InetAddress)
	409	+ * checkMulticast} method is invoked with the given {@code address}.
	410	+ * Otherwise, the security manager's {@link
	411	+ * java.lang.SecurityManager#checkConnect(String,int) checkConnect}
	412	+ * and {@link java.lang.SecurityManager#checkAccept checkAccept} methods
	413	+ * are invoked, with the given {@code address} and {@code port}, to
	414	+ * verify that datagrams are permitted to be sent and received
	415	+ * respectively.
	416	+ *
	417	+ * <p> When a socket is connected, {@link #receive receive} and
	418	+ * {@link #send send} <b>will not perform any security checks</b>
	419	+ * on incoming and outgoing packets, other than matching the packet's
	420	+ * and the socket's address and port. On a send operation, if the
	421	+ * packet's address is set and the packet's address and the socket's
	422	+ * address do not match, an {@code IllegalArgumentException} will be
	423	+ * thrown. A socket connected to a multicast address may only be used
	424	+ * to send packets.
	425	+ *
	426	+ * @param address the remote address for the socket
	427	+ *
	428	+ * @param port the remote port for the socket.
	429	+ *
	430	+ * @throws IllegalArgumentException
	431	+ * if the address is null, or the port is out of range.
	432	+ *
	433	+ * @throws SecurityException
	434	+ * if a security manager has been installed and it does
	435	+ * not permit access to the given remote address
	436	+ *
	437	+ * @see #disconnect
	438	+ */
	439	+ public void connect(InetAddress address, int port) {
	440	+ try {
	441	+ connectInternal(address, port);
	442	+ } catch (SocketException se) {
	443	+ throw new Error("connect failed", se);
	444	+ }
	445	+ }
	446	+
	447	+ /**
	448	+ * Connects this socket to a remote socket address (IP address + port number).
	449	+ *
	450	+ * <p> If given an {@link InetSocketAddress InetSocketAddress}, this method
	451	+ * behaves as if invoking {@link #connect(InetAddress,int) connect(InetAddress,int)}
	452	+ * with the the given socket addresses IP address and port number.
	453	+ *
	454	+ * @param addr The remote address.
	455	+ *
	456	+ * @throws SocketException
	457	+ * if the connect fails
	458	+ *
	459	+ * @throws IllegalArgumentException
	460	+ * if {@code addr} is {@code null}, or {@code addr} is a SocketAddress
	461	+ * subclass not supported by this socket
	462	+ *
	463	+ * @throws SecurityException
	464	+ * if a security manager has been installed and it does
	465	+ * not permit access to the given remote address
	466	+ *
	467	+ * @since 1.4
	468	+ */
	469	+ public void connect(SocketAddress addr) throws SocketException {
	470	+ if (addr == null)
	471	+ throw new IllegalArgumentException("Address can't be null");
	472	+ if (!(addr instanceof InetSocketAddress))
	473	+ throw new IllegalArgumentException("Unsupported address type");
	474	+ InetSocketAddress epoint = (InetSocketAddress) addr;
	475	+ if (epoint.isUnresolved())
	476	+ throw new SocketException("Unresolved address");
	477	+ connectInternal(epoint.getAddress(), epoint.getPort());
	478	+ }
	479	+
	480	+ /**
	481	+ * Disconnects the socket. If the socket is closed or not connected,
	482	+ * then this method has no effect.
	483	+ *
	484	+ * @see #connect
	485	+ */
	486	+ public void disconnect() {
	487	+ synchronized (this) {
	488	+ if (isClosed())
	489	+ return;
	490	+ if (connectState == ST_CONNECTED) {
	491	+ impl.disconnect ();
	492	+ }
	493	+ connectedAddress = null;
	494	+ connectedPort = -1;
	495	+ connectState = ST_NOT_CONNECTED;
	496	+ }
	497	+ }
	498	+
	499	+ /**
	500	+ * Returns the binding state of the socket.
	501	+ * <p>
	502	+ * If the socket was bound prior to being {@link #close closed},
	503	+ * then this method will continue to return <code>true</code>
	504	+ * after the socket is closed.
	505	+ *
	506	+ * @return true if the socket successfully bound to an address
	507	+ * @since 1.4
	508	+ */
	509	+ public boolean isBound() {
	510	+ return bound;
	511	+ }
	512	+
	513	+ /**
	514	+ * Returns the connection state of the socket.
	515	+ * <p>
	516	+ * If the socket was connected prior to being {@link #close closed},
	517	+ * then this method will continue to return <code>true</code>
	518	+ * after the socket is closed.
	519	+ *
	520	+ * @return true if the socket successfully connected to a server
	521	+ * @since 1.4
	522	+ */
	523	+ public boolean isConnected() {
	524	+ return connectState != ST_NOT_CONNECTED;
	525	+ }
	526	+
	527	+ /**
	528	+ * Returns the address to which this socket is connected. Returns
	529	+ * <code>null</code> if the socket is not connected.
	530	+ * <p>
	531	+ * If the socket was connected prior to being {@link #close closed},
	532	+ * then this method will continue to return the connected address
	533	+ * after the socket is closed.
	534	+ *
	535	+ * @return the address to which this socket is connected.
	536	+ */
	537	+ public InetAddress getInetAddress() {
	538	+ return connectedAddress;
	539	+ }
	540	+
	541	+ /**
	542	+ * Returns the port number to which this socket is connected.
	543	+ * Returns <code>-1</code> if the socket is not connected.
	544	+ * <p>
	545	+ * If the socket was connected prior to being {@link #close closed},
	546	+ * then this method will continue to return the connected port number
	547	+ * after the socket is closed.
	548	+ *
	549	+ * @return the port number to which this socket is connected.
	550	+ */
	551	+ public int getPort() {
	552	+ return connectedPort;
	553	+ }
	554	+
	555	+ /**
	556	+ * Returns the address of the endpoint this socket is connected to, or
	557	+ * <code>null</code> if it is unconnected.
	558	+ * <p>
	559	+ * If the socket was connected prior to being {@link #close closed},
	560	+ * then this method will continue to return the connected address
	561	+ * after the socket is closed.
	562	+ *
	563	+ * @return a <code>SocketAddress</code> representing the remote
	564	+ * endpoint of this socket, or <code>null</code> if it is
	565	+ * not connected yet.
	566	+ * @see #getInetAddress()
	567	+ * @see #getPort()
	568	+ * @see #connect(SocketAddress)
	569	+ * @since 1.4
	570	+ */
	571	+ public SocketAddress getRemoteSocketAddress() {
	572	+ if (!isConnected())
	573	+ return null;
	574	+ return new InetSocketAddress(getInetAddress(), getPort());
	575	+ }
	576	+
	577	+ /**
	578	+ * Returns the address of the endpoint this socket is bound to.
	579	+ *
	580	+ * @return a <code>SocketAddress</code> representing the local endpoint of this
	581	+ * socket, or <code>null</code> if it is closed or not bound yet.
	582	+ * @see #getLocalAddress()
	583	+ * @see #getLocalPort()
	584	+ * @see #bind(SocketAddress)
	585	+ * @since 1.4
	586	+ */
	587	+
	588	+ public SocketAddress getLocalSocketAddress() {
	589	+ if (isClosed())
	590	+ return null;
	591	+ if (!isBound())
	592	+ return null;
	593	+ return new InetSocketAddress(getLocalAddress(), getLocalPort());
	594	+ }
	595	+
	596	+ /**
	597	+ * Sends a datagram packet from this socket. The
	598	+ * <code>DatagramPacket</code> includes information indicating the
	599	+ * data to be sent, its length, the IP address of the remote host,
	600	+ * and the port number on the remote host.
	601	+ *
	602	+ * <p>If there is a security manager, and the socket is not currently
	603	+ * connected to a remote address, this method first performs some
	604	+ * security checks. First, if <code>p.getAddress().isMulticastAddress()</code>
	605	+ * is true, this method calls the
	606	+ * security manager's <code>checkMulticast</code> method
	607	+ * with <code>p.getAddress()</code> as its argument.
	608	+ * If the evaluation of that expression is false,
	609	+ * this method instead calls the security manager's
	610	+ * <code>checkConnect</code> method with arguments
	611	+ * <code>p.getAddress().getHostAddress()</code> and
	612	+ * <code>p.getPort()</code>. Each call to a security manager method
	613	+ * could result in a SecurityException if the operation is not allowed.
	614	+ *
	615	+ * @param p the <code>DatagramPacket</code> to be sent.
	616	+ *
	617	+ * @exception IOException if an I/O error occurs.
	618	+ * @exception SecurityException if a security manager exists and its
	619	+ * <code>checkMulticast</code> or <code>checkConnect</code>
	620	+ * method doesn't allow the send.
	621	+ * @exception PortUnreachableException may be thrown if the socket is connected
	622	+ * to a currently unreachable destination. Note, there is no
	623	+ * guarantee that the exception will be thrown.
	624	+ * @exception java.nio.channels.IllegalBlockingModeException
	625	+ * if this socket has an associated channel,
	626	+ * and the channel is in non-blocking mode.
	627	+ * @exception IllegalArgumentException if the socket is connected,
	628	+ * and connected address and packet address differ.
	629	+ *
	630	+ * @see java.net.DatagramPacket
	631	+ * @see SecurityManager#checkMulticast(InetAddress)
	632	+ * @see SecurityManager#checkConnect
	633	+ * @revised 1.4
	634	+ * @spec JSR-51
	635	+ */
	636	+ public void send(DatagramPacket p) throws IOException {
	637	+ InetAddress packetAddress = null;
	638	+ synchronized (p) {
	639	+ if (isClosed())
	640	+ throw new SocketException("Socket is closed");
	641	+ checkAddress (p.getAddress(), "send");
	642	+ if (connectState == ST_NOT_CONNECTED) {
	643	+ // check the address is ok wiht the security manager on every send.
	644	+ SecurityManager security = System.getSecurityManager();
	645	+
	646	+ // The reason you want to synchronize on datagram packet
	647	+ // is because you dont want an applet to change the address
	648	+ // while you are trying to send the packet for example
	649	+ // after the security check but before the send.
	650	+ if (security != null) {
	651	+ if (p.getAddress().isMulticastAddress()) {
	652	+ security.checkMulticast(p.getAddress());
	653	+ } else {
	654	+ security.checkConnect(p.getAddress().getHostAddress(),
	655	+ p.getPort());
	656	+ }
	657	+ }
	658	+ } else {
	659	+ // we're connected
	660	+ packetAddress = p.getAddress();
	661	+ if (packetAddress == null) {
	662	+ p.setAddress(connectedAddress);
	663	+ p.setPort(connectedPort);
	664	+ } else if ((!packetAddress.equals(connectedAddress)) \|\|
	665	+ p.getPort() != connectedPort) {
	666	+ throw new IllegalArgumentException("connected address " +
	667	+ "and packet address" +
	668	+ " differ");
	669	+ }
	670	+ }
	671	+ // Check whether the socket is bound
	672	+ if (!isBound())
	673	+ bind(new InetSocketAddress(0));
	674	+ // call the method to send
	675	+ getImpl().send(p);
	676	+ }
	677	+ }
	678	+
	679	+ /**
	680	+ * Receives a datagram packet from this socket. When this method
	681	+ * returns, the <code>DatagramPacket</code>'s buffer is filled with
	682	+ * the data received. The datagram packet also contains the sender's
	683	+ * IP address, and the port number on the sender's machine.
	684	+ * <p>
	685	+ * This method blocks until a datagram is received. The
	686	+ * <code>length</code> field of the datagram packet object contains
	687	+ * the length of the received message. If the message is longer than
	688	+ * the packet's length, the message is truncated.
	689	+ * <p>
	690	+ * If there is a security manager, a packet cannot be received if the
	691	+ * security manager's <code>checkAccept</code> method
	692	+ * does not allow it.
	693	+ *
	694	+ * @param p the <code>DatagramPacket</code> into which to place
	695	+ * the incoming data.
	696	+ * @exception IOException if an I/O error occurs.
	697	+ * @exception SocketTimeoutException if setSoTimeout was previously called
	698	+ * and the timeout has expired.
	699	+ * @exception PortUnreachableException may be thrown if the socket is connected
	700	+ * to a currently unreachable destination. Note, there is no guarantee that the
	701	+ * exception will be thrown.
	702	+ * @exception java.nio.channels.IllegalBlockingModeException
	703	+ * if this socket has an associated channel,
	704	+ * and the channel is in non-blocking mode.
	705	+ * @see java.net.DatagramPacket
	706	+ * @see java.net.DatagramSocket
	707	+ * @revised 1.4
	708	+ * @spec JSR-51
	709	+ */
	710	+ public synchronized void receive(DatagramPacket p) throws IOException {
	711	+ synchronized (p) {
	712	+ if (!isBound())
	713	+ bind(new InetSocketAddress(0));
	714	+ if (connectState == ST_NOT_CONNECTED) {
	715	+ // check the address is ok with the security manager before every recv.
	716	+ SecurityManager security = System.getSecurityManager();
	717	+ if (security != null) {
	718	+ while(true) {
	719	+ String peekAd = null;
	720	+ int peekPort = 0;
	721	+ // peek at the packet to see who it is from.
	722	+ if (!oldImpl) {
	723	+ // We can use the new peekData() API
	724	+ DatagramPacket peekPacket = new DatagramPacket(new byte[1], 1);
	725	+ peekPort = getImpl().peekData(peekPacket);
	726	+ peekAd = peekPacket.getAddress().getHostAddress();
	727	+ } else {
	728	+ InetAddress adr = new InetAddress();
	729	+ peekPort = getImpl().peek(adr);
	730	+ peekAd = adr.getHostAddress();
	731	+ }
	732	+ try {
	733	+ security.checkAccept(peekAd, peekPort);
	734	+ // security check succeeded - so now break
	735	+ // and recv the packet.
	736	+ break;
	737	+ } catch (SecurityException se) {
	738	+ // Throw away the offending packet by consuming
	739	+ // it in a tmp buffer.
	740	+ DatagramPacket tmp = new DatagramPacket(new byte[1], 1);
	741	+ getImpl().receive(tmp);
	742	+
	743	+ // silently discard the offending packet
	744	+ // and continue: unknown/malicious
	745	+ // entities on nets should not make
	746	+ // runtime throw security exception and
	747	+ // disrupt the applet by sending random
	748	+ // datagram packets.
	749	+ continue;
	750	+ }
	751	+ } // end of while
	752	+ }
	753	+ }
	754	+ if (connectState == ST_CONNECTED_NO_IMPL) {
	755	+ // We have to do the filtering the old fashioned way since
	756	+ // the native impl doesn't support connect or the connect
	757	+ // via the impl failed.
	758	+ boolean stop = false;
	759	+ while (!stop) {
	760	+ // peek at the packet to see who it is from.
	761	+ InetAddress peekAddress = new InetAddress();
	762	+ int peekPort = getImpl().peek(peekAddress);
	763	+ if ((!connectedAddress.equals(peekAddress)) \|\|
	764	+ (connectedPort != peekPort)) {
	765	+ // throw the packet away and silently continue
	766	+ DatagramPacket tmp = new DatagramPacket(new byte[1], 1);
	767	+ getImpl().receive(tmp);
	768	+ } else {
	769	+ stop = true;
	770	+ }
	771	+ }
	772	+ }
	773	+ // If the security check succeeds, or the datagram is
	774	+ // connected then receive the packet
	775	+ getImpl().receive(p);
	776	+ }
	777	+ }
	778	+
	779	+ /**
	780	+ * Gets the local address to which the socket is bound.
	781	+ *
	782	+ * <p>If there is a security manager, its
	783	+ * <code>checkConnect</code> method is first called
	784	+ * with the host address and <code>-1</code>
	785	+ * as its arguments to see if the operation is allowed.
	786	+ *
	787	+ * @see SecurityManager#checkConnect
	788	+ * @return the local address to which the socket is bound,
	789	+ * <code>null</code> if the socket is closed, or
	790	+ * an <code>InetAddress</code> representing
	791	+ * {@link InetAddress#isAnyLocalAddress wildcard}
	792	+ * address if either the socket is not bound, or
	793	+ * the security manager <code>checkConnect</code>
	794	+ * method does not allow the operation
	795	+ * @since 1.1
	796	+ */
	797	+ public InetAddress getLocalAddress() {
	798	+ if (isClosed())
	799	+ return null;
	800	+ InetAddress in = null;
	801	+ try {
	802	+ in = (InetAddress) getImpl().getOption(SocketOptions.SO_BINDADDR);
	803	+ if (in.isAnyLocalAddress()) {
	804	+ in = InetAddress.anyLocalAddress();
	805	+ }
	806	+ SecurityManager s = System.getSecurityManager();
	807	+ if (s != null) {
	808	+ s.checkConnect(in.getHostAddress(), -1);
	809	+ }
	810	+ } catch (Exception e) {
	811	+ in = InetAddress.anyLocalAddress(); // "0.0.0.0"
	812	+ }
	813	+ return in;
	814	+ }
	815	+
	816	+ /**
	817	+ * Returns the port number on the local host to which this socket
	818	+ * is bound.
	819	+ *
	820	+ * @return the port number on the local host to which this socket is bound,
	821	+ <code>-1</code> if the socket is closed, or
	822	+ <code>0</code> if it is not bound yet.
	823	+ */
	824	+ public int getLocalPort() {
	825	+ if (isClosed())
	826	+ return -1;
	827	+ try {
	828	+ return getImpl().getLocalPort();
	829	+ } catch (Exception e) {
	830	+ return 0;
	831	+ }
	832	+ }
	833	+
	834	+ /** Enable/disable SO_TIMEOUT with the specified timeout, in
	835	+ * milliseconds. With this option set to a non-zero timeout,
	836	+ * a call to receive() for this DatagramSocket
	837	+ * will block for only this amount of time. If the timeout expires,
	838	+ * a <B>java.net.SocketTimeoutException</B> is raised, though the
	839	+ * DatagramSocket is still valid. The option <B>must</B> be enabled
	840	+ * prior to entering the blocking operation to have effect. The
	841	+ * timeout must be > 0.
	842	+ * A timeout of zero is interpreted as an infinite timeout.
	843	+ *
	844	+ * @param timeout the specified timeout in milliseconds.
	845	+ * @throws SocketException if there is an error in the underlying protocol, such as an UDP error.
	846	+ * @since JDK1.1
	847	+ * @see #getSoTimeout()
	848	+ */
	849	+ public synchronized void setSoTimeout(int timeout) throws SocketException {
	850	+ if (isClosed())
	851	+ throw new SocketException("Socket is closed");
	852	+ getImpl().setOption(SocketOptions.SO_TIMEOUT, new Integer(timeout));
	853	+ }
	854	+
	855	+ /**
	856	+ * Retrieve setting for SO_TIMEOUT. 0 returns implies that the
	857	+ * option is disabled (i.e., timeout of infinity).
	858	+ *
	859	+ * @return the setting for SO_TIMEOUT
	860	+ * @throws SocketException if there is an error in the underlying protocol, such as an UDP error.
	861	+ * @since JDK1.1
	862	+ * @see #setSoTimeout(int)
	863	+ */
	864	+ public synchronized int getSoTimeout() throws SocketException {
	865	+ if (isClosed())
	866	+ throw new SocketException("Socket is closed");
	867	+ if (getImpl() == null)
	868	+ return 0;
	869	+ Object o = getImpl().getOption(SocketOptions.SO_TIMEOUT);
	870	+ /* extra type safety */
	871	+ if (o instanceof Integer) {
	872	+ return ((Integer) o).intValue();
	873	+ } else {
	874	+ return 0;
	875	+ }
	876	+ }
	877	+
	878	+ /**
	879	+ * Sets the SO_SNDBUF option to the specified value for this
	880	+ * <tt>DatagramSocket</tt>. The SO_SNDBUF option is used by the
	881	+ * network implementation as a hint to size the underlying
	882	+ * network I/O buffers. The SO_SNDBUF setting may also be used
	883	+ * by the network implementation to determine the maximum size
	884	+ * of the packet that can be sent on this socket.
	885	+ * <p>
	886	+ * As SO_SNDBUF is a hint, applications that want to verify
	887	+ * what size the buffer is should call {@link #getSendBufferSize()}.
	888	+ * <p>
	889	+ * Increasing the buffer size may allow multiple outgoing packets
	890	+ * to be queued by the network implementation when the send rate
	891	+ * is high.
	892	+ * <p>
	893	+ * Note: If {@link #send(DatagramPacket)} is used to send a
	894	+ * <code>DatagramPacket</code> that is larger than the setting
	895	+ * of SO_SNDBUF then it is implementation specific if the
	896	+ * packet is sent or discarded.
	897	+ *
	898	+ * @param size the size to which to set the send buffer
	899	+ * size. This value must be greater than 0.
	900	+ *
	901	+ * @exception SocketException if there is an error
	902	+ * in the underlying protocol, such as an UDP error.
	903	+ * @exception IllegalArgumentException if the value is 0 or is
	904	+ * negative.
	905	+ * @see #getSendBufferSize()
	906	+ */
	907	+ public synchronized void setSendBufferSize(int size)
	908	+ throws SocketException{
	909	+ if (!(size > 0)) {
	910	+ throw new IllegalArgumentException("negative send size");
	911	+ }
	912	+ if (isClosed())
	913	+ throw new SocketException("Socket is closed");
	914	+ getImpl().setOption(SocketOptions.SO_SNDBUF, new Integer(size));
	915	+ }
	916	+
	917	+ /**
	918	+ * Get value of the SO_SNDBUF option for this <tt>DatagramSocket</tt>, that is the
	919	+ * buffer size used by the platform for output on this <tt>DatagramSocket</tt>.
	920	+ *
	921	+ * @return the value of the SO_SNDBUF option for this <tt>DatagramSocket</tt>
	922	+ * @exception SocketException if there is an error in
	923	+ * the underlying protocol, such as an UDP error.
	924	+ * @see #setSendBufferSize
	925	+ */
	926	+ public synchronized int getSendBufferSize() throws SocketException {
	927	+ if (isClosed())
	928	+ throw new SocketException("Socket is closed");
	929	+ int result = 0;
	930	+ Object o = getImpl().getOption(SocketOptions.SO_SNDBUF);
	931	+ if (o instanceof Integer) {
	932	+ result = ((Integer)o).intValue();
	933	+ }
	934	+ return result;
	935	+ }
	936	+
	937	+ /**
	938	+ * Sets the SO_RCVBUF option to the specified value for this
	939	+ * <tt>DatagramSocket</tt>. The SO_RCVBUF option is used by the
	940	+ * the network implementation as a hint to size the underlying
	941	+ * network I/O buffers. The SO_RCVBUF setting may also be used
	942	+ * by the network implementation to determine the maximum size
	943	+ * of the packet that can be received on this socket.
	944	+ * <p>
	945	+ * Because SO_RCVBUF is a hint, applications that want to
	946	+ * verify what size the buffers were set to should call
	947	+ * {@link #getReceiveBufferSize()}.
	948	+ * <p>
	949	+ * Increasing SO_RCVBUF may allow the network implementation
	950	+ * to buffer multiple packets when packets arrive faster than
	951	+ * are being received using {@link #receive(DatagramPacket)}.
	952	+ * <p>
	953	+ * Note: It is implementation specific if a packet larger
	954	+ * than SO_RCVBUF can be received.
	955	+ *
	956	+ * @param size the size to which to set the receive buffer
	957	+ * size. This value must be greater than 0.
	958	+ *
	959	+ * @exception SocketException if there is an error in
	960	+ * the underlying protocol, such as an UDP error.
	961	+ * @exception IllegalArgumentException if the value is 0 or is
	962	+ * negative.
	963	+ * @see #getReceiveBufferSize()
	964	+ */
	965	+ public synchronized void setReceiveBufferSize(int size)
	966	+ throws SocketException{
	967	+ if (size <= 0) {
	968	+ throw new IllegalArgumentException("invalid receive size");
	969	+ }
	970	+ if (isClosed())
	971	+ throw new SocketException("Socket is closed");
	972	+ getImpl().setOption(SocketOptions.SO_RCVBUF, new Integer(size));
	973	+ }
	974	+
	975	+ /**
	976	+ * Get value of the SO_RCVBUF option for this <tt>DatagramSocket</tt>, that is the
	977	+ * buffer size used by the platform for input on this <tt>DatagramSocket</tt>.
	978	+ *
	979	+ * @return the value of the SO_RCVBUF option for this <tt>DatagramSocket</tt>
	980	+ * @exception SocketException if there is an error in the underlying protocol, such as an UDP error.
	981	+ * @see #setReceiveBufferSize(int)
	982	+ */
	983	+ public synchronized int getReceiveBufferSize()
	984	+ throws SocketException{
	985	+ if (isClosed())
	986	+ throw new SocketException("Socket is closed");
	987	+ int result = 0;
	988	+ Object o = getImpl().getOption(SocketOptions.SO_RCVBUF);
	989	+ if (o instanceof Integer) {
	990	+ result = ((Integer)o).intValue();
	991	+ }
	992	+ return result;
	993	+ }
	994	+
	995	+ /**
	996	+ * Enable/disable the SO_REUSEADDR socket option.
	997	+ * <p>
	998	+ * For UDP sockets it may be necessary to bind more than one
	999	+ * socket to the same socket address. This is typically for the
	1000	+ * purpose of receiving multicast packets
	1001	+ * (See {@link java.net.MulticastSocket}). The
	1002	+ * <tt>SO_REUSEADDR</tt> socket option allows multiple
	1003	+ * sockets to be bound to the same socket address if the
	1004	+ * <tt>SO_REUSEADDR</tt> socket option is enabled prior
	1005	+ * to binding the socket using {@link #bind(SocketAddress)}.
	1006	+ * <p>
	1007	+ * Note: This functionality is not supported by all existing platforms,
	1008	+ * so it is implementation specific whether this option will be ignored
	1009	+ * or not. However, if it is not supported then
	1010	+ * {@link #getReuseAddress()} will always return <code>false</code>.
	1011	+ * <p>
	1012	+ * When a <tt>DatagramSocket</tt> is created the initial setting
	1013	+ * of <tt>SO_REUSEADDR</tt> is disabled.
	1014	+ * <p>
	1015	+ * The behaviour when <tt>SO_REUSEADDR</tt> is enabled or
	1016	+ * disabled after a socket is bound (See {@link #isBound()})
	1017	+ * is not defined.
	1018	+ *
	1019	+ * @param on whether to enable or disable the
	1020	+ * @exception SocketException if an error occurs enabling or
	1021	+ * disabling the <tt>SO_RESUEADDR</tt> socket option,
	1022	+ * or the socket is closed.
	1023	+ * @since 1.4
	1024	+ * @see #getReuseAddress()
	1025	+ * @see #bind(SocketAddress)
	1026	+ * @see #isBound()
	1027	+ * @see #isClosed()
	1028	+ */
	1029	+ public synchronized void setReuseAddress(boolean on) throws SocketException {
	1030	+ if (isClosed())
	1031	+ throw new SocketException("Socket is closed");
	1032	+ // Integer instead of Boolean for compatibility with older DatagramSocketImpl
	1033	+ if (oldImpl)
	1034	+ getImpl().setOption(SocketOptions.SO_REUSEADDR, new Integer(on?-1:0));
	1035	+ else
	1036	+ getImpl().setOption(SocketOptions.SO_REUSEADDR, Boolean.valueOf(on));
	1037	+ }
	1038	+
	1039	+ /**
	1040	+ * Tests if SO_REUSEADDR is enabled.
	1041	+ *
	1042	+ * @return a <code>boolean</code> indicating whether or not SO_REUSEADDR is enabled.
	1043	+ * @exception SocketException if there is an error
	1044	+ * in the underlying protocol, such as an UDP error.
	1045	+ * @since 1.4
	1046	+ * @see #setReuseAddress(boolean)
	1047	+ */
	1048	+ public synchronized boolean getReuseAddress() throws SocketException {
	1049	+ if (isClosed())
	1050	+ throw new SocketException("Socket is closed");
	1051	+ Object o = getImpl().getOption(SocketOptions.SO_REUSEADDR);
	1052	+ return ((Boolean)o).booleanValue();
	1053	+ }
	1054	+
	1055	+ /**
	1056	+ * Enable/disable SO_BROADCAST.
	1057	+ *
	1058	+ * <p> Some operating systems may require that the Java virtual machine be
	1059	+ * started with implementation specific privileges to enable this option or
	1060	+ * send broadcast datagrams.
	1061	+ *
	1062	+ * @param on
	1063	+ * whether or not to have broadcast turned on.
	1064	+ *
	1065	+ * @throws SocketException
	1066	+ * if there is an error in the underlying protocol, such as an UDP
	1067	+ * error.
	1068	+ *
	1069	+ * @since 1.4
	1070	+ * @see #getBroadcast()
	1071	+ */
	1072	+ public synchronized void setBroadcast(boolean on) throws SocketException {
	1073	+ if (isClosed())
	1074	+ throw new SocketException("Socket is closed");
	1075	+ getImpl().setOption(SocketOptions.SO_BROADCAST, Boolean.valueOf(on));
	1076	+ }
	1077	+
	1078	+ /**
	1079	+ * Tests if SO_BROADCAST is enabled.
	1080	+ * @return a <code>boolean</code> indicating whether or not SO_BROADCAST is enabled.
	1081	+ * @exception SocketException if there is an error
	1082	+ * in the underlying protocol, such as an UDP error.
	1083	+ * @since 1.4
	1084	+ * @see #setBroadcast(boolean)
	1085	+ */
	1086	+ public synchronized boolean getBroadcast() throws SocketException {
	1087	+ if (isClosed())
	1088	+ throw new SocketException("Socket is closed");
	1089	+ return ((Boolean)(getImpl().getOption(SocketOptions.SO_BROADCAST))).booleanValue();
	1090	+ }
	1091	+
	1092	+ /**
	1093	+ * Sets traffic class or type-of-service octet in the IP
	1094	+ * datagram header for datagrams sent from this DatagramSocket.
	1095	+ * As the underlying network implementation may ignore this
	1096	+ * value applications should consider it a hint.
	1097	+ *
	1098	+ * <P> The tc <B>must</B> be in the range <code> 0 <= tc <=
	1099	+ * 255</code> or an IllegalArgumentException will be thrown.
	1100	+ * <p>Notes:
	1101	+ * <p>For Internet Protocol v4 the value consists of an
	1102	+ * <code>integer</code>, the least significant 8 bits of which
	1103	+ * represent the value of the TOS octet in IP packets sent by
	1104	+ * the socket.
	1105	+ * RFC 1349 defines the TOS values as follows:
	1106	+ * <p>
	1107	+ * <UL>
	1108	+ * <LI><CODE>IPTOS_LOWCOST (0x02)</CODE></LI>
	1109	+ * <LI><CODE>IPTOS_RELIABILITY (0x04)</CODE></LI>
	1110	+ * <LI><CODE>IPTOS_THROUGHPUT (0x08)</CODE></LI>
	1111	+ * <LI><CODE>IPTOS_LOWDELAY (0x10)</CODE></LI>
	1112	+ * </UL>
	1113	+ * The last low order bit is always ignored as this
	1114	+ * corresponds to the MBZ (must be zero) bit.
	1115	+ * <p>
	1116	+ * Setting bits in the precedence field may result in a
	1117	+ * SocketException indicating that the operation is not
	1118	+ * permitted.
	1119	+ * <p>
	1120	+ * for Internet Protocol v6 <code>tc</code> is the value that
	1121	+ * would be placed into the sin6_flowinfo field of the IP header.
	1122	+ *
	1123	+ * @param tc an <code>int</code> value for the bitset.
	1124	+ * @throws SocketException if there is an error setting the
	1125	+ * traffic class or type-of-service
	1126	+ * @since 1.4
	1127	+ * @see #getTrafficClass
	1128	+ */
	1129	+ public synchronized void setTrafficClass(int tc) throws SocketException {
	1130	+ if (tc < 0 \|\| tc > 255)
	1131	+ throw new IllegalArgumentException("tc is not in range 0 -- 255");
	1132	+
	1133	+ if (isClosed())
	1134	+ throw new SocketException("Socket is closed");
	1135	+ getImpl().setOption(SocketOptions.IP_TOS, new Integer(tc));
	1136	+ }
	1137	+
	1138	+ /**
	1139	+ * Gets traffic class or type-of-service in the IP datagram
	1140	+ * header for packets sent from this DatagramSocket.
	1141	+ * <p>
	1142	+ * As the underlying network implementation may ignore the
	1143	+ * traffic class or type-of-service set using {@link #setTrafficClass(int)}
	1144	+ * this method may return a different value than was previously
	1145	+ * set using the {@link #setTrafficClass(int)} method on this
	1146	+ * DatagramSocket.
	1147	+ *
	1148	+ * @return the traffic class or type-of-service already set
	1149	+ * @throws SocketException if there is an error obtaining the
	1150	+ * traffic class or type-of-service value.
	1151	+ * @since 1.4
	1152	+ * @see #setTrafficClass(int)
	1153	+ */
	1154	+ public synchronized int getTrafficClass() throws SocketException {
	1155	+ if (isClosed())
	1156	+ throw new SocketException("Socket is closed");
	1157	+ return ((Integer)(getImpl().getOption(SocketOptions.IP_TOS))).intValue();
	1158	+ }
	1159	+
	1160	+ /**
	1161	+ * Closes this datagram socket.
	1162	+ * <p>
	1163	+ * Any thread currently blocked in {@link #receive} upon this socket
	1164	+ * will throw a {@link SocketException}.
	1165	+ *
	1166	+ * <p> If this socket has an associated channel then the channel is closed
	1167	+ * as well.
	1168	+ *
	1169	+ * @revised 1.4
	1170	+ * @spec JSR-51
	1171	+ */
	1172	+ public void close() {
	1173	+ synchronized(closeLock) {
	1174	+ if (isClosed())
	1175	+ return;
	1176	+ impl.close();
	1177	+ closed = true;
	1178	+ }
	1179	+ }
	1180	+
	1181	+ /**
	1182	+ * Returns whether the socket is closed or not.
	1183	+ *
	1184	+ * @return true if the socket has been closed
	1185	+ * @since 1.4
	1186	+ */
	1187	+ public boolean isClosed() {
	1188	+ synchronized(closeLock) {
	1189	+ return closed;
	1190	+ }
	1191	+ }
	1192	+
	1193	+ /**
	1194	+ * Returns the unique {@link java.nio.channels.DatagramChannel} object
	1195	+ * associated with this datagram socket, if any.
	1196	+ *
	1197	+ * <p> A datagram socket will have a channel if, and only if, the channel
	1198	+ * itself was created via the {@link java.nio.channels.DatagramChannel#open
	1199	+ * DatagramChannel.open} method.
	1200	+ *
	1201	+ * @return the datagram channel associated with this datagram socket,
	1202	+ * or <tt>null</tt> if this socket was not created for a channel
	1203	+ *
	1204	+ * @since 1.4
	1205	+ * @spec JSR-51
	1206	+ */
	1207	+ public DatagramChannel getChannel() {
	1208	+ return null;
	1209	+ }
	1210	+
	1211	+ /**
	1212	+ * User defined factory for all datagram sockets.
	1213	+ */
	1214	+ static DatagramSocketImplFactory factory;
	1215	+
	1216	+ /**
	1217	+ * Sets the datagram socket implementation factory for the
	1218	+ * application. The factory can be specified only once.
	1219	+ * <p>
	1220	+ * When an application creates a new datagram socket, the socket
	1221	+ * implementation factory's <code>createDatagramSocketImpl</code> method is
	1222	+ * called to create the actual datagram socket implementation.
	1223	+ * <p>
	1224	+ * Passing <code>null</code> to the method is a no-op unless the factory
	1225	+ * was already set.
	1226	+ *
	1227	+ * <p>If there is a security manager, this method first calls
	1228	+ * the security manager's <code>checkSetFactory</code> method
	1229	+ * to ensure the operation is allowed.
	1230	+ * This could result in a SecurityException.
	1231	+ *
	1232	+ * @param fac the desired factory.
	1233	+ * @exception IOException if an I/O error occurs when setting the
	1234	+ * datagram socket factory.
	1235	+ * @exception SocketException if the factory is already defined.
	1236	+ * @exception SecurityException if a security manager exists and its
	1237	+ * <code>checkSetFactory</code> method doesn't allow the
	1238	+ operation.
	1239	+ * @see
	1240	+ java.net.DatagramSocketImplFactory#createDatagramSocketImpl()
	1241	+ * @see SecurityManager#checkSetFactory
	1242	+ * @since 1.3
	1243	+ */
	1244	+ public static synchronized void
	1245	+ setDatagramSocketImplFactory(DatagramSocketImplFactory fac)
	1246	+ throws IOException
	1247	+ {
	1248	+ if (factory != null) {
	1249	+ throw new SocketException("factory already defined");
	1250	+ }
	1251	+ SecurityManager security = System.getSecurityManager();
	1252	+ if (security != null) {
	1253	+ security.checkSetFactory();
	1254	+ }
	1255	+ factory = fac;
	1256	+ }
	1257	+}

java/pkg/java/net/DatagramSocketImpl.class+0−0

Binary file not shown.

java/pkg/java/net/DatagramSocketImpl.java+244−0

@@ -0,0 +1,244 @@
	1	+/*
	2	+ * Copyright (c) 1996, 2006, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.io.FileDescriptor;
	29	+import java.io.IOException;
	30	+import java.io.InterruptedIOException;
	31	+
	32	+/**
	33	+ * Abstract datagram and multicast socket implementation base class.
	34	+ * @author Pavani Diwanji
	35	+ * @since JDK1.1
	36	+ */
	37	+
	38	+public abstract class DatagramSocketImpl implements SocketOptions {
	39	+
	40	+ /**
	41	+ * The local port number.
	42	+ */
	43	+ protected int localPort;
	44	+
	45	+ /**
	46	+ * The file descriptor object.
	47	+ */
	48	+ protected FileDescriptor fd;
	49	+
	50	+ /**
	51	+ * Creates a datagram socket.
	52	+ * @exception SocketException if there is an error in the
	53	+ * underlying protocol, such as a TCP error.
	54	+ */
	55	+ protected abstract void create() throws SocketException;
	56	+
	57	+ /**
	58	+ * Binds a datagram socket to a local port and address.
	59	+ * @param lport the local port
	60	+ * @param laddr the local address
	61	+ * @exception SocketException if there is an error in the
	62	+ * underlying protocol, such as a TCP error.
	63	+ */
	64	+ protected abstract void bind(int lport, InetAddress laddr) throws SocketException;
	65	+
	66	+ /**
	67	+ * Sends a datagram packet. The packet contains the data and the
	68	+ * destination address to send the packet to.
	69	+ * @param p the packet to be sent.
	70	+ * @exception IOException if an I/O exception occurs while sending the
	71	+ * datagram packet.
	72	+ * @exception PortUnreachableException may be thrown if the socket is connected
	73	+ * to a currently unreachable destination. Note, there is no guarantee that
	74	+ * the exception will be thrown.
	75	+ */
	76	+ protected abstract void send(DatagramPacket p) throws IOException;
	77	+
	78	+ /**
	79	+ * Connects a datagram socket to a remote destination. This associates the remote
	80	+ * address with the local socket so that datagrams may only be sent to this destination
	81	+ * and received from this destination. This may be overridden to call a native
	82	+ * system connect.
	83	+ *
	84	+ * <p>If the remote destination to which the socket is connected does not
	85	+ * exist, or is otherwise unreachable, and if an ICMP destination unreachable
	86	+ * packet has been received for that address, then a subsequent call to
	87	+ * send or receive may throw a PortUnreachableException.
	88	+ * Note, there is no guarantee that the exception will be thrown.
	89	+ * @param address the remote InetAddress to connect to
	90	+ * @param port the remote port number
	91	+ * @exception SocketException may be thrown if the socket cannot be
	92	+ * connected to the remote destination
	93	+ * @since 1.4
	94	+ */
	95	+ protected void connect(InetAddress address, int port) throws SocketException {}
	96	+
	97	+ /**
	98	+ * Disconnects a datagram socket from its remote destination.
	99	+ * @since 1.4
	100	+ */
	101	+ protected void disconnect() {}
	102	+
	103	+ /**
	104	+ * Peek at the packet to see who it is from. Updates the specified <code>InetAddress</code>
	105	+ * to the address which the packet came from.
	106	+ * @param i an InetAddress object
	107	+ * @return the port number which the packet came from.
	108	+ * @exception IOException if an I/O exception occurs
	109	+ * @exception PortUnreachableException may be thrown if the socket is connected
	110	+ * to a currently unreachable destination. Note, there is no guarantee that the
	111	+ * exception will be thrown.
	112	+ */
	113	+ protected abstract int peek(InetAddress i) throws IOException;
	114	+
	115	+ /**
	116	+ * Peek at the packet to see who it is from. The data is copied into the specified
	117	+ * <code>DatagramPacket</code>. The data is returned,
	118	+ * but not consumed, so that a subsequent peekData/receive operation
	119	+ * will see the same data.
	120	+ * @param p the Packet Received.
	121	+ * @return the port number which the packet came from.
	122	+ * @exception IOException if an I/O exception occurs
	123	+ * @exception PortUnreachableException may be thrown if the socket is connected
	124	+ * to a currently unreachable destination. Note, there is no guarantee that the
	125	+ * exception will be thrown.
	126	+ * @since 1.4
	127	+ */
	128	+ protected abstract int peekData(DatagramPacket p) throws IOException;
	129	+ /**
	130	+ * Receive the datagram packet.
	131	+ * @param p the Packet Received.
	132	+ * @exception IOException if an I/O exception occurs
	133	+ * while receiving the datagram packet.
	134	+ * @exception PortUnreachableException may be thrown if the socket is connected
	135	+ * to a currently unreachable destination. Note, there is no guarantee that the
	136	+ * exception will be thrown.
	137	+ */
	138	+ protected abstract void receive(DatagramPacket p) throws IOException;
	139	+
	140	+ /**
	141	+ * Set the TTL (time-to-live) option.
	142	+ * @param ttl a byte specifying the TTL value
	143	+ *
	144	+ * @deprecated use setTimeToLive instead.
	145	+ * @exception IOException if an I/O exception occurs while setting
	146	+ * the time-to-live option.
	147	+ * @see #getTTL()
	148	+ */
	149	+ @Deprecated
	150	+ protected abstract void setTTL(byte ttl) throws IOException;
	151	+
	152	+ /**
	153	+ * Retrieve the TTL (time-to-live) option.
	154	+ *
	155	+ * @exception IOException if an I/O exception occurs
	156	+ * while retrieving the time-to-live option
	157	+ * @deprecated use getTimeToLive instead.
	158	+ * @return a byte representing the TTL value
	159	+ * @see #setTTL(byte)
	160	+ */
	161	+ @Deprecated
	162	+ protected abstract byte getTTL() throws IOException;
	163	+
	164	+ /**
	165	+ * Set the TTL (time-to-live) option.
	166	+ * @param ttl an <tt>int</tt> specifying the time-to-live value
	167	+ * @exception IOException if an I/O exception occurs
	168	+ * while setting the time-to-live option.
	169	+ * @see #getTimeToLive()
	170	+ */
	171	+ protected abstract void setTimeToLive(int ttl) throws IOException;
	172	+
	173	+ /**
	174	+ * Retrieve the TTL (time-to-live) option.
	175	+ * @exception IOException if an I/O exception occurs
	176	+ * while retrieving the time-to-live option
	177	+ * @return an <tt>int</tt> representing the time-to-live value
	178	+ * @see #setTimeToLive(int)
	179	+ */
	180	+ protected abstract int getTimeToLive() throws IOException;
	181	+
	182	+ /**
	183	+ * Join the multicast group.
	184	+ * @param inetaddr multicast address to join.
	185	+ * @exception IOException if an I/O exception occurs
	186	+ * while joining the multicast group.
	187	+ */
	188	+ protected abstract void join(InetAddress inetaddr) throws IOException;
	189	+
	190	+ /**
	191	+ * Leave the multicast group.
	192	+ * @param inetaddr multicast address to leave.
	193	+ * @exception IOException if an I/O exception occurs
	194	+ * while leaving the multicast group.
	195	+ */
	196	+ protected abstract void leave(InetAddress inetaddr) throws IOException;
	197	+
	198	+ /**
	199	+ * Join the multicast group.
	200	+ * @param mcastaddr address to join.
	201	+ * @param netIf specifies the local interface to receive multicast
	202	+ * datagram packets
	203	+ * @throws IOException if an I/O exception occurs while joining
	204	+ * the multicast group
	205	+ * @since 1.4
	206	+ */
	207	+ protected abstract void joinGroup(SocketAddress mcastaddr,
	208	+ NetworkInterface netIf)
	209	+ throws IOException;
	210	+
	211	+ /**
	212	+ * Leave the multicast group.
	213	+ * @param mcastaddr address to leave.
	214	+ * @param netIf specified the local interface to leave the group at
	215	+ * @throws IOException if an I/O exception occurs while leaving
	216	+ * the multicast group
	217	+ * @since 1.4
	218	+ */
	219	+ protected abstract void leaveGroup(SocketAddress mcastaddr,
	220	+ NetworkInterface netIf)
	221	+ throws IOException;
	222	+
	223	+ /**
	224	+ * Close the socket.
	225	+ */
	226	+ protected abstract void close();
	227	+
	228	+ /**
	229	+ * Gets the local port.
	230	+ * @return an <tt>int</tt> representing the local port value
	231	+ */
	232	+ protected int getLocalPort() {
	233	+ return localPort;
	234	+ }
	235	+
	236	+ /**
	237	+ * Gets the datagram socket file descriptor.
	238	+ * @return a <tt>FileDescriptor</tt> object representing the datagram socket
	239	+ * file descriptor
	240	+ */
	241	+ protected FileDescriptor getFileDescriptor() {
	242	+ return fd;
	243	+ }
	244	+}

java/pkg/java/net/DatagramSocketImplFactory.class+0−0

Binary file not shown.

java/pkg/java/net/DatagramSocketImplFactory.java+46−0

@@ -0,0 +1,46 @@
	1	+/*
	2	+ * Copyright (c) 1999, 2002, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+/**
	29	+ * This interface defines a factory for datagram socket implementations. It
	30	+ * is used by the classes <code>DatagramSocket</code> to create actual socket
	31	+ * implementations.
	32	+ *
	33	+ * @author Yingxian Wang
	34	+ * @see java.net.DatagramSocket
	35	+ * @since 1.3
	36	+ */
	37	+public
	38	+interface DatagramSocketImplFactory {
	39	+ /**
	40	+ * Creates a new <code>DatagramSocketImpl</code> instance.
	41	+ *
	42	+ * @return a new instance of <code>DatagramSocketImpl</code>.
	43	+ * @see java.net.DatagramSocketImpl
	44	+ */
	45	+ DatagramSocketImpl createDatagramSocketImpl();
	46	+}

java/pkg/java/net/FactoryURLClassLoader.class+0−0

Binary file not shown.

java/pkg/java/net/FileNameMap.class+0−0

Binary file not shown.

java/pkg/java/net/FileNameMap.java+44−0

@@ -0,0 +1,44 @@
	1	+/*
	2	+ * Copyright (c) 1996, 1999, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+/**
	29	+ * A simple interface which provides a mechanism to map
	30	+ * between a file name and a MIME type string.
	31	+ *
	32	+ * @author Steven B. Byrne
	33	+ * @since JDK1.1
	34	+ */
	35	+public interface FileNameMap {
	36	+
	37	+ /**
	38	+ * Gets the MIME type for the specified file name.
	39	+ * @param fileName the specified file name
	40	+ * @return a <code>String</code> indicating the MIME
	41	+ * type for the specified file name.
	42	+ */
	43	+ public String getContentTypeFor(String fileName);
	44	+}

java/pkg/java/net/HttpCookie$1.class+0−0

Binary file not shown.

java/pkg/java/net/HttpCookie$10.class+0−0

Binary file not shown.

java/pkg/java/net/HttpCookie$11.class+0−0

Binary file not shown.

java/pkg/java/net/HttpCookie$2.class+0−0

Binary file not shown.

java/pkg/java/net/HttpCookie$3.class+0−0

Binary file not shown.

java/pkg/java/net/HttpCookie$4.class+0−0

Binary file not shown.

java/pkg/java/net/HttpCookie$5.class+0−0

Binary file not shown.

java/pkg/java/net/HttpCookie$6.class+0−0

Binary file not shown.

java/pkg/java/net/HttpCookie$7.class+0−0

Binary file not shown.

java/pkg/java/net/HttpCookie$8.class+0−0

Binary file not shown.

java/pkg/java/net/HttpCookie$9.class+0−0

Binary file not shown.

java/pkg/java/net/HttpCookie$CookieAttributeAssignor.class+0−0

Binary file not shown.

java/pkg/java/net/HttpCookie.class+0−0

Binary file not shown.

java/pkg/java/net/HttpCookie.java+1206−0

@@ -0,0 +1,1206 @@
	1	+/*
	2	+ * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.util.List;
	29	+import java.util.StringTokenizer;
	30	+import java.util.NoSuchElementException;
	31	+import java.text.SimpleDateFormat;
	32	+import java.util.TimeZone;
	33	+import java.util.Date;
	34	+
	35	+import java.lang.NullPointerException; // for javadoc
	36	+import java.util.Locale;
	37	+import java.util.Objects;
	38	+
	39	+/**
	40	+ * An HttpCookie object represents an http cookie, which carries state
	41	+ * information between server and user agent. Cookie is widely adopted
	42	+ * to create stateful sessions.
	43	+ *
	44	+ * <p>There are 3 http cookie specifications:
	45	+ * <blockquote>
	46	+ * Netscape draft<br>
	47	+ * RFC 2109 - <a href="http://www.ietf.org/rfc/rfc2109.txt">
	48	+ * <i>http://www.ietf.org/rfc/rfc2109.txt</i></a><br>
	49	+ * RFC 2965 - <a href="http://www.ietf.org/rfc/rfc2965.txt">
	50	+ * <i>http://www.ietf.org/rfc/rfc2965.txt</i></a>
	51	+ * </blockquote>
	52	+ *
	53	+ * <p>HttpCookie class can accept all these 3 forms of syntax.
	54	+ *
	55	+ * @author Edward Wang
	56	+ * @since 1.6
	57	+ */
	58	+public final class HttpCookie implements Cloneable {
	59	+ /* ---------------- Fields -------------- */
	60	+
	61	+ //
	62	+ // The value of the cookie itself.
	63	+ //
	64	+
	65	+ private String name; // NAME= ... "$Name" style is reserved
	66	+ private String value; // value of NAME
	67	+
	68	+ //
	69	+ // Attributes encoded in the header's cookie fields.
	70	+ //
	71	+
	72	+ private String comment; // Comment=VALUE ... describes cookie's use
	73	+ private String commentURL; // CommentURL="http URL" ... describes cookie's use
	74	+ private boolean toDiscard; // Discard ... discard cookie unconditionally
	75	+ private String domain; // Domain=VALUE ... domain that sees cookie
	76	+ private long maxAge = MAX_AGE_UNSPECIFIED; // Max-Age=VALUE ... cookies auto-expire
	77	+ private String path; // Path=VALUE ... URLs that see the cookie
	78	+ private String portlist; // Port[="portlist"] ... the port cookie may be returned to
	79	+ private boolean secure; // Secure ... e.g. use SSL
	80	+ private boolean httpOnly; // HttpOnly ... i.e. not accessible to scripts
	81	+ private int version = 1; // Version=1 ... RFC 2965 style
	82	+
	83	+ //
	84	+ // Hold the creation time (in seconds) of the http cookie for later
	85	+ // expiration calculation
	86	+ //
	87	+ private long whenCreated = 0;
	88	+
	89	+
	90	+ //
	91	+ // Since the positive and zero max-age have their meanings,
	92	+ // this value serves as a hint as 'not specify max-age'
	93	+ //
	94	+ private final static long MAX_AGE_UNSPECIFIED = -1;
	95	+
	96	+
	97	+ //
	98	+ // date formats used by Netscape's cookie draft
	99	+ // as well as formats seen on various sites
	100	+ //
	101	+ private final static String[] COOKIE_DATE_FORMATS = {
	102	+ "EEE',' dd-MMM-yyyy HH:mm:ss 'GMT'",
	103	+ "EEE',' dd MMM yyyy HH:mm:ss 'GMT'",
	104	+ "EEE MMM dd yyyy HH:mm:ss 'GMT'Z"
	105	+ };
	106	+
	107	+ //
	108	+ // constant strings represent set-cookie header token
	109	+ //
	110	+ private final static String SET_COOKIE = "set-cookie:";
	111	+ private final static String SET_COOKIE2 = "set-cookie2:";
	112	+
	113	+
	114	+ /* ---------------- Ctors -------------- */
	115	+
	116	+ /**
	117	+ * Constructs a cookie with a specified name and value.
	118	+ *
	119	+ * <p>The name must conform to RFC 2965. That means it can contain
	120	+ * only ASCII alphanumeric characters and cannot contain commas,
	121	+ * semicolons, or white space or begin with a $ character. The cookie's
	122	+ * name cannot be changed after creation.
	123	+ *
	124	+ * <p>The value can be anything the server chooses to send. Its
	125	+ * value is probably of interest only to the server. The cookie's
	126	+ * value can be changed after creation with the
	127	+ * <code>setValue</code> method.
	128	+ *
	129	+ * <p>By default, cookies are created according to the RFC 2965
	130	+ * cookie specification. The version can be changed with the
	131	+ * <code>setVersion</code> method.
	132	+ *
	133	+ *
	134	+ * @param name a <code>String</code> specifying the name of the cookie
	135	+ *
	136	+ * @param value a <code>String</code> specifying the value of the cookie
	137	+ *
	138	+ * @throws IllegalArgumentException if the cookie name contains illegal characters
	139	+ * or it is one of the tokens reserved for use
	140	+ * by the cookie protocol
	141	+ * @throws NullPointerException if <tt>name</tt> is <tt>null</tt>
	142	+ * @see #setValue
	143	+ * @see #setVersion
	144	+ *
	145	+ */
	146	+
	147	+ public HttpCookie(String name, String value) {
	148	+ name = name.trim();
	149	+ if (name.length() == 0 \|\| !isToken(name) \|\| isReserved(name)) {
	150	+ throw new IllegalArgumentException("Illegal cookie name");
	151	+ }
	152	+
	153	+ this.name = name;
	154	+ this.value = value;
	155	+ toDiscard = false;
	156	+ secure = false;
	157	+
	158	+ whenCreated = System.currentTimeMillis();
	159	+ portlist = null;
	160	+ }
	161	+
	162	+
	163	+ /**
	164	+ * Constructs cookies from set-cookie or set-cookie2 header string.
	165	+ * RFC 2965 section 3.2.2 set-cookie2 syntax indicates that one header line
	166	+ * may contain more than one cookie definitions, so this is a static
	167	+ * utility method instead of another constructor.
	168	+ *
	169	+ * @param header a <tt>String</tt> specifying the set-cookie header.
	170	+ * The header should start with "set-cookie", or "set-cookie2"
	171	+ * token; or it should have no leading token at all.
	172	+ * @return a List of cookie parsed from header line string
	173	+ * @throws IllegalArgumentException if header string violates the cookie
	174	+ * specification's syntax, or the cookie
	175	+ * name contains llegal characters, or
	176	+ * the cookie name is one of the tokens
	177	+ * reserved for use by the cookie protocol
	178	+ * @throws NullPointerException if the header string is <tt>null</tt>
	179	+ */
	180	+ public static List<HttpCookie> parse(String header) {
	181	+ int version = guessCookieVersion(header);
	182	+
	183	+ // if header start with set-cookie or set-cookie2, strip it off
	184	+ if (startsWithIgnoreCase(header, SET_COOKIE2)) {
	185	+ header = header.substring(SET_COOKIE2.length());
	186	+ } else if (startsWithIgnoreCase(header, SET_COOKIE)) {
	187	+ header = header.substring(SET_COOKIE.length());
	188	+ }
	189	+
	190	+
	191	+ List<HttpCookie> cookies = new java.util.ArrayList<HttpCookie>();
	192	+ // The Netscape cookie may have a comma in its expires attribute,
	193	+ // while the comma is the delimiter in rfc 2965/2109 cookie header string.
	194	+ // so the parse logic is slightly different
	195	+ if (version == 0) {
	196	+ // Netscape draft cookie
	197	+ HttpCookie cookie = parseInternal(header);
	198	+ cookie.setVersion(0);
	199	+ cookies.add(cookie);
	200	+ } else {
	201	+ // rfc2965/2109 cookie
	202	+ // if header string contains more than one cookie,
	203	+ // it'll separate them with comma
	204	+ List<String> cookieStrings = splitMultiCookies(header);
	205	+ for (String cookieStr : cookieStrings) {
	206	+ HttpCookie cookie = parseInternal(cookieStr);
	207	+ cookie.setVersion(1);
	208	+ cookies.add(cookie);
	209	+ }
	210	+ }
	211	+
	212	+ return cookies;
	213	+ }
	214	+
	215	+
	216	+
	217	+
	218	+ /* ---------------- Public operations -------------- */
	219	+
	220	+
	221	+ /**
	222	+ * Reports whether this http cookie has expired or not.
	223	+ *
	224	+ * @return <tt>true</tt> to indicate this http cookie has expired;
	225	+ * otherwise, <tt>false</tt>
	226	+ */
	227	+ public boolean hasExpired() {
	228	+ if (maxAge == 0) return true;
	229	+
	230	+ // if not specify max-age, this cookie should be
	231	+ // discarded when user agent is to be closed, but
	232	+ // it is not expired.
	233	+ if (maxAge == MAX_AGE_UNSPECIFIED) return false;
	234	+
	235	+ long deltaSecond = (System.currentTimeMillis() - whenCreated) / 1000;
	236	+ if (deltaSecond > maxAge)
	237	+ return true;
	238	+ else
	239	+ return false;
	240	+ }
	241	+
	242	+ /**
	243	+ *
	244	+ * Specifies a comment that describes a cookie's purpose.
	245	+ * The comment is useful if the browser presents the cookie
	246	+ * to the user. Comments
	247	+ * are not supported by Netscape Version 0 cookies.
	248	+ *
	249	+ * @param purpose a <code>String</code> specifying the comment
	250	+ * to display to the user
	251	+ *
	252	+ * @see #getComment
	253	+ *
	254	+ */
	255	+
	256	+ public void setComment(String purpose) {
	257	+ comment = purpose;
	258	+ }
	259	+
	260	+
	261	+
	262	+
	263	+ /**
	264	+ * Returns the comment describing the purpose of this cookie, or
	265	+ * <code>null</code> if the cookie has no comment.
	266	+ *
	267	+ * @return a <code>String</code> containing the comment,
	268	+ * or <code>null</code> if none
	269	+ *
	270	+ * @see #setComment
	271	+ *
	272	+ */
	273	+
	274	+ public String getComment() {
	275	+ return comment;
	276	+ }
	277	+
	278	+
	279	+ /**
	280	+ *
	281	+ * Specifies a comment url that describes a cookie's purpose.
	282	+ * The comment url is useful if the browser presents the cookie
	283	+ * to the user. Comment url is RFC 2965 only.
	284	+ *
	285	+ * @param purpose a <code>String</code> specifying the comment url
	286	+ * to display to the user
	287	+ *
	288	+ * @see #getCommentURL
	289	+ *
	290	+ */
	291	+
	292	+ public void setCommentURL(String purpose) {
	293	+ commentURL = purpose;
	294	+ }
	295	+
	296	+
	297	+
	298	+
	299	+ /**
	300	+ * Returns the comment url describing the purpose of this cookie, or
	301	+ * <code>null</code> if the cookie has no comment url.
	302	+ *
	303	+ * @return a <code>String</code> containing the comment url,
	304	+ * or <code>null</code> if none
	305	+ *
	306	+ * @see #setCommentURL
	307	+ *
	308	+ */
	309	+
	310	+ public String getCommentURL() {
	311	+ return commentURL;
	312	+ }
	313	+
	314	+
	315	+ /**
	316	+ * Specify whether user agent should discard the cookie unconditionally.
	317	+ * This is RFC 2965 only attribute.
	318	+ *
	319	+ * @param discard <tt>true</tt> indicates to discard cookie unconditionally
	320	+ *
	321	+ * @see #getDiscard
	322	+ */
	323	+
	324	+ public void setDiscard(boolean discard) {
	325	+ toDiscard = discard;
	326	+ }
	327	+
	328	+
	329	+
	330	+
	331	+ /**
	332	+ * Return the discard attribute of the cookie
	333	+ *
	334	+ * @return a <tt>boolean</tt> to represent this cookie's discard attribute
	335	+ *
	336	+ * @see #setDiscard
	337	+ */
	338	+
	339	+ public boolean getDiscard() {
	340	+ return toDiscard;
	341	+ }
	342	+
	343	+
	344	+ /**
	345	+ * Specify the portlist of the cookie, which restricts the port(s)
	346	+ * to which a cookie may be sent back in a Cookie header.
	347	+ *
	348	+ * @param ports a <tt>String</tt> specify the port list, which is
	349	+ * comma seperated series of digits
	350	+ * @see #getPortlist
	351	+ */
	352	+
	353	+ public void setPortlist(String ports) {
	354	+ portlist = ports;
	355	+ }
	356	+
	357	+
	358	+
	359	+
	360	+ /**
	361	+ * Return the port list attribute of the cookie
	362	+ *
	363	+ * @return a <tt>String</tt> contains the port list
	364	+ * or <tt>null</tt> if none
	365	+ * @see #setPortlist
	366	+ */
	367	+
	368	+ public String getPortlist() {
	369	+ return portlist;
	370	+ }
	371	+
	372	+ /**
	373	+ *
	374	+ * Specifies the domain within which this cookie should be presented.
	375	+ *
	376	+ * <p>The form of the domain name is specified by RFC 2965. A domain
	377	+ * name begins with a dot (<code>.foo.com</code>) and means that
	378	+ * the cookie is visible to servers in a specified Domain Name System
	379	+ * (DNS) zone (for example, <code>www.foo.com</code>, but not
	380	+ * <code>a.b.foo.com</code>). By default, cookies are only returned
	381	+ * to the server that sent them.
	382	+ *
	383	+ *
	384	+ * @param pattern a <code>String</code> containing the domain name
	385	+ * within which this cookie is visible;
	386	+ * form is according to RFC 2965
	387	+ *
	388	+ * @see #getDomain
	389	+ *
	390	+ */
	391	+
	392	+ public void setDomain(String pattern) {
	393	+ if (pattern != null)
	394	+ domain = pattern.toLowerCase();
	395	+ else
	396	+ domain = pattern;
	397	+ }
	398	+
	399	+
	400	+
	401	+
	402	+
	403	+ /**
	404	+ * Returns the domain name set for this cookie. The form of
	405	+ * the domain name is set by RFC 2965.
	406	+ *
	407	+ * @return a <code>String</code> containing the domain name
	408	+ *
	409	+ * @see #setDomain
	410	+ *
	411	+ */
	412	+
	413	+ public String getDomain() {
	414	+ return domain;
	415	+ }
	416	+
	417	+
	418	+ /**
	419	+ * Sets the maximum age of the cookie in seconds.
	420	+ *
	421	+ * <p>A positive value indicates that the cookie will expire
	422	+ * after that many seconds have passed. Note that the value is
	423	+ * the <i>maximum</i> age when the cookie will expire, not the cookie's
	424	+ * current age.
	425	+ *
	426	+ * <p>A negative value means
	427	+ * that the cookie is not stored persistently and will be deleted
	428	+ * when the Web browser exits. A zero value causes the cookie
	429	+ * to be deleted.
	430	+ *
	431	+ * @param expiry an integer specifying the maximum age of the
	432	+ * cookie in seconds; if zero, the cookie
	433	+ * should be discarded immediately;
	434	+ * otherwise, the cookie's max age is unspecified.
	435	+ *
	436	+ * @see #getMaxAge
	437	+ *
	438	+ */
	439	+ public void setMaxAge(long expiry) {
	440	+ maxAge = expiry;
	441	+ }
	442	+
	443	+
	444	+
	445	+
	446	+ /**
	447	+ * Returns the maximum age of the cookie, specified in seconds.
	448	+ * By default, <code>-1</code> indicating the cookie will persist
	449	+ * until browser shutdown.
	450	+ *
	451	+ *
	452	+ * @return an integer specifying the maximum age of the
	453	+ * cookie in seconds
	454	+ *
	455	+ *
	456	+ * @see #setMaxAge
	457	+ *
	458	+ */
	459	+
	460	+ public long getMaxAge() {
	461	+ return maxAge;
	462	+ }
	463	+
	464	+
	465	+
	466	+
	467	+ /**
	468	+ * Specifies a path for the cookie
	469	+ * to which the client should return the cookie.
	470	+ *
	471	+ * <p>The cookie is visible to all the pages in the directory
	472	+ * you specify, and all the pages in that directory's subdirectories.
	473	+ * A cookie's path must include the servlet that set the cookie,
	474	+ * for example, <i>/catalog</i>, which makes the cookie
	475	+ * visible to all directories on the server under <i>/catalog</i>.
	476	+ *
	477	+ * <p>Consult RFC 2965 (available on the Internet) for more
	478	+ * information on setting path names for cookies.
	479	+ *
	480	+ *
	481	+ * @param uri a <code>String</code> specifying a path
	482	+ *
	483	+ *
	484	+ * @see #getPath
	485	+ *
	486	+ */
	487	+
	488	+ public void setPath(String uri) {
	489	+ path = uri;
	490	+ }
	491	+
	492	+
	493	+
	494	+
	495	+ /**
	496	+ * Returns the path on the server
	497	+ * to which the browser returns this cookie. The
	498	+ * cookie is visible to all subpaths on the server.
	499	+ *
	500	+ *
	501	+ * @return a <code>String</code> specifying a path that contains
	502	+ * a servlet name, for example, <i>/catalog</i>
	503	+ *
	504	+ * @see #setPath
	505	+ *
	506	+ */
	507	+
	508	+ public String getPath() {
	509	+ return path;
	510	+ }
	511	+
	512	+
	513	+
	514	+
	515	+
	516	+ /**
	517	+ * Indicates whether the cookie should only be sent using a secure protocol,
	518	+ * such as HTTPS or SSL.
	519	+ *
	520	+ * <p>The default value is <code>false</code>.
	521	+ *
	522	+ * @param flag If <code>true</code>, the cookie can only be sent over
	523	+ * a secure protocol like https.
	524	+ * If <code>false</code>, it can be sent over any protocol.
	525	+ *
	526	+ * @see #getSecure
	527	+ *
	528	+ */
	529	+
	530	+ public void setSecure(boolean flag) {
	531	+ secure = flag;
	532	+ }
	533	+
	534	+
	535	+
	536	+
	537	+ /**
	538	+ * Returns <code>true</code> if sending this cookie should be
	539	+ * restricted to a secure protocol, or <code>false</code> if the
	540	+ * it can be sent using any protocol.
	541	+ *
	542	+ * @return <code>false</code> if the cookie can be sent over
	543	+ * any standard protocol; otherwise, <code>true</code>
	544	+ *
	545	+ * @see #setSecure
	546	+ *
	547	+ */
	548	+
	549	+ public boolean getSecure() {
	550	+ return secure;
	551	+ }
	552	+
	553	+
	554	+
	555	+
	556	+
	557	+ /**
	558	+ * Returns the name of the cookie. The name cannot be changed after
	559	+ * creation.
	560	+ *
	561	+ * @return a <code>String</code> specifying the cookie's name
	562	+ *
	563	+ */
	564	+
	565	+ public String getName() {
	566	+ return name;
	567	+ }
	568	+
	569	+
	570	+
	571	+
	572	+
	573	+ /**
	574	+ *
	575	+ * Assigns a new value to a cookie after the cookie is created.
	576	+ * If you use a binary value, you may want to use BASE64 encoding.
	577	+ *
	578	+ * <p>With Version 0 cookies, values should not contain white
	579	+ * space, brackets, parentheses, equals signs, commas,
	580	+ * double quotes, slashes, question marks, at signs, colons,
	581	+ * and semicolons. Empty values may not behave the same way
	582	+ * on all browsers.
	583	+ *
	584	+ * @param newValue a <code>String</code> specifying the new value
	585	+ *
	586	+ *
	587	+ * @see #getValue
	588	+ *
	589	+ */
	590	+
	591	+ public void setValue(String newValue) {
	592	+ value = newValue;
	593	+ }
	594	+
	595	+
	596	+
	597	+
	598	+ /**
	599	+ * Returns the value of the cookie.
	600	+ *
	601	+ * @return a <code>String</code> containing the cookie's
	602	+ * present value
	603	+ *
	604	+ * @see #setValue
	605	+ *
	606	+ */
	607	+
	608	+ public String getValue() {
	609	+ return value;
	610	+ }
	611	+
	612	+
	613	+
	614	+
	615	+ /**
	616	+ * Returns the version of the protocol this cookie complies
	617	+ * with. Version 1 complies with RFC 2965/2109,
	618	+ * and version 0 complies with the original
	619	+ * cookie specification drafted by Netscape. Cookies provided
	620	+ * by a browser use and identify the browser's cookie version.
	621	+ *
	622	+ *
	623	+ * @return 0 if the cookie complies with the
	624	+ * original Netscape specification; 1
	625	+ * if the cookie complies with RFC 2965/2109
	626	+ *
	627	+ * @see #setVersion
	628	+ *
	629	+ */
	630	+
	631	+ public int getVersion() {
	632	+ return version;
	633	+ }
	634	+
	635	+
	636	+
	637	+
	638	+ /**
	639	+ * Sets the version of the cookie protocol this cookie complies
	640	+ * with. Version 0 complies with the original Netscape cookie
	641	+ * specification. Version 1 complies with RFC 2965/2109.
	642	+ *
	643	+ *
	644	+ * @param v 0 if the cookie should comply with
	645	+ * the original Netscape specification;
	646	+ * 1 if the cookie should comply with RFC 2965/2109
	647	+ *
	648	+ * @throws IllegalArgumentException if <tt>v</tt> is neither 0 nor 1
	649	+ *
	650	+ * @see #getVersion
	651	+ *
	652	+ */
	653	+
	654	+ public void setVersion(int v) {
	655	+ if (v != 0 && v != 1) {
	656	+ throw new IllegalArgumentException("cookie version should be 0 or 1");
	657	+ }
	658	+
	659	+ version = v;
	660	+ }
	661	+
	662	+ /**
	663	+ * Returns {@code true} if this cookie contains the <i>HttpOnly</i>
	664	+ * attribute. This means that the cookie should not be accessible to
	665	+ * scripting engines, like javascript.
	666	+ *
	667	+ * @return {@code true} if this cookie should be considered http only.
	668	+ * @see #setHttpOnly(boolean)
	669	+ */
	670	+ public boolean isHttpOnly()
	671	+ {
	672	+ return httpOnly;
	673	+ }
	674	+
	675	+ /**
	676	+ * Indicates whether the cookie should be considered HTTP Only. If set to
	677	+ * {@code true} it means the cookie should not be accessible to scripting
	678	+ * engines like javascript.
	679	+ *
	680	+ * @param httpOnly if {@code true} make the cookie HTTP only, i.e.
	681	+ * only visible as part of an HTTP request.
	682	+ * @see #isHttpOnly()
	683	+ */
	684	+ public void setHttpOnly(boolean httpOnly)
	685	+ {
	686	+ this.httpOnly = httpOnly;
	687	+ }
	688	+
	689	+ /**
	690	+ * The utility method to check whether a host name is in a domain
	691	+ * or not.
	692	+ *
	693	+ * <p>This concept is described in the cookie specification.
	694	+ * To understand the concept, some terminologies need to be defined first:
	695	+ * <blockquote>
	696	+ * effective host name = hostname if host name contains dot<br>
	697	+ *                  or = hostname.local if not
	698	+ * </blockquote>
	699	+ * <p>Host A's name domain-matches host B's if:
	700	+ * <blockquote><ul>
	701	+ * <li>their host name strings string-compare equal; or</li>
	702	+ * <li>A is a HDN string and has the form NB, where N is a non-empty
	703	+ * name string, B has the form .B', and B' is a HDN string. (So,
	704	+ * x.y.com domain-matches .Y.com but not Y.com.)</li>
	705	+ * </ul></blockquote>
	706	+ *
	707	+ * <p>A host isn't in a domain (RFC 2965 sec. 3.3.2) if:
	708	+ * <blockquote><ul>
	709	+ * <li>The value for the Domain attribute contains no embedded dots,
	710	+ * and the value is not .local.</li>
	711	+ * <li>The effective host name that derives from the request-host does
	712	+ * not domain-match the Domain attribute.</li>
	713	+ * <li>The request-host is a HDN (not IP address) and has the form HD,
	714	+ * where D is the value of the Domain attribute, and H is a string
	715	+ * that contains one or more dots.</li>
	716	+ * </ul></blockquote>
	717	+ *
	718	+ * <p>Examples:
	719	+ * <blockquote><ul>
	720	+ * <li>A Set-Cookie2 from request-host y.x.foo.com for Domain=.foo.com
	721	+ * would be rejected, because H is y.x and contains a dot.</li>
	722	+ * <li>A Set-Cookie2 from request-host x.foo.com for Domain=.foo.com
	723	+ * would be accepted.</li>
	724	+ * <li>A Set-Cookie2 with Domain=.com or Domain=.com., will always be
	725	+ * rejected, because there is no embedded dot.</li>
	726	+ * <li>A Set-Cookie2 with Domain=ajax.com will be accepted, and the
	727	+ * value for Domain will be taken to be .ajax.com, because a dot
	728	+ * gets prepended to the value.</li>
	729	+ * <li>A Set-Cookie2 from request-host example for Domain=.local will
	730	+ * be accepted, because the effective host name for the request-
	731	+ * host is example.local, and example.local domain-matches .local.</li>
	732	+ * </ul></blockquote>
	733	+ *
	734	+ * @param domain the domain name to check host name with
	735	+ * @param host the host name in question
	736	+ * @return <tt>true</tt> if they domain-matches; <tt>false</tt> if not
	737	+ */
	738	+ public static boolean domainMatches(String domain, String host) {
	739	+ if (domain == null \|\| host == null)
	740	+ return false;
	741	+
	742	+ // if there's no embedded dot in domain and domain is not .local
	743	+ boolean isLocalDomain = ".local".equalsIgnoreCase(domain);
	744	+ int embeddedDotInDomain = domain.indexOf('.');
	745	+ if (embeddedDotInDomain == 0)
	746	+ embeddedDotInDomain = domain.indexOf('.', 1);
	747	+ if (!isLocalDomain
	748	+ && (embeddedDotInDomain == -1 \|\| embeddedDotInDomain == domain.length() - 1))
	749	+ return false;
	750	+
	751	+ // if the host name contains no dot and the domain name is .local
	752	+ int firstDotInHost = host.indexOf('.');
	753	+ if (firstDotInHost == -1 && isLocalDomain)
	754	+ return true;
	755	+
	756	+ int domainLength = domain.length();
	757	+ int lengthDiff = host.length() - domainLength;
	758	+ if (lengthDiff == 0) {
	759	+ // if the host name and the domain name are just string-compare euqal
	760	+ return host.equalsIgnoreCase(domain);
	761	+ }
	762	+ else if (lengthDiff > 0) {
	763	+ // need to check H & D component
	764	+ String H = host.substring(0, lengthDiff);
	765	+ String D = host.substring(lengthDiff);
	766	+
	767	+ return (H.indexOf('.') == -1 && D.equalsIgnoreCase(domain));
	768	+ }
	769	+ else if (lengthDiff == -1) {
	770	+ // if domain is actually .host
	771	+ return (domain.charAt(0) == '.' &&
	772	+ host.equalsIgnoreCase(domain.substring(1)));
	773	+ }
	774	+
	775	+ return false;
	776	+ }
	777	+
	778	+
	779	+ /**
	780	+ * Constructs a cookie header string representation of this cookie,
	781	+ * which is in the format defined by corresponding cookie specification,
	782	+ * but without the leading "Cookie:" token.
	783	+ *
	784	+ * @return a string form of the cookie. The string has the defined format
	785	+ */
	786	+ @Override
	787	+ public String toString() {
	788	+ if (getVersion() > 0) {
	789	+ return toRFC2965HeaderString();
	790	+ } else {
	791	+ return toNetscapeHeaderString();
	792	+ }
	793	+ }
	794	+
	795	+
	796	+ /**
	797	+ * Test the equality of two http cookies.
	798	+ *
	799	+ * <p> The result is <tt>true</tt> only if two cookies
	800	+ * come from same domain (case-insensitive),
	801	+ * have same name (case-insensitive),
	802	+ * and have same path (case-sensitive).
	803	+ *
	804	+ * @return <tt>true</tt> if 2 http cookies equal to each other;
	805	+ * otherwise, <tt>false</tt>
	806	+ */
	807	+ @Override
	808	+ public boolean equals(Object obj) {
	809	+ if (obj == this)
	810	+ return true;
	811	+ if (!(obj instanceof HttpCookie))
	812	+ return false;
	813	+ HttpCookie other = (HttpCookie)obj;
	814	+
	815	+ // One http cookie equals to another cookie (RFC 2965 sec. 3.3.3) if:
	816	+ // 1. they come from same domain (case-insensitive),
	817	+ // 2. have same name (case-insensitive),
	818	+ // 3. and have same path (case-sensitive).
	819	+ return equalsIgnoreCase(getName(), other.getName()) &&
	820	+ equalsIgnoreCase(getDomain(), other.getDomain()) &&
	821	+ Objects.equals(getPath(), other.getPath());
	822	+ }
	823	+
	824	+
	825	+ /**
	826	+ * Return hash code of this http cookie. The result is the sum of
	827	+ * hash code value of three significant components of this cookie:
	828	+ * name, domain, and path.
	829	+ * That is, the hash code is the value of the expression:
	830	+ * <blockquote>
	831	+ * getName().toLowerCase().hashCode()<br>
	832	+ * + getDomain().toLowerCase().hashCode()<br>
	833	+ * + getPath().hashCode()
	834	+ * </blockquote>
	835	+ *
	836	+ * @return this http cookie's hash code
	837	+ */
	838	+ @Override
	839	+ public int hashCode() {
	840	+ int h1 = name.toLowerCase().hashCode();
	841	+ int h2 = (domain!=null) ? domain.toLowerCase().hashCode() : 0;
	842	+ int h3 = (path!=null) ? path.hashCode() : 0;
	843	+
	844	+ return h1 + h2 + h3;
	845	+ }
	846	+
	847	+ /**
	848	+ * Create and return a copy of this object.
	849	+ *
	850	+ * @return a clone of this http cookie
	851	+ */
	852	+ @Override
	853	+ public Object clone() {
	854	+ try {
	855	+ return super.clone();
	856	+ } catch (CloneNotSupportedException e) {
	857	+ throw new RuntimeException(e.getMessage());
	858	+ }
	859	+ }
	860	+
	861	+
	862	+ /* ---------------- Private operations -------------- */
	863	+
	864	+ // Note -- disabled for now to allow full Netscape compatibility
	865	+ // from RFC 2068, token special case characters
	866	+ //
	867	+ // private static final String tspecials = "()<>@,;:\\\"/[]?={} \t";
	868	+ private static final String tspecials = ",;";
	869	+
	870	+ /*
	871	+ * Tests a string and returns true if the string counts as a
	872	+ * token.
	873	+ *
	874	+ * @param value the <code>String</code> to be tested
	875	+ *
	876	+ * @return <code>true</code> if the <code>String</code> is
	877	+ * a token; <code>false</code> if it is not
	878	+ */
	879	+
	880	+ private static boolean isToken(String value) {
	881	+ int len = value.length();
	882	+
	883	+ for (int i = 0; i < len; i++) {
	884	+ char c = value.charAt(i);
	885	+
	886	+ if (c < 0x20 \|\| c >= 0x7f \|\| tspecials.indexOf(c) != -1)
	887	+ return false;
	888	+ }
	889	+ return true;
	890	+ }
	891	+
	892	+
	893	+ /*
	894	+ * @param name the name to be tested
	895	+ * @return <tt>true</tt> if the name is reserved by cookie
	896	+ * specification, <tt>false</tt> if it is not
	897	+ */
	898	+ private static boolean isReserved(String name) {
	899	+ if (name.equalsIgnoreCase("Comment")
	900	+ \|\| name.equalsIgnoreCase("CommentURL") // rfc2965 only
	901	+ \|\| name.equalsIgnoreCase("Discard") // rfc2965 only
	902	+ \|\| name.equalsIgnoreCase("Domain")
	903	+ \|\| name.equalsIgnoreCase("Expires") // netscape draft only
	904	+ \|\| name.equalsIgnoreCase("Max-Age")
	905	+ \|\| name.equalsIgnoreCase("Path")
	906	+ \|\| name.equalsIgnoreCase("Port") // rfc2965 only
	907	+ \|\| name.equalsIgnoreCase("Secure")
	908	+ \|\| name.equalsIgnoreCase("Version")
	909	+ \|\| name.equalsIgnoreCase("HttpOnly")
	910	+ \|\| name.charAt(0) == '$')
	911	+ {
	912	+ return true;
	913	+ }
	914	+
	915	+ return false;
	916	+ }
	917	+
	918	+
	919	+ /*
	920	+ * Parse header string to cookie object.
	921	+ *
	922	+ * @param header header string; should contain only one NAME=VALUE pair
	923	+ *
	924	+ * @return an HttpCookie being extracted
	925	+ *
	926	+ * @throws IllegalArgumentException if header string violates the cookie
	927	+ * specification
	928	+ */
	929	+ private static HttpCookie parseInternal(String header)
	930	+ {
	931	+ HttpCookie cookie = null;
	932	+ String namevaluePair = null;
	933	+
	934	+ StringTokenizer tokenizer = new StringTokenizer(header, ";");
	935	+
	936	+ // there should always have at least on name-value pair;
	937	+ // it's cookie's name
	938	+ try {
	939	+ namevaluePair = tokenizer.nextToken();
	940	+ int index = namevaluePair.indexOf('=');
	941	+ if (index != -1) {
	942	+ String name = namevaluePair.substring(0, index).trim();
	943	+ String value = namevaluePair.substring(index + 1).trim();
	944	+ cookie = new HttpCookie(name, stripOffSurroundingQuote(value));
	945	+ } else {
	946	+ // no "=" in name-value pair; it's an error
	947	+ throw new IllegalArgumentException("Invalid cookie name-value pair");
	948	+ }
	949	+ } catch (NoSuchElementException ignored) {
	950	+ throw new IllegalArgumentException("Empty cookie header string");
	951	+ }
	952	+
	953	+ // remaining name-value pairs are cookie's attributes
	954	+ while (tokenizer.hasMoreTokens()) {
	955	+ namevaluePair = tokenizer.nextToken();
	956	+ int index = namevaluePair.indexOf('=');
	957	+ String name, value;
	958	+ if (index != -1) {
	959	+ name = namevaluePair.substring(0, index).trim();
	960	+ value = namevaluePair.substring(index + 1).trim();
	961	+ } else {
	962	+ name = namevaluePair.trim();
	963	+ value = null;
	964	+ }
	965	+
	966	+ // assign attribute to cookie
	967	+ assignAttribute(cookie, name, value);
	968	+ }
	969	+
	970	+ return cookie;
	971	+ }
	972	+
	973	+
	974	+ /*
	975	+ * assign cookie attribute value to attribute name;
	976	+ * use a map to simulate method dispatch
	977	+ */
	978	+ static interface CookieAttributeAssignor {
	979	+ public void assign(HttpCookie cookie, String attrName, String attrValue);
	980	+ }
	981	+ static java.util.Map<String, CookieAttributeAssignor> assignors = null;
	982	+ static {
	983	+ assignors = new java.util.HashMap<String, CookieAttributeAssignor>();
	984	+ assignors.put("comment", new CookieAttributeAssignor(){
	985	+ public void assign(HttpCookie cookie, String attrName, String attrValue) {
	986	+ if (cookie.getComment() == null) cookie.setComment(attrValue);
	987	+ }
	988	+ });
	989	+ assignors.put("commenturl", new CookieAttributeAssignor(){
	990	+ public void assign(HttpCookie cookie, String attrName, String attrValue) {
	991	+ if (cookie.getCommentURL() == null) cookie.setCommentURL(attrValue);
	992	+ }
	993	+ });
	994	+ assignors.put("discard", new CookieAttributeAssignor(){
	995	+ public void assign(HttpCookie cookie, String attrName, String attrValue) {
	996	+ cookie.setDiscard(true);
	997	+ }
	998	+ });
	999	+ assignors.put("domain", new CookieAttributeAssignor(){
	1000	+ public void assign(HttpCookie cookie, String attrName, String attrValue) {
	1001	+ if (cookie.getDomain() == null) cookie.setDomain(attrValue);
	1002	+ }
	1003	+ });
	1004	+ assignors.put("max-age", new CookieAttributeAssignor(){
	1005	+ public void assign(HttpCookie cookie, String attrName, String attrValue) {
	1006	+ try {
	1007	+ long maxage = Long.parseLong(attrValue);
	1008	+ if (cookie.getMaxAge() == MAX_AGE_UNSPECIFIED) cookie.setMaxAge(maxage);
	1009	+ } catch (NumberFormatException ignored) {
	1010	+ throw new IllegalArgumentException("Illegal cookie max-age attribute");
	1011	+ }
	1012	+ }
	1013	+ });
	1014	+ assignors.put("path", new CookieAttributeAssignor(){
	1015	+ public void assign(HttpCookie cookie, String attrName, String attrValue) {
	1016	+ if (cookie.getPath() == null) cookie.setPath(attrValue);
	1017	+ }
	1018	+ });
	1019	+ assignors.put("port", new CookieAttributeAssignor(){
	1020	+ public void assign(HttpCookie cookie, String attrName, String attrValue) {
	1021	+ if (cookie.getPortlist() == null) cookie.setPortlist(attrValue == null ? "" : attrValue);
	1022	+ }
	1023	+ });
	1024	+ assignors.put("secure", new CookieAttributeAssignor(){
	1025	+ public void assign(HttpCookie cookie, String attrName, String attrValue) {
	1026	+ cookie.setSecure(true);
	1027	+ }
	1028	+ });
	1029	+ assignors.put("httponly", new CookieAttributeAssignor(){
	1030	+ public void assign(HttpCookie cookie, String attrName, String attrValue) {
	1031	+ cookie.setHttpOnly(true);
	1032	+ }
	1033	+ });
	1034	+ assignors.put("version", new CookieAttributeAssignor(){
	1035	+ public void assign(HttpCookie cookie, String attrName, String attrValue) {
	1036	+ try {
	1037	+ int version = Integer.parseInt(attrValue);
	1038	+ cookie.setVersion(version);
	1039	+ } catch (NumberFormatException ignored) {
	1040	+ // Just ignore bogus version, it will default to 0 or 1
	1041	+ }
	1042	+ }
	1043	+ });
	1044	+ assignors.put("expires", new CookieAttributeAssignor(){ // Netscape only
	1045	+ public void assign(HttpCookie cookie, String attrName, String attrValue) {
	1046	+ if (cookie.getMaxAge() == MAX_AGE_UNSPECIFIED) {
	1047	+ cookie.setMaxAge(cookie.expiryDate2DeltaSeconds(attrValue));
	1048	+ }
	1049	+ }
	1050	+ });
	1051	+ }
	1052	+ private static void assignAttribute(HttpCookie cookie,
	1053	+ String attrName,
	1054	+ String attrValue)
	1055	+ {
	1056	+ // strip off the surrounding "-sign if there's any
	1057	+ attrValue = stripOffSurroundingQuote(attrValue);
	1058	+
	1059	+ CookieAttributeAssignor assignor = assignors.get(attrName.toLowerCase());
	1060	+ if (assignor != null) {
	1061	+ assignor.assign(cookie, attrName, attrValue);
	1062	+ } else {
	1063	+ // Ignore the attribute as per RFC 2965
	1064	+ }
	1065	+ }
	1066	+
	1067	+ /*
	1068	+ * Constructs a string representation of this cookie. The string format is
	1069	+ * as Netscape spec, but without leading "Cookie:" token.
	1070	+ */
	1071	+ private String toNetscapeHeaderString() {
	1072	+ StringBuilder sb = new StringBuilder();
	1073	+
	1074	+ sb.append(getName() + "=" + getValue());
	1075	+
	1076	+ return sb.toString();
	1077	+ }
	1078	+
	1079	+ /*
	1080	+ * Constructs a string representation of this cookie. The string format is
	1081	+ * as RFC 2965/2109, but without leading "Cookie:" token.
	1082	+ */
	1083	+ private String toRFC2965HeaderString() {
	1084	+ StringBuilder sb = new StringBuilder();
	1085	+
	1086	+ sb.append(getName()).append("=\"").append(getValue()).append('"');
	1087	+ if (getPath() != null)
	1088	+ sb.append(";$Path=\"").append(getPath()).append('"');
	1089	+ if (getDomain() != null)
	1090	+ sb.append(";$Domain=\"").append(getDomain()).append('"');
	1091	+ if (getPortlist() != null)
	1092	+ sb.append(";$Port=\"").append(getPortlist()).append('"');
	1093	+
	1094	+ return sb.toString();
	1095	+ }
	1096	+
	1097	+ static final TimeZone GMT = TimeZone.getTimeZone("GMT");
	1098	+
	1099	+ /*
	1100	+ * @param dateString a date string in one of the formats
	1101	+ * defined in Netscape cookie spec
	1102	+ *
	1103	+ * @return delta seconds between this cookie's creation
	1104	+ * time and the time specified by dateString
	1105	+ */
	1106	+ private long expiryDate2DeltaSeconds(String dateString) {
	1107	+ for (int i = 0; i < COOKIE_DATE_FORMATS.length; i++) {
	1108	+ SimpleDateFormat df = new SimpleDateFormat(COOKIE_DATE_FORMATS[i], Locale.US);
	1109	+ df.setTimeZone(GMT);
	1110	+ try {
	1111	+ Date date = df.parse(dateString);
	1112	+ return (date.getTime() - whenCreated) / 1000;
	1113	+ } catch (Exception e) {
	1114	+ // Ignore, try the next date format
	1115	+ }
	1116	+ }
	1117	+ return 0;
	1118	+ }
	1119	+
	1120	+
	1121	+
	1122	+ /*
	1123	+ * try to guess the cookie version through set-cookie header string
	1124	+ */
	1125	+ private static int guessCookieVersion(String header) {
	1126	+ int version = 0;
	1127	+
	1128	+ header = header.toLowerCase();
	1129	+ if (header.indexOf("expires=") != -1) {
	1130	+ // only netscape cookie using 'expires'
	1131	+ version = 0;
	1132	+ } else if (header.indexOf("version=") != -1) {
	1133	+ // version is mandatory for rfc 2965/2109 cookie
	1134	+ version = 1;
	1135	+ } else if (header.indexOf("max-age") != -1) {
	1136	+ // rfc 2965/2109 use 'max-age'
	1137	+ version = 1;
	1138	+ } else if (startsWithIgnoreCase(header, SET_COOKIE2)) {
	1139	+ // only rfc 2965 cookie starts with 'set-cookie2'
	1140	+ version = 1;
	1141	+ }
	1142	+
	1143	+ return version;
	1144	+ }
	1145	+
	1146	+ private static String stripOffSurroundingQuote(String str) {
	1147	+ if (str != null && str.length() > 2 &&
	1148	+ str.charAt(0) == '"' && str.charAt(str.length() - 1) == '"') {
	1149	+ return str.substring(1, str.length() - 1);
	1150	+ }
	1151	+ if (str != null && str.length() > 2 &&
	1152	+ str.charAt(0) == '\'' && str.charAt(str.length() - 1) == '\'') {
	1153	+ return str.substring(1, str.length() - 1);
	1154	+ }
	1155	+ return str;
	1156	+ }
	1157	+
	1158	+ private static boolean equalsIgnoreCase(String s, String t) {
	1159	+ if (s == t) return true;
	1160	+ if ((s != null) && (t != null)) {
	1161	+ return s.equalsIgnoreCase(t);
	1162	+ }
	1163	+ return false;
	1164	+ }
	1165	+
	1166	+ private static boolean startsWithIgnoreCase(String s, String start) {
	1167	+ if (s == null \|\| start == null) return false;
	1168	+
	1169	+ if (s.length() >= start.length() &&
	1170	+ start.equalsIgnoreCase(s.substring(0, start.length()))) {
	1171	+ return true;
	1172	+ }
	1173	+
	1174	+ return false;
	1175	+ }
	1176	+
	1177	+ /*
	1178	+ * Split cookie header string according to rfc 2965:
	1179	+ * 1) split where it is a comma;
	1180	+ * 2) but not the comma surrounding by double-quotes, which is the comma
	1181	+ * inside port list or embeded URIs.
	1182	+ *
	1183	+ * @param header the cookie header string to split
	1184	+ *
	1185	+ * @return list of strings; never null
	1186	+ *
	1187	+ */
	1188	+ private static List<String> splitMultiCookies(String header) {
	1189	+ List<String> cookies = new java.util.ArrayList<String>();
	1190	+ int quoteCount = 0;
	1191	+ int p, q;
	1192	+
	1193	+ for (p = 0, q = 0; p < header.length(); p++) {
	1194	+ char c = header.charAt(p);
	1195	+ if (c == '"') quoteCount++;
	1196	+ if (c == ',' && (quoteCount % 2 == 0)) { // it is comma and not surrounding by double-quotes
	1197	+ cookies.add(header.substring(q, p));
	1198	+ q = p + 1;
	1199	+ }
	1200	+ }
	1201	+
	1202	+ cookies.add(header.substring(q));
	1203	+
	1204	+ return cookies;
	1205	+ }
	1206	+}

java/pkg/java/net/HttpRetryException.class+0−0

Binary file not shown.

java/pkg/java/net/HttpRetryException.java+99−0

@@ -0,0 +1,99 @@
	1	+/*
	2	+ * Copyright (c) 2004, 2008, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.io.IOException;
	29	+
	30	+/**
	31	+ * Thrown to indicate that a HTTP request needs to be retried
	32	+ * but cannot be retried automatically, due to streaming mode
	33	+ * being enabled.
	34	+ *
	35	+ * @author Michael McMahon
	36	+ * @since 1.5
	37	+ */
	38	+public
	39	+class HttpRetryException extends IOException {
	40	+ private static final long serialVersionUID = -9186022286469111381L;
	41	+
	42	+ private int responseCode;
	43	+ private String location;
	44	+
	45	+ /**
	46	+ * Constructs a new <code>HttpRetryException</code> from the
	47	+ * specified response code and exception detail message
	48	+ *
	49	+ * @param detail the detail message.
	50	+ * @param code the HTTP response code from server.
	51	+ */
	52	+ public HttpRetryException(String detail, int code) {
	53	+ super(detail);
	54	+ responseCode = code;
	55	+ }
	56	+
	57	+ /**
	58	+ * Constructs a new <code>HttpRetryException</code> with detail message
	59	+ * responseCode and the contents of the Location response header field.
	60	+ *
	61	+ * @param detail the detail message.
	62	+ * @param code the HTTP response code from server.
	63	+ * @param location the URL to be redirected to
	64	+ */
	65	+ public HttpRetryException(String detail, int code, String location) {
	66	+ super (detail);
	67	+ responseCode = code;
	68	+ this.location = location;
	69	+ }
	70	+
	71	+ /**
	72	+ * Returns the http response code
	73	+ *
	74	+ * @return The http response code.
	75	+ */
	76	+ public int responseCode() {
	77	+ return responseCode;
	78	+ }
	79	+
	80	+ /**
	81	+ * Returns a string explaining why the http request could
	82	+ * not be retried.
	83	+ *
	84	+ * @return The reason string
	85	+ */
	86	+ public String getReason() {
	87	+ return super.getMessage();
	88	+ }
	89	+
	90	+ /**
	91	+ * Returns the value of the Location header field if the
	92	+ * error resulted from redirection.
	93	+ *
	94	+ * @return The location string
	95	+ */
	96	+ public String getLocation() {
	97	+ return location;
	98	+ }
	99	+}

java/pkg/java/net/HttpURLConnection.class+0−0

Binary file not shown.

java/pkg/java/net/HttpURLConnection.java+804−0

@@ -0,0 +1,804 @@
	1	+/*
	2	+ * Copyright (c) 1996, 2011, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.io.InputStream;
	29	+import java.io.IOException;
	30	+import java.security.Permission;
	31	+import java.util.Date;
	32	+
	33	+/**
	34	+ * A URLConnection with support for HTTP-specific features. See
	35	+ * <A HREF="http://www.w3.org/pub/WWW/Protocols/"> the spec </A> for
	36	+ * details.
	37	+ * <p>
	38	+ *
	39	+ * Each HttpURLConnection instance is used to make a single request
	40	+ * but the underlying network connection to the HTTP server may be
	41	+ * transparently shared by other instances. Calling the close() methods
	42	+ * on the InputStream or OutputStream of an HttpURLConnection
	43	+ * after a request may free network resources associated with this
	44	+ * instance but has no effect on any shared persistent connection.
	45	+ * Calling the disconnect() method may close the underlying socket
	46	+ * if a persistent connection is otherwise idle at that time.
	47	+ *
	48	+ * <P>The HTTP protocol handler has a few settings that can be accessed through
	49	+ * System Properties. This covers
	50	+ * <a href="doc-files/net-properties.html#Proxies">Proxy settings</a> as well as
	51	+ * <a href="doc-files/net-properties.html#MiscHTTP"> various other settings</a>.
	52	+ * </P>
	53	+ *
	54	+ * @see java.net.HttpURLConnection#disconnect()
	55	+ * @since JDK1.1
	56	+ */
	57	+abstract public class HttpURLConnection extends URLConnection {
	58	+ /* instance variables */
	59	+
	60	+ /**
	61	+ * The HTTP method (GET,POST,PUT,etc.).
	62	+ */
	63	+ protected String method = "GET";
	64	+
	65	+ /**
	66	+ * The chunk-length when using chunked encoding streaming mode for output.
	67	+ * A value of <code>-1</code> means chunked encoding is disabled for output.
	68	+ * @since 1.5
	69	+ */
	70	+ protected int chunkLength = -1;
	71	+
	72	+ /**
	73	+ * The fixed content-length when using fixed-length streaming mode.
	74	+ * A value of <code>-1</code> means fixed-length streaming mode is disabled
	75	+ * for output.
	76	+ *
	77	+ * <P> <B>NOTE:</B> {@link #fixedContentLengthLong} is recommended instead
	78	+ * of this field, as it allows larger content lengths to be set.
	79	+ *
	80	+ * @since 1.5
	81	+ */
	82	+ protected int fixedContentLength = -1;
	83	+
	84	+ /**
	85	+ * The fixed content-length when using fixed-length streaming mode.
	86	+ * A value of {@code -1} means fixed-length streaming mode is disabled
	87	+ * for output.
	88	+ *
	89	+ * @since 1.7
	90	+ */
	91	+ protected long fixedContentLengthLong = -1;
	92	+
	93	+ /**
	94	+ * Returns the key for the <code>n</code><sup>th</sup> header field.
	95	+ * Some implementations may treat the <code>0</code><sup>th</sup>
	96	+ * header field as special, i.e. as the status line returned by the HTTP
	97	+ * server. In this case, {@link #getHeaderField(int) getHeaderField(0)} returns the status
	98	+ * line, but <code>getHeaderFieldKey(0)</code> returns null.
	99	+ *
	100	+ * @param n an index, where n >=0.
	101	+ * @return the key for the <code>n</code><sup>th</sup> header field,
	102	+ * or <code>null</code> if the key does not exist.
	103	+ */
	104	+ public String getHeaderFieldKey (int n) {
	105	+ return null;
	106	+ }
	107	+
	108	+ /**
	109	+ * This method is used to enable streaming of a HTTP request body
	110	+ * without internal buffering, when the content length is known in
	111	+ * advance.
	112	+ * <p>
	113	+ * An exception will be thrown if the application
	114	+ * attempts to write more data than the indicated
	115	+ * content-length, or if the application closes the OutputStream
	116	+ * before writing the indicated amount.
	117	+ * <p>
	118	+ * When output streaming is enabled, authentication
	119	+ * and redirection cannot be handled automatically.
	120	+ * A HttpRetryException will be thrown when reading
	121	+ * the response if authentication or redirection are required.
	122	+ * This exception can be queried for the details of the error.
	123	+ * <p>
	124	+ * This method must be called before the URLConnection is connected.
	125	+ * <p>
	126	+ * <B>NOTE:</B> {@link #setFixedLengthStreamingMode(long)} is recommended
	127	+ * instead of this method as it allows larger content lengths to be set.
	128	+ *
	129	+ * @param contentLength The number of bytes which will be written
	130	+ * to the OutputStream.
	131	+ *
	132	+ * @throws IllegalStateException if URLConnection is already connected
	133	+ * or if a different streaming mode is already enabled.
	134	+ *
	135	+ * @throws IllegalArgumentException if a content length less than
	136	+ * zero is specified.
	137	+ *
	138	+ * @see #setChunkedStreamingMode(int)
	139	+ * @since 1.5
	140	+ */
	141	+ public void setFixedLengthStreamingMode (int contentLength) {
	142	+ if (connected) {
	143	+ throw new IllegalStateException ("Already connected");
	144	+ }
	145	+ if (chunkLength != -1) {
	146	+ throw new IllegalStateException ("Chunked encoding streaming mode set");
	147	+ }
	148	+ if (contentLength < 0) {
	149	+ throw new IllegalArgumentException ("invalid content length");
	150	+ }
	151	+ fixedContentLength = contentLength;
	152	+ }
	153	+
	154	+ /**
	155	+ * This method is used to enable streaming of a HTTP request body
	156	+ * without internal buffering, when the content length is known in
	157	+ * advance.
	158	+ *
	159	+ * <P> An exception will be thrown if the application attempts to write
	160	+ * more data than the indicated content-length, or if the application
	161	+ * closes the OutputStream before writing the indicated amount.
	162	+ *
	163	+ * <P> When output streaming is enabled, authentication and redirection
	164	+ * cannot be handled automatically. A {@linkplain HttpRetryException} will
	165	+ * be thrown when reading the response if authentication or redirection
	166	+ * are required. This exception can be queried for the details of the
	167	+ * error.
	168	+ *
	169	+ * <P> This method must be called before the URLConnection is connected.
	170	+ *
	171	+ * <P> The content length set by invoking this method takes precedence
	172	+ * over any value set by {@link #setFixedLengthStreamingMode(int)}.
	173	+ *
	174	+ * @param contentLength
	175	+ * The number of bytes which will be written to the OutputStream.
	176	+ *
	177	+ * @throws IllegalStateException
	178	+ * if URLConnection is already connected or if a different
	179	+ * streaming mode is already enabled.
	180	+ *
	181	+ * @throws IllegalArgumentException
	182	+ * if a content length less than zero is specified.
	183	+ *
	184	+ * @since 1.7
	185	+ */
	186	+ public void setFixedLengthStreamingMode(long contentLength) {
	187	+ if (connected) {
	188	+ throw new IllegalStateException("Already connected");
	189	+ }
	190	+ if (chunkLength != -1) {
	191	+ throw new IllegalStateException(
	192	+ "Chunked encoding streaming mode set");
	193	+ }
	194	+ if (contentLength < 0) {
	195	+ throw new IllegalArgumentException("invalid content length");
	196	+ }
	197	+ fixedContentLengthLong = contentLength;
	198	+ }
	199	+
	200	+ /* Default chunk size (including chunk header) if not specified;
	201	+ * we want to keep this in sync with the one defined in
	202	+ * sun.net.www.http.ChunkedOutputStream
	203	+ */
	204	+ private static final int DEFAULT_CHUNK_SIZE = 4096;
	205	+
	206	+ /**
	207	+ * This method is used to enable streaming of a HTTP request body
	208	+ * without internal buffering, when the content length is <b>not</b>
	209	+ * known in advance. In this mode, chunked transfer encoding
	210	+ * is used to send the request body. Note, not all HTTP servers
	211	+ * support this mode.
	212	+ * <p>
	213	+ * When output streaming is enabled, authentication
	214	+ * and redirection cannot be handled automatically.
	215	+ * A HttpRetryException will be thrown when reading
	216	+ * the response if authentication or redirection are required.
	217	+ * This exception can be queried for the details of the error.
	218	+ * <p>
	219	+ * This method must be called before the URLConnection is connected.
	220	+ *
	221	+ * @param chunklen The number of bytes to write in each chunk.
	222	+ * If chunklen is less than or equal to zero, a default
	223	+ * value will be used.
	224	+ *
	225	+ * @throws IllegalStateException if URLConnection is already connected
	226	+ * or if a different streaming mode is already enabled.
	227	+ *
	228	+ * @see #setFixedLengthStreamingMode(int)
	229	+ * @since 1.5
	230	+ */
	231	+ public void setChunkedStreamingMode (int chunklen) {
	232	+ if (connected) {
	233	+ throw new IllegalStateException ("Can't set streaming mode: already connected");
	234	+ }
	235	+ if (fixedContentLength != -1 \|\| fixedContentLengthLong != -1) {
	236	+ throw new IllegalStateException ("Fixed length streaming mode set");
	237	+ }
	238	+ chunkLength = chunklen <=0? DEFAULT_CHUNK_SIZE : chunklen;
	239	+ }
	240	+
	241	+ /**
	242	+ * Returns the value for the <code>n</code><sup>th</sup> header field.
	243	+ * Some implementations may treat the <code>0</code><sup>th</sup>
	244	+ * header field as special, i.e. as the status line returned by the HTTP
	245	+ * server.
	246	+ * <p>
	247	+ * This method can be used in conjunction with the
	248	+ * {@link #getHeaderFieldKey getHeaderFieldKey} method to iterate through all
	249	+ * the headers in the message.
	250	+ *
	251	+ * @param n an index, where n>=0.
	252	+ * @return the value of the <code>n</code><sup>th</sup> header field,
	253	+ * or <code>null</code> if the value does not exist.
	254	+ * @see java.net.HttpURLConnection#getHeaderFieldKey(int)
	255	+ */
	256	+ public String getHeaderField(int n) {
	257	+ return null;
	258	+ }
	259	+
	260	+ /**
	261	+ * An <code>int</code> representing the three digit HTTP Status-Code.
	262	+ * <ul>
	263	+ * <li> 1xx: Informational
	264	+ * <li> 2xx: Success
	265	+ * <li> 3xx: Redirection
	266	+ * <li> 4xx: Client Error
	267	+ * <li> 5xx: Server Error
	268	+ * </ul>
	269	+ */
	270	+ protected int responseCode = -1;
	271	+
	272	+ /**
	273	+ * The HTTP response message.
	274	+ */
	275	+ protected String responseMessage = null;
	276	+
	277	+ /* static variables */
	278	+
	279	+ /* do we automatically follow redirects? The default is true. */
	280	+ private static boolean followRedirects = true;
	281	+
	282	+ /**
	283	+ * If <code>true</code>, the protocol will automatically follow redirects.
	284	+ * If <code>false</code>, the protocol will not automatically follow
	285	+ * redirects.
	286	+ * <p>
	287	+ * This field is set by the <code>setInstanceFollowRedirects</code>
	288	+ * method. Its value is returned by the <code>getInstanceFollowRedirects</code>
	289	+ * method.
	290	+ * <p>
	291	+ * Its default value is based on the value of the static followRedirects
	292	+ * at HttpURLConnection construction time.
	293	+ *
	294	+ * @see java.net.HttpURLConnection#setInstanceFollowRedirects(boolean)
	295	+ * @see java.net.HttpURLConnection#getInstanceFollowRedirects()
	296	+ * @see java.net.HttpURLConnection#setFollowRedirects(boolean)
	297	+ */
	298	+ protected boolean instanceFollowRedirects = followRedirects;
	299	+
	300	+ /* valid HTTP methods */
	301	+ private static final String[] methods = {
	302	+ "GET", "POST", "HEAD", "OPTIONS", "PUT", "DELETE", "TRACE"
	303	+ };
	304	+
	305	+ /**
	306	+ * Constructor for the HttpURLConnection.
	307	+ * @param u the URL
	308	+ */
	309	+ protected HttpURLConnection (URL u) {
	310	+ super(u);
	311	+ }
	312	+
	313	+ /**
	314	+ * Sets whether HTTP redirects (requests with response code 3xx) should
	315	+ * be automatically followed by this class. True by default. Applets
	316	+ * cannot change this variable.
	317	+ * <p>
	318	+ * If there is a security manager, this method first calls
	319	+ * the security manager's <code>checkSetFactory</code> method
	320	+ * to ensure the operation is allowed.
	321	+ * This could result in a SecurityException.
	322	+ *
	323	+ * @param set a <code>boolean</code> indicating whether or not
	324	+ * to follow HTTP redirects.
	325	+ * @exception SecurityException if a security manager exists and its
	326	+ * <code>checkSetFactory</code> method doesn't
	327	+ * allow the operation.
	328	+ * @see SecurityManager#checkSetFactory
	329	+ * @see #getFollowRedirects()
	330	+ */
	331	+ public static void setFollowRedirects(boolean set) {
	332	+ SecurityManager sec = System.getSecurityManager();
	333	+ if (sec != null) {
	334	+ // seems to be the best check here...
	335	+ sec.checkSetFactory();
	336	+ }
	337	+ followRedirects = set;
	338	+ }
	339	+
	340	+ /**
	341	+ * Returns a <code>boolean</code> indicating
	342	+ * whether or not HTTP redirects (3xx) should
	343	+ * be automatically followed.
	344	+ *
	345	+ * @return <code>true</code> if HTTP redirects should
	346	+ * be automatically followed, <tt>false</tt> if not.
	347	+ * @see #setFollowRedirects(boolean)
	348	+ */
	349	+ public static boolean getFollowRedirects() {
	350	+ return followRedirects;
	351	+ }
	352	+
	353	+ /**
	354	+ * Sets whether HTTP redirects (requests with response code 3xx) should
	355	+ * be automatically followed by this <code>HttpURLConnection</code>
	356	+ * instance.
	357	+ * <p>
	358	+ * The default value comes from followRedirects, which defaults to
	359	+ * true.
	360	+ *
	361	+ * @param followRedirects a <code>boolean</code> indicating
	362	+ * whether or not to follow HTTP redirects.
	363	+ *
	364	+ * @see java.net.HttpURLConnection#instanceFollowRedirects
	365	+ * @see #getInstanceFollowRedirects
	366	+ * @since 1.3
	367	+ */
	368	+ public void setInstanceFollowRedirects(boolean followRedirects) {
	369	+ instanceFollowRedirects = followRedirects;
	370	+ }
	371	+
	372	+ /**
	373	+ * Returns the value of this <code>HttpURLConnection</code>'s
	374	+ * <code>instanceFollowRedirects</code> field.
	375	+ *
	376	+ * @return the value of this <code>HttpURLConnection</code>'s
	377	+ * <code>instanceFollowRedirects</code> field.
	378	+ * @see java.net.HttpURLConnection#instanceFollowRedirects
	379	+ * @see #setInstanceFollowRedirects(boolean)
	380	+ * @since 1.3
	381	+ */
	382	+ public boolean getInstanceFollowRedirects() {
	383	+ return instanceFollowRedirects;
	384	+ }
	385	+
	386	+ /**
	387	+ * Set the method for the URL request, one of:
	388	+ * <UL>
	389	+ * <LI>GET
	390	+ * <LI>POST
	391	+ * <LI>HEAD
	392	+ * <LI>OPTIONS
	393	+ * <LI>PUT
	394	+ * <LI>DELETE
	395	+ * <LI>TRACE
	396	+ * </UL> are legal, subject to protocol restrictions. The default
	397	+ * method is GET.
	398	+ *
	399	+ * @param method the HTTP method
	400	+ * @exception ProtocolException if the method cannot be reset or if
	401	+ * the requested method isn't valid for HTTP.
	402	+ * @exception SecurityException if a security manager is set and the
	403	+ * method is "TRACE", but the "allowHttpTrace"
	404	+ * NetPermission is not granted.
	405	+ * @see #getRequestMethod()
	406	+ */
	407	+ public void setRequestMethod(String method) throws ProtocolException {
	408	+ if (connected) {
	409	+ throw new ProtocolException("Can't reset method: already connected");
	410	+ }
	411	+ // This restriction will prevent people from using this class to
	412	+ // experiment w/ new HTTP methods using java. But it should
	413	+ // be placed for security - the request String could be
	414	+ // arbitrarily long.
	415	+
	416	+ for (int i = 0; i < methods.length; i++) {
	417	+ if (methods[i].equals(method)) {
	418	+ if (method.equals("TRACE")) {
	419	+ SecurityManager s = System.getSecurityManager();
	420	+ if (s != null) {
	421	+ s.checkPermission(new NetPermission("allowHttpTrace"));
	422	+ }
	423	+ }
	424	+ this.method = method;
	425	+ return;
	426	+ }
	427	+ }
	428	+ throw new ProtocolException("Invalid HTTP method: " + method);
	429	+ }
	430	+
	431	+ /**
	432	+ * Get the request method.
	433	+ * @return the HTTP request method
	434	+ * @see #setRequestMethod(java.lang.String)
	435	+ */
	436	+ public String getRequestMethod() {
	437	+ return method;
	438	+ }
	439	+
	440	+ /**
	441	+ * Gets the status code from an HTTP response message.
	442	+ * For example, in the case of the following status lines:
	443	+ * <PRE>
	444	+ * HTTP/1.0 200 OK
	445	+ * HTTP/1.0 401 Unauthorized
	446	+ * </PRE>
	447	+ * It will return 200 and 401 respectively.
	448	+ * Returns -1 if no code can be discerned
	449	+ * from the response (i.e., the response is not valid HTTP).
	450	+ * @throws IOException if an error occurred connecting to the server.
	451	+ * @return the HTTP Status-Code, or -1
	452	+ */
	453	+ public int getResponseCode() throws IOException {
	454	+ /*
	455	+ * We're got the response code already
	456	+ */
	457	+ if (responseCode != -1) {
	458	+ return responseCode;
	459	+ }
	460	+
	461	+ /*
	462	+ * Ensure that we have connected to the server. Record
	463	+ * exception as we need to re-throw it if there isn't
	464	+ * a status line.
	465	+ */
	466	+ Exception exc = null;
	467	+ try {
	468	+ getInputStream();
	469	+ } catch (Exception e) {
	470	+ exc = e;
	471	+ }
	472	+
	473	+ /*
	474	+ * If we can't a status-line then re-throw any exception
	475	+ * that getInputStream threw.
	476	+ */
	477	+ String statusLine = getHeaderField(0);
	478	+ if (statusLine == null) {
	479	+ if (exc != null) {
	480	+ if (exc instanceof RuntimeException)
	481	+ throw (RuntimeException)exc;
	482	+ else
	483	+ throw (IOException)exc;
	484	+ }
	485	+ return -1;
	486	+ }
	487	+
	488	+ /*
	489	+ * Examine the status-line - should be formatted as per
	490	+ * section 6.1 of RFC 2616 :-
	491	+ *
	492	+ * Status-Line = HTTP-Version SP Status-Code SP Reason-Phrase
	493	+ *
	494	+ * If status line can't be parsed return -1.
	495	+ */
	496	+ if (statusLine.startsWith("HTTP/1.")) {
	497	+ int codePos = statusLine.indexOf(' ');
	498	+ if (codePos > 0) {
	499	+
	500	+ int phrasePos = statusLine.indexOf(' ', codePos+1);
	501	+ if (phrasePos > 0 && phrasePos < statusLine.length()) {
	502	+ responseMessage = statusLine.substring(phrasePos+1);
	503	+ }
	504	+
	505	+ // deviation from RFC 2616 - don't reject status line
	506	+ // if SP Reason-Phrase is not included.
	507	+ if (phrasePos < 0)
	508	+ phrasePos = statusLine.length();
	509	+
	510	+ try {
	511	+ responseCode = Integer.parseInt
	512	+ (statusLine.substring(codePos+1, phrasePos));
	513	+ return responseCode;
	514	+ } catch (NumberFormatException e) { }
	515	+ }
	516	+ }
	517	+ return -1;
	518	+ }
	519	+
	520	+ /**
	521	+ * Gets the HTTP response message, if any, returned along with the
	522	+ * response code from a server. From responses like:
	523	+ * <PRE>
	524	+ * HTTP/1.0 200 OK
	525	+ * HTTP/1.0 404 Not Found
	526	+ * </PRE>
	527	+ * Extracts the Strings "OK" and "Not Found" respectively.
	528	+ * Returns null if none could be discerned from the responses
	529	+ * (the result was not valid HTTP).
	530	+ * @throws IOException if an error occurred connecting to the server.
	531	+ * @return the HTTP response message, or <code>null</code>
	532	+ */
	533	+ public String getResponseMessage() throws IOException {
	534	+ getResponseCode();
	535	+ return responseMessage;
	536	+ }
	537	+
	538	+ public long getHeaderFieldDate(String name, long Default) {
	539	+ String dateString = getHeaderField(name);
	540	+ try {
	541	+ if (dateString.indexOf("GMT") == -1) {
	542	+ dateString = dateString+" GMT";
	543	+ }
	544	+ return Date.parse(dateString);
	545	+ } catch (Exception e) {
	546	+ }
	547	+ return Default;
	548	+ }
	549	+
	550	+
	551	+ /**
	552	+ * Indicates that other requests to the server
	553	+ * are unlikely in the near future. Calling disconnect()
	554	+ * should not imply that this HttpURLConnection
	555	+ * instance can be reused for other requests.
	556	+ */
	557	+ public abstract void disconnect();
	558	+
	559	+ /**
	560	+ * Indicates if the connection is going through a proxy.
	561	+ * @return a boolean indicating if the connection is
	562	+ * using a proxy.
	563	+ */
	564	+ public abstract boolean usingProxy();
	565	+
	566	+ /**
	567	+ * Returns a {@link SocketPermission} object representing the
	568	+ * permission necessary to connect to the destination host and port.
	569	+ *
	570	+ * @exception IOException if an error occurs while computing
	571	+ * the permission.
	572	+ *
	573	+ * @return a <code>SocketPermission</code> object representing the
	574	+ * permission necessary to connect to the destination
	575	+ * host and port.
	576	+ */
	577	+ public Permission getPermission() throws IOException {
	578	+ int port = url.getPort();
	579	+ port = port < 0 ? 80 : port;
	580	+ String host = url.getHost() + ":" + port;
	581	+ Permission permission = new SocketPermission(host, "connect");
	582	+ return permission;
	583	+ }
	584	+
	585	+ /**
	586	+ * Returns the error stream if the connection failed
	587	+ * but the server sent useful data nonetheless. The
	588	+ * typical example is when an HTTP server responds
	589	+ * with a 404, which will cause a FileNotFoundException
	590	+ * to be thrown in connect, but the server sent an HTML
	591	+ * help page with suggestions as to what to do.
	592	+ *
	593	+ * <p>This method will not cause a connection to be initiated. If
	594	+ * the connection was not connected, or if the server did not have
	595	+ * an error while connecting or if the server had an error but
	596	+ * no error data was sent, this method will return null. This is
	597	+ * the default.
	598	+ *
	599	+ * @return an error stream if any, null if there have been no
	600	+ * errors, the connection is not connected or the server sent no
	601	+ * useful data.
	602	+ */
	603	+ public InputStream getErrorStream() {
	604	+ return null;
	605	+ }
	606	+
	607	+ /**
	608	+ * The response codes for HTTP, as of version 1.1.
	609	+ */
	610	+
	611	+ // REMIND: do we want all these??
	612	+ // Others not here that we do want??
	613	+
	614	+ /* 2XX: generally "OK" */
	615	+
	616	+ /**
	617	+ * HTTP Status-Code 200: OK.
	618	+ */
	619	+ public static final int HTTP_OK = 200;
	620	+
	621	+ /**
	622	+ * HTTP Status-Code 201: Created.
	623	+ */
	624	+ public static final int HTTP_CREATED = 201;
	625	+
	626	+ /**
	627	+ * HTTP Status-Code 202: Accepted.
	628	+ */
	629	+ public static final int HTTP_ACCEPTED = 202;
	630	+
	631	+ /**
	632	+ * HTTP Status-Code 203: Non-Authoritative Information.
	633	+ */
	634	+ public static final int HTTP_NOT_AUTHORITATIVE = 203;
	635	+
	636	+ /**
	637	+ * HTTP Status-Code 204: No Content.
	638	+ */
	639	+ public static final int HTTP_NO_CONTENT = 204;
	640	+
	641	+ /**
	642	+ * HTTP Status-Code 205: Reset Content.
	643	+ */
	644	+ public static final int HTTP_RESET = 205;
	645	+
	646	+ /**
	647	+ * HTTP Status-Code 206: Partial Content.
	648	+ */
	649	+ public static final int HTTP_PARTIAL = 206;
	650	+
	651	+ /* 3XX: relocation/redirect */
	652	+
	653	+ /**
	654	+ * HTTP Status-Code 300: Multiple Choices.
	655	+ */
	656	+ public static final int HTTP_MULT_CHOICE = 300;
	657	+
	658	+ /**
	659	+ * HTTP Status-Code 301: Moved Permanently.
	660	+ */
	661	+ public static final int HTTP_MOVED_PERM = 301;
	662	+
	663	+ /**
	664	+ * HTTP Status-Code 302: Temporary Redirect.
	665	+ */
	666	+ public static final int HTTP_MOVED_TEMP = 302;
	667	+
	668	+ /**
	669	+ * HTTP Status-Code 303: See Other.
	670	+ */
	671	+ public static final int HTTP_SEE_OTHER = 303;
	672	+
	673	+ /**
	674	+ * HTTP Status-Code 304: Not Modified.
	675	+ */
	676	+ public static final int HTTP_NOT_MODIFIED = 304;
	677	+
	678	+ /**
	679	+ * HTTP Status-Code 305: Use Proxy.
	680	+ */
	681	+ public static final int HTTP_USE_PROXY = 305;
	682	+
	683	+ /* 4XX: client error */
	684	+
	685	+ /**
	686	+ * HTTP Status-Code 400: Bad Request.
	687	+ */
	688	+ public static final int HTTP_BAD_REQUEST = 400;
	689	+
	690	+ /**
	691	+ * HTTP Status-Code 401: Unauthorized.
	692	+ */
	693	+ public static final int HTTP_UNAUTHORIZED = 401;
	694	+
	695	+ /**
	696	+ * HTTP Status-Code 402: Payment Required.
	697	+ */
	698	+ public static final int HTTP_PAYMENT_REQUIRED = 402;
	699	+
	700	+ /**
	701	+ * HTTP Status-Code 403: Forbidden.
	702	+ */
	703	+ public static final int HTTP_FORBIDDEN = 403;
	704	+
	705	+ /**
	706	+ * HTTP Status-Code 404: Not Found.
	707	+ */
	708	+ public static final int HTTP_NOT_FOUND = 404;
	709	+
	710	+ /**
	711	+ * HTTP Status-Code 405: Method Not Allowed.
	712	+ */
	713	+ public static final int HTTP_BAD_METHOD = 405;
	714	+
	715	+ /**
	716	+ * HTTP Status-Code 406: Not Acceptable.
	717	+ */
	718	+ public static final int HTTP_NOT_ACCEPTABLE = 406;
	719	+
	720	+ /**
	721	+ * HTTP Status-Code 407: Proxy Authentication Required.
	722	+ */
	723	+ public static final int HTTP_PROXY_AUTH = 407;
	724	+
	725	+ /**
	726	+ * HTTP Status-Code 408: Request Time-Out.
	727	+ */
	728	+ public static final int HTTP_CLIENT_TIMEOUT = 408;
	729	+
	730	+ /**
	731	+ * HTTP Status-Code 409: Conflict.
	732	+ */
	733	+ public static final int HTTP_CONFLICT = 409;
	734	+
	735	+ /**
	736	+ * HTTP Status-Code 410: Gone.
	737	+ */
	738	+ public static final int HTTP_GONE = 410;
	739	+
	740	+ /**
	741	+ * HTTP Status-Code 411: Length Required.
	742	+ */
	743	+ public static final int HTTP_LENGTH_REQUIRED = 411;
	744	+
	745	+ /**
	746	+ * HTTP Status-Code 412: Precondition Failed.
	747	+ */
	748	+ public static final int HTTP_PRECON_FAILED = 412;
	749	+
	750	+ /**
	751	+ * HTTP Status-Code 413: Request Entity Too Large.
	752	+ */
	753	+ public static final int HTTP_ENTITY_TOO_LARGE = 413;
	754	+
	755	+ /**
	756	+ * HTTP Status-Code 414: Request-URI Too Large.
	757	+ */
	758	+ public static final int HTTP_REQ_TOO_LONG = 414;
	759	+
	760	+ /**
	761	+ * HTTP Status-Code 415: Unsupported Media Type.
	762	+ */
	763	+ public static final int HTTP_UNSUPPORTED_TYPE = 415;
	764	+
	765	+ /* 5XX: server error */
	766	+
	767	+ /**
	768	+ * HTTP Status-Code 500: Internal Server Error.
	769	+ * @deprecated it is misplaced and shouldn't have existed.
	770	+ */
	771	+ @Deprecated
	772	+ public static final int HTTP_SERVER_ERROR = 500;
	773	+
	774	+ /**
	775	+ * HTTP Status-Code 500: Internal Server Error.
	776	+ */
	777	+ public static final int HTTP_INTERNAL_ERROR = 500;
	778	+
	779	+ /**
	780	+ * HTTP Status-Code 501: Not Implemented.
	781	+ */
	782	+ public static final int HTTP_NOT_IMPLEMENTED = 501;
	783	+
	784	+ /**
	785	+ * HTTP Status-Code 502: Bad Gateway.
	786	+ */
	787	+ public static final int HTTP_BAD_GATEWAY = 502;
	788	+
	789	+ /**
	790	+ * HTTP Status-Code 503: Service Unavailable.
	791	+ */
	792	+ public static final int HTTP_UNAVAILABLE = 503;
	793	+
	794	+ /**
	795	+ * HTTP Status-Code 504: Gateway Timeout.
	796	+ */
	797	+ public static final int HTTP_GATEWAY_TIMEOUT = 504;
	798	+
	799	+ /**
	800	+ * HTTP Status-Code 505: HTTP Version Not Supported.
	801	+ */
	802	+ public static final int HTTP_VERSION = 505;
	803	+
	804	+}

java/pkg/java/net/IDN$1.class+0−0

Binary file not shown.

java/pkg/java/net/IDN.class+0−0

Binary file not shown.

java/pkg/java/net/IDN.java+468−0

@@ -0,0 +1,468 @@
	1	+/*
	2	+ * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+package java.net;
	26	+
	27	+import java.io.InputStream;
	28	+import java.io.IOException;
	29	+import java.security.AccessController;
	30	+import java.security.PrivilegedAction;
	31	+
	32	+import sun.net.idn.StringPrep;
	33	+import sun.net.idn.Punycode;
	34	+import sun.text.normalizer.UCharacterIterator;
	35	+
	36	+/**
	37	+ * Provides methods to convert internationalized domain names (IDNs) between
	38	+ * a normal Unicode representation and an ASCII Compatible Encoding (ACE) representation.
	39	+ * Internationalized domain names can use characters from the entire range of
	40	+ * Unicode, while traditional domain names are restricted to ASCII characters.
	41	+ * ACE is an encoding of Unicode strings that uses only ASCII characters and
	42	+ * can be used with software (such as the Domain Name System) that only
	43	+ * understands traditional domain names.
	44	+ *
	45	+ * <p>Internationalized domain names are defined in <a href="http://www.ietf.org/rfc/rfc3490.txt">RFC 3490</a>.
	46	+ * RFC 3490 defines two operations: ToASCII and ToUnicode. These 2 operations employ
	47	+ * <a href="http://www.ietf.org/rfc/rfc3491.txt">Nameprep</a> algorithm, which is a
	48	+ * profile of <a href="http://www.ietf.org/rfc/rfc3454.txt">Stringprep</a>, and
	49	+ * <a href="http://www.ietf.org/rfc/rfc3492.txt">Punycode</a> algorithm to convert
	50	+ * domain name string back and forth.
	51	+ *
	52	+ * <p>The behavior of aforementioned conversion process can be adjusted by various flags:
	53	+ * <ul>
	54	+ * <li>If the ALLOW_UNASSIGNED flag is used, the domain name string to be converted
	55	+ * can contain code points that are unassigned in Unicode 3.2, which is the
	56	+ * Unicode version on which IDN conversion is based. If the flag is not used,
	57	+ * the presence of such unassigned code points is treated as an error.
	58	+ * <li>If the USE_STD3_ASCII_RULES flag is used, ASCII strings are checked against <a href="http://www.ietf.org/rfc/rfc1122.txt">RFC 1122</a> and <a href="http://www.ietf.org/rfc/rfc1123.txt">RFC 1123</a>.
	59	+ * It is an error if they don't meet the requirements.
	60	+ * </ul>
	61	+ * These flags can be logically OR'ed together.
	62	+ *
	63	+ * <p>The security consideration is important with respect to internationalization
	64	+ * domain name support. For example, English domain names may be <i>homographed</i>
	65	+ * - maliciously misspelled by substitution of non-Latin letters.
	66	+ * <a href="http://www.unicode.org/reports/tr36/">Unicode Technical Report #36</a>
	67	+ * discusses security issues of IDN support as well as possible solutions.
	68	+ * Applications are responsible for taking adequate security measures when using
	69	+ * international domain names.
	70	+ *
	71	+ * @author Edward Wang
	72	+ * @since 1.6
	73	+ *
	74	+ */
	75	+public final class IDN {
	76	+ /**
	77	+ * Flag to allow processing of unassigned code points
	78	+ */
	79	+ public static final int ALLOW_UNASSIGNED = 0x01;
	80	+
	81	+ /**
	82	+ * Flag to turn on the check against STD-3 ASCII rules
	83	+ */
	84	+ public static final int USE_STD3_ASCII_RULES = 0x02;
	85	+
	86	+
	87	+ /**
	88	+ * Translates a string from Unicode to ASCII Compatible Encoding (ACE),
	89	+ * as defined by the ToASCII operation of <a href="http://www.ietf.org/rfc/rfc3490.txt">RFC 3490</a>.
	90	+ *
	91	+ * <p>ToASCII operation can fail. ToASCII fails if any step of it fails.
	92	+ * If ToASCII operation fails, an IllegalArgumentException will be thrown.
	93	+ * In this case, the input string should not be used in an internationalized domain name.
	94	+ *
	95	+ * <p> A label is an individual part of a domain name. The original ToASCII operation,
	96	+ * as defined in RFC 3490, only operates on a single label. This method can handle
	97	+ * both label and entire domain name, by assuming that labels in a domain name are
	98	+ * always separated by dots. The following characters are recognized as dots:
	99	+ * \u002E (full stop), \u3002 (ideographic full stop), \uFF0E (fullwidth full stop),
	100	+ * and \uFF61 (halfwidth ideographic full stop). if dots are
	101	+ * used as label separators, this method also changes all of them to \u002E (full stop)
	102	+ * in output translated string.
	103	+ *
	104	+ * @param input the string to be processed
	105	+ * @param flag process flag; can be 0 or any logical OR of possible flags
	106	+ *
	107	+ * @return the translated <tt>String</tt>
	108	+ *
	109	+ * @throws IllegalArgumentException if the input string doesn't conform to RFC 3490 specification
	110	+ */
	111	+ public static String toASCII(String input, int flag)
	112	+ {
	113	+ int p = 0, q = 0;
	114	+ StringBuffer out = new StringBuffer();
	115	+
	116	+ while (p < input.length()) {
	117	+ q = searchDots(input, p);
	118	+ out.append(toASCIIInternal(input.substring(p, q), flag));
	119	+ p = q + 1;
	120	+ if (p < input.length()) out.append('.');
	121	+ }
	122	+
	123	+ return out.toString();
	124	+ }
	125	+
	126	+
	127	+ /**
	128	+ * Translates a string from Unicode to ASCII Compatible Encoding (ACE),
	129	+ * as defined by the ToASCII operation of <a href="http://www.ietf.org/rfc/rfc3490.txt">RFC 3490</a>.
	130	+ *
	131	+ * <p> This convenience method works as if by invoking the
	132	+ * two-argument counterpart as follows:
	133	+ * <blockquote><tt>
	134	+ * {@link #toASCII(String, int) toASCII}(input, 0);
	135	+ * </tt></blockquote>
	136	+ *
	137	+ * @param input the string to be processed
	138	+ *
	139	+ * @return the translated <tt>String</tt>
	140	+ *
	141	+ * @throws IllegalArgumentException if the input string doesn't conform to RFC 3490 specification
	142	+ */
	143	+ public static String toASCII(String input) {
	144	+ return toASCII(input, 0);
	145	+ }
	146	+
	147	+
	148	+ /**
	149	+ * Translates a string from ASCII Compatible Encoding (ACE) to Unicode,
	150	+ * as defined by the ToUnicode operation of <a href="http://www.ietf.org/rfc/rfc3490.txt">RFC 3490</a>.
	151	+ *
	152	+ * <p>ToUnicode never fails. In case of any error, the input string is returned unmodified.
	153	+ *
	154	+ * <p> A label is an individual part of a domain name. The original ToUnicode operation,
	155	+ * as defined in RFC 3490, only operates on a single label. This method can handle
	156	+ * both label and entire domain name, by assuming that labels in a domain name are
	157	+ * always separated by dots. The following characters are recognized as dots:
	158	+ * \u002E (full stop), \u3002 (ideographic full stop), \uFF0E (fullwidth full stop),
	159	+ * and \uFF61 (halfwidth ideographic full stop).
	160	+ *
	161	+ * @param input the string to be processed
	162	+ * @param flag process flag; can be 0 or any logical OR of possible flags
	163	+ *
	164	+ * @return the translated <tt>String</tt>
	165	+ */
	166	+ public static String toUnicode(String input, int flag) {
	167	+ int p = 0, q = 0;
	168	+ StringBuffer out = new StringBuffer();
	169	+
	170	+ while (p < input.length()) {
	171	+ q = searchDots(input, p);
	172	+ out.append(toUnicodeInternal(input.substring(p, q), flag));
	173	+ p = q + 1;
	174	+ if (p < input.length()) out.append('.');
	175	+ }
	176	+
	177	+ return out.toString();
	178	+ }
	179	+
	180	+
	181	+ /**
	182	+ * Translates a string from ASCII Compatible Encoding (ACE) to Unicode,
	183	+ * as defined by the ToUnicode operation of <a href="http://www.ietf.org/rfc/rfc3490.txt">RFC 3490</a>.
	184	+ *
	185	+ * <p> This convenience method works as if by invoking the
	186	+ * two-argument counterpart as follows:
	187	+ * <blockquote><tt>
	188	+ * {@link #toUnicode(String, int) toUnicode}(input, 0);
	189	+ * </tt></blockquote>
	190	+ *
	191	+ * @param input the string to be processed
	192	+ *
	193	+ * @return the translated <tt>String</tt>
	194	+ */
	195	+ public static String toUnicode(String input) {
	196	+ return toUnicode(input, 0);
	197	+ }
	198	+
	199	+
	200	+ /* ---------------- Private members -------------- */
	201	+
	202	+ // ACE Prefix is "xn--"
	203	+ private static final String ACE_PREFIX = "xn--";
	204	+ private static final int ACE_PREFIX_LENGTH = ACE_PREFIX.length();
	205	+
	206	+ private static final int MAX_LABEL_LENGTH = 63;
	207	+
	208	+ // single instance of nameprep
	209	+ private static StringPrep namePrep = null;
	210	+
	211	+ static {
	212	+ InputStream stream = null;
	213	+
	214	+ try {
	215	+ final String IDN_PROFILE = "uidna.spp";
	216	+ if (System.getSecurityManager() != null) {
	217	+ stream = AccessController.doPrivileged(new PrivilegedAction<InputStream>() {
	218	+ public InputStream run() {
	219	+ return StringPrep.class.getResourceAsStream(IDN_PROFILE);
	220	+ }
	221	+ });
	222	+ } else {
	223	+ stream = StringPrep.class.getResourceAsStream(IDN_PROFILE);
	224	+ }
	225	+
	226	+ namePrep = new StringPrep(stream);
	227	+ stream.close();
	228	+ } catch (IOException e) {
	229	+ // should never reach here
	230	+ assert false;
	231	+ }
	232	+ }
	233	+
	234	+
	235	+ /* ---------------- Private operations -------------- */
	236	+
	237	+
	238	+ //
	239	+ // to suppress the default zero-argument constructor
	240	+ //
	241	+ private IDN() {}
	242	+
	243	+ //
	244	+ // toASCII operation; should only apply to a single label
	245	+ //
	246	+ private static String toASCIIInternal(String label, int flag)
	247	+ {
	248	+ // step 1
	249	+ // Check if the string contains code points outside the ASCII range 0..0x7c.
	250	+ boolean isASCII = isAllASCII(label);
	251	+ StringBuffer dest;
	252	+
	253	+ // step 2
	254	+ // perform the nameprep operation; flag ALLOW_UNASSIGNED is used here
	255	+ if (!isASCII) {
	256	+ UCharacterIterator iter = UCharacterIterator.getInstance(label);
	257	+ try {
	258	+ dest = namePrep.prepare(iter, flag);
	259	+ } catch (java.text.ParseException e) {
	260	+ throw new IllegalArgumentException(e);
	261	+ }
	262	+ } else {
	263	+ dest = new StringBuffer(label);
	264	+ }
	265	+
	266	+ // step 3
	267	+ // Verify the absence of non-LDH ASCII code points
	268	+ // 0..0x2c, 0x2e..0x2f, 0x3a..0x40, 0x5b..0x60, 0x7b..0x7f
	269	+ // Verify the absence of leading and trailing hyphen
	270	+ boolean useSTD3ASCIIRules = ((flag & USE_STD3_ASCII_RULES) != 0);
	271	+ if (useSTD3ASCIIRules) {
	272	+ for (int i = 0; i < dest.length(); i++) {
	273	+ int c = dest.charAt(i);
	274	+ if (!isLDHChar(c)) {
	275	+ throw new IllegalArgumentException("Contains non-LDH characters");
	276	+ }
	277	+ }
	278	+
	279	+ if (dest.charAt(0) == '-' \|\| dest.charAt(dest.length() - 1) == '-') {
	280	+ throw new IllegalArgumentException("Has leading or trailing hyphen");
	281	+ }
	282	+ }
	283	+
	284	+ if (!isASCII) {
	285	+ // step 4
	286	+ // If all code points are inside 0..0x7f, skip to step 8
	287	+ if (!isAllASCII(dest.toString())) {
	288	+ // step 5
	289	+ // verify the sequence does not begin with ACE prefix
	290	+ if(!startsWithACEPrefix(dest)){
	291	+
	292	+ // step 6
	293	+ // encode the sequence with punycode
	294	+ try {
	295	+ dest = Punycode.encode(dest, null);
	296	+ } catch (java.text.ParseException e) {
	297	+ throw new IllegalArgumentException(e);
	298	+ }
	299	+
	300	+ dest = toASCIILower(dest);
	301	+
	302	+ // step 7
	303	+ // prepend the ACE prefix
	304	+ dest.insert(0, ACE_PREFIX);
	305	+ } else {
	306	+ throw new IllegalArgumentException("The input starts with the ACE Prefix");
	307	+ }
	308	+
	309	+ }
	310	+ }
	311	+
	312	+ // step 8
	313	+ // the length must be inside 1..63
	314	+ if(dest.length() > MAX_LABEL_LENGTH){
	315	+ throw new IllegalArgumentException("The label in the input is too long");
	316	+ }
	317	+
	318	+ return dest.toString();
	319	+ }
	320	+
	321	+ //
	322	+ // toUnicode operation; should only apply to a single label
	323	+ //
	324	+ private static String toUnicodeInternal(String label, int flag) {
	325	+ boolean[] caseFlags = null;
	326	+ StringBuffer dest;
	327	+
	328	+ // step 1
	329	+ // find out if all the codepoints in input are ASCII
	330	+ boolean isASCII = isAllASCII(label);
	331	+
	332	+ if(!isASCII){
	333	+ // step 2
	334	+ // perform the nameprep operation; flag ALLOW_UNASSIGNED is used here
	335	+ try {
	336	+ UCharacterIterator iter = UCharacterIterator.getInstance(label);
	337	+ dest = namePrep.prepare(iter, flag);
	338	+ } catch (Exception e) {
	339	+ // toUnicode never fails; if any step fails, return the input string
	340	+ return label;
	341	+ }
	342	+ } else {
	343	+ dest = new StringBuffer(label);
	344	+ }
	345	+
	346	+ // step 3
	347	+ // verify ACE Prefix
	348	+ if(startsWithACEPrefix(dest)) {
	349	+
	350	+ // step 4
	351	+ // Remove the ACE Prefix
	352	+ String temp = dest.substring(ACE_PREFIX_LENGTH, dest.length());
	353	+
	354	+ try {
	355	+ // step 5
	356	+ // Decode using punycode
	357	+ StringBuffer decodeOut = Punycode.decode(new StringBuffer(temp), null);
	358	+
	359	+ // step 6
	360	+ // Apply toASCII
	361	+ String toASCIIOut = toASCII(decodeOut.toString(), flag);
	362	+
	363	+ // step 7
	364	+ // verify
	365	+ if (toASCIIOut.equalsIgnoreCase(dest.toString())) {
	366	+ // step 8
	367	+ // return output of step 5
	368	+ return decodeOut.toString();
	369	+ }
	370	+ } catch (Exception ignored) {
	371	+ // no-op
	372	+ }
	373	+ }
	374	+
	375	+ // just return the input
	376	+ return label;
	377	+ }
	378	+
	379	+
	380	+ //
	381	+ // LDH stands for "letter/digit/hyphen", with characters restricted to the
	382	+ // 26-letter Latin alphabet <A-Z a-z>, the digits <0-9>, and the hyphen
	383	+ // <->
	384	+ // non-LDH = 0..0x2C, 0x2E..0x2F, 0x3A..0x40, 0x56..0x60, 0x7B..0x7F
	385	+ //
	386	+ private static boolean isLDHChar(int ch){
	387	+ // high runner case
	388	+ if(ch > 0x007A){
	389	+ return false;
	390	+ }
	391	+ //['-' '0'..'9' 'A'..'Z' 'a'..'z']
	392	+ if((ch == 0x002D) \|\|
	393	+ (0x0030 <= ch && ch <= 0x0039) \|\|
	394	+ (0x0041 <= ch && ch <= 0x005A) \|\|
	395	+ (0x0061 <= ch && ch <= 0x007A)
	396	+ ){
	397	+ return true;
	398	+ }
	399	+ return false;
	400	+ }
	401	+
	402	+
	403	+ //
	404	+ // search dots in a string and return the index of that character;
	405	+ // or if there is no dots, return the length of input string
	406	+ // dots might be: \u002E (full stop), \u3002 (ideographic full stop), \uFF0E (fullwidth full stop),
	407	+ // and \uFF61 (halfwidth ideographic full stop).
	408	+ //
	409	+ private static int searchDots(String s, int start) {
	410	+ int i;
	411	+ for (i = start; i < s.length(); i++) {
	412	+ char c = s.charAt(i);
	413	+ if (c == '.' \|\| c == '\u3002' \|\| c == '\uFF0E' \|\| c == '\uFF61') {
	414	+ break;
	415	+ }
	416	+ }
	417	+
	418	+ return i;
	419	+ }
	420	+
	421	+
	422	+ //
	423	+ // to check if a string only contains US-ASCII code point
	424	+ //
	425	+ private static boolean isAllASCII(String input) {
	426	+ boolean isASCII = true;
	427	+ for (int i = 0; i < input.length(); i++) {
	428	+ int c = input.charAt(i);
	429	+ if (c > 0x7F) {
	430	+ isASCII = false;
	431	+ break;
	432	+ }
	433	+ }
	434	+ return isASCII;
	435	+ }
	436	+
	437	+ //
	438	+ // to check if a string starts with ACE-prefix
	439	+ //
	440	+ private static boolean startsWithACEPrefix(StringBuffer input){
	441	+ boolean startsWithPrefix = true;
	442	+
	443	+ if(input.length() < ACE_PREFIX_LENGTH){
	444	+ return false;
	445	+ }
	446	+ for(int i = 0; i < ACE_PREFIX_LENGTH; i++){
	447	+ if(toASCIILower(input.charAt(i)) != ACE_PREFIX.charAt(i)){
	448	+ startsWithPrefix = false;
	449	+ }
	450	+ }
	451	+ return startsWithPrefix;
	452	+ }
	453	+
	454	+ private static char toASCIILower(char ch){
	455	+ if('A' <= ch && ch <= 'Z'){
	456	+ return (char)(ch + 'a' - 'A');
	457	+ }
	458	+ return ch;
	459	+ }
	460	+
	461	+ private static StringBuffer toASCIILower(StringBuffer input){
	462	+ StringBuffer dest = new StringBuffer();
	463	+ for(int i = 0; i < input.length();i++){
	464	+ dest.append(toASCIILower(input.charAt(i)));
	465	+ }
	466	+ return dest;
	467	+ }
	468	+}

java/pkg/java/net/InMemoryCookieStore.class+0−0

Binary file not shown.

java/pkg/java/net/InMemoryCookieStore.java+393−0

@@ -0,0 +1,393 @@
	1	+/*
	2	+ * Copyright (c) 2005, 2008, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.net.URI;
	29	+import java.net.CookieStore;
	30	+import java.net.HttpCookie;
	31	+import java.net.URISyntaxException;
	32	+import java.util.List;
	33	+import java.util.Map;
	34	+import java.util.ArrayList;
	35	+import java.util.HashMap;
	36	+import java.util.Collections;
	37	+import java.util.Iterator;
	38	+import java.util.concurrent.locks.ReentrantLock;
	39	+
	40	+/**
	41	+ * A simple in-memory java.net.CookieStore implementation
	42	+ *
	43	+ * @author Edward Wang
	44	+ * @since 1.6
	45	+ */
	46	+class InMemoryCookieStore implements CookieStore {
	47	+ // the in-memory representation of cookies
	48	+ private List<HttpCookie> cookieJar = null;
	49	+
	50	+ // the cookies are indexed by its domain and associated uri (if present)
	51	+ // CAUTION: when a cookie removed from main data structure (i.e. cookieJar),
	52	+ // it won't be cleared in domainIndex & uriIndex. Double-check the
	53	+ // presence of cookie when retrieve one form index store.
	54	+ private Map<String, List<HttpCookie>> domainIndex = null;
	55	+ private Map<URI, List<HttpCookie>> uriIndex = null;
	56	+
	57	+ // use ReentrantLock instead of syncronized for scalability
	58	+ private ReentrantLock lock = null;
	59	+
	60	+
	61	+ /**
	62	+ * The default ctor
	63	+ */
	64	+ public InMemoryCookieStore() {
	65	+ cookieJar = new ArrayList<HttpCookie>();
	66	+ domainIndex = new HashMap<String, List<HttpCookie>>();
	67	+ uriIndex = new HashMap<URI, List<HttpCookie>>();
	68	+
	69	+ lock = new ReentrantLock(false);
	70	+ }
	71	+
	72	+ /**
	73	+ * Add one cookie into cookie store.
	74	+ */
	75	+ public void add(URI uri, HttpCookie cookie) {
	76	+ // pre-condition : argument can't be null
	77	+ if (cookie == null) {
	78	+ throw new NullPointerException("cookie is null");
	79	+ }
	80	+
	81	+
	82	+ lock.lock();
	83	+ try {
	84	+ // remove the ole cookie if there has had one
	85	+ cookieJar.remove(cookie);
	86	+
	87	+ // add new cookie if it has a non-zero max-age
	88	+ if (cookie.getMaxAge() != 0) {
	89	+ cookieJar.add(cookie);
	90	+ // and add it to domain index
	91	+ if (cookie.getDomain() != null) {
	92	+ addIndex(domainIndex, cookie.getDomain(), cookie);
	93	+ }
	94	+ // add it to uri index, too
	95	+ addIndex(uriIndex, getEffectiveURI(uri), cookie);
	96	+ }
	97	+ } finally {
	98	+ lock.unlock();
	99	+ }
	100	+ }
	101	+
	102	+
	103	+ /**
	104	+ * Get all cookies, which:
	105	+ * 1) given uri domain-matches with, or, associated with
	106	+ * given uri when added to the cookie store.
	107	+ * 3) not expired.
	108	+ * See RFC 2965 sec. 3.3.4 for more detail.
	109	+ */
	110	+ public List<HttpCookie> get(URI uri) {
	111	+ // argument can't be null
	112	+ if (uri == null) {
	113	+ throw new NullPointerException("uri is null");
	114	+ }
	115	+
	116	+ List<HttpCookie> cookies = new ArrayList<HttpCookie>();
	117	+ boolean secureLink = "https".equalsIgnoreCase(uri.getScheme());
	118	+ lock.lock();
	119	+ try {
	120	+ // check domainIndex first
	121	+ getInternal1(cookies, domainIndex, uri.getHost(), secureLink);
	122	+ // check uriIndex then
	123	+ getInternal2(cookies, uriIndex, getEffectiveURI(uri), secureLink);
	124	+ } finally {
	125	+ lock.unlock();
	126	+ }
	127	+
	128	+ return cookies;
	129	+ }
	130	+
	131	+ /**
	132	+ * Get all cookies in cookie store, except those have expired
	133	+ */
	134	+ public List<HttpCookie> getCookies() {
	135	+ List<HttpCookie> rt;
	136	+
	137	+ lock.lock();
	138	+ try {
	139	+ Iterator<HttpCookie> it = cookieJar.iterator();
	140	+ while (it.hasNext()) {
	141	+ if (it.next().hasExpired()) {
	142	+ it.remove();
	143	+ }
	144	+ }
	145	+ } finally {
	146	+ rt = Collections.unmodifiableList(cookieJar);
	147	+ lock.unlock();
	148	+ }
	149	+
	150	+ return rt;
	151	+ }
	152	+
	153	+ /**
	154	+ * Get all URIs, which are associated with at least one cookie
	155	+ * of this cookie store.
	156	+ */
	157	+ public List<URI> getURIs() {
	158	+ List<URI> uris = new ArrayList<URI>();
	159	+
	160	+ lock.lock();
	161	+ try {
	162	+ Iterator<URI> it = uriIndex.keySet().iterator();
	163	+ while (it.hasNext()) {
	164	+ URI uri = it.next();
	165	+ List<HttpCookie> cookies = uriIndex.get(uri);
	166	+ if (cookies == null \|\| cookies.size() == 0) {
	167	+ // no cookies list or an empty list associated with
	168	+ // this uri entry, delete it
	169	+ it.remove();
	170	+ }
	171	+ }
	172	+ } finally {
	173	+ uris.addAll(uriIndex.keySet());
	174	+ lock.unlock();
	175	+ }
	176	+
	177	+ return uris;
	178	+ }
	179	+
	180	+
	181	+ /**
	182	+ * Remove a cookie from store
	183	+ */
	184	+ public boolean remove(URI uri, HttpCookie ck) {
	185	+ // argument can't be null
	186	+ if (ck == null) {
	187	+ throw new NullPointerException("cookie is null");
	188	+ }
	189	+
	190	+ boolean modified = false;
	191	+ lock.lock();
	192	+ try {
	193	+ modified = cookieJar.remove(ck);
	194	+ } finally {
	195	+ lock.unlock();
	196	+ }
	197	+
	198	+ return modified;
	199	+ }
	200	+
	201	+
	202	+ /**
	203	+ * Remove all cookies in this cookie store.
	204	+ */
	205	+ public boolean removeAll() {
	206	+ lock.lock();
	207	+ try {
	208	+ cookieJar.clear();
	209	+ domainIndex.clear();
	210	+ uriIndex.clear();
	211	+ } finally {
	212	+ lock.unlock();
	213	+ }
	214	+
	215	+ return true;
	216	+ }
	217	+
	218	+
	219	+ /* ---------------- Private operations -------------- */
	220	+
	221	+
	222	+ /*
	223	+ * This is almost the same as HttpCookie.domainMatches except for
	224	+ * one difference: It won't reject cookies when the 'H' part of the
	225	+ * domain contains a dot ('.').
	226	+ * I.E.: RFC 2965 section 3.3.2 says that if host is x.y.domain.com
	227	+ * and the cookie domain is .domain.com, then it should be rejected.
	228	+ * However that's not how the real world works. Browsers don't reject and
	229	+ * some sites, like yahoo.com do actually expect these cookies to be
	230	+ * passed along.
	231	+ * And should be used for 'old' style cookies (aka Netscape type of cookies)
	232	+ */
	233	+ private boolean netscapeDomainMatches(String domain, String host)
	234	+ {
	235	+ if (domain == null \|\| host == null) {
	236	+ return false;
	237	+ }
	238	+
	239	+ // if there's no embedded dot in domain and domain is not .local
	240	+ boolean isLocalDomain = ".local".equalsIgnoreCase(domain);
	241	+ int embeddedDotInDomain = domain.indexOf('.');
	242	+ if (embeddedDotInDomain == 0) {
	243	+ embeddedDotInDomain = domain.indexOf('.', 1);
	244	+ }
	245	+ if (!isLocalDomain && (embeddedDotInDomain == -1 \|\| embeddedDotInDomain == domain.length() - 1)) {
	246	+ return false;
	247	+ }
	248	+
	249	+ // if the host name contains no dot and the domain name is .local
	250	+ int firstDotInHost = host.indexOf('.');
	251	+ if (firstDotInHost == -1 && isLocalDomain) {
	252	+ return true;
	253	+ }
	254	+
	255	+ int domainLength = domain.length();
	256	+ int lengthDiff = host.length() - domainLength;
	257	+ if (lengthDiff == 0) {
	258	+ // if the host name and the domain name are just string-compare euqal
	259	+ return host.equalsIgnoreCase(domain);
	260	+ } else if (lengthDiff > 0) {
	261	+ // need to check H & D component
	262	+ String H = host.substring(0, lengthDiff);
	263	+ String D = host.substring(lengthDiff);
	264	+
	265	+ return (D.equalsIgnoreCase(domain));
	266	+ } else if (lengthDiff == -1) {
	267	+ // if domain is actually .host
	268	+ return (domain.charAt(0) == '.' &&
	269	+ host.equalsIgnoreCase(domain.substring(1)));
	270	+ }
	271	+
	272	+ return false;
	273	+ }
	274	+
	275	+ private void getInternal1(List<HttpCookie> cookies, Map<String, List<HttpCookie>> cookieIndex,
	276	+ String host, boolean secureLink) {
	277	+ // Use a separate list to handle cookies that need to be removed so
	278	+ // that there is no conflict with iterators.
	279	+ ArrayList<HttpCookie> toRemove = new ArrayList<HttpCookie>();
	280	+ for (Map.Entry<String, List<HttpCookie>> entry : cookieIndex.entrySet()) {
	281	+ String domain = entry.getKey();
	282	+ List<HttpCookie> lst = entry.getValue();
	283	+ for (HttpCookie c : lst) {
	284	+ if ((c.getVersion() == 0 && netscapeDomainMatches(domain, host)) \|\|
	285	+ (c.getVersion() == 1 && HttpCookie.domainMatches(domain, host))) {
	286	+ if ((cookieJar.indexOf(c) != -1)) {
	287	+ // the cookie still in main cookie store
	288	+ if (!c.hasExpired()) {
	289	+ // don't add twice and make sure it's the proper
	290	+ // security level
	291	+ if ((secureLink \|\| !c.getSecure()) &&
	292	+ !cookies.contains(c)) {
	293	+ cookies.add(c);
	294	+ }
	295	+ } else {
	296	+ toRemove.add(c);
	297	+ }
	298	+ } else {
	299	+ // the cookie has beed removed from main store,
	300	+ // so also remove it from domain indexed store
	301	+ toRemove.add(c);
	302	+ }
	303	+ }
	304	+ }
	305	+ // Clear up the cookies that need to be removed
	306	+ for (HttpCookie c : toRemove) {
	307	+ lst.remove(c);
	308	+ cookieJar.remove(c);
	309	+
	310	+ }
	311	+ toRemove.clear();
	312	+ }
	313	+ }
	314	+
	315	+ // @param cookies [OUT] contains the found cookies
	316	+ // @param cookieIndex the index
	317	+ // @param comparator the prediction to decide whether or not
	318	+ // a cookie in index should be returned
	319	+ private <T> void getInternal2(List<HttpCookie> cookies,
	320	+ Map<T, List<HttpCookie>> cookieIndex,
	321	+ Comparable<T> comparator, boolean secureLink)
	322	+ {
	323	+ for (T index : cookieIndex.keySet()) {
	324	+ if (comparator.compareTo(index) == 0) {
	325	+ List<HttpCookie> indexedCookies = cookieIndex.get(index);
	326	+ // check the list of cookies associated with this domain
	327	+ if (indexedCookies != null) {
	328	+ Iterator<HttpCookie> it = indexedCookies.iterator();
	329	+ while (it.hasNext()) {
	330	+ HttpCookie ck = it.next();
	331	+ if (cookieJar.indexOf(ck) != -1) {
	332	+ // the cookie still in main cookie store
	333	+ if (!ck.hasExpired()) {
	334	+ // don't add twice
	335	+ if ((secureLink \|\| !ck.getSecure()) &&
	336	+ !cookies.contains(ck))
	337	+ cookies.add(ck);
	338	+ } else {
	339	+ it.remove();
	340	+ cookieJar.remove(ck);
	341	+ }
	342	+ } else {
	343	+ // the cookie has beed removed from main store,
	344	+ // so also remove it from domain indexed store
	345	+ it.remove();
	346	+ }
	347	+ }
	348	+ } // end of indexedCookies != null
	349	+ } // end of comparator.compareTo(index) == 0
	350	+ } // end of cookieIndex iteration
	351	+ }
	352	+
	353	+ // add 'cookie' indexed by 'index' into 'indexStore'
	354	+ private <T> void addIndex(Map<T, List<HttpCookie>> indexStore,
	355	+ T index,
	356	+ HttpCookie cookie)
	357	+ {
	358	+ if (index != null) {
	359	+ List<HttpCookie> cookies = indexStore.get(index);
	360	+ if (cookies != null) {
	361	+ // there may already have the same cookie, so remove it first
	362	+ cookies.remove(cookie);
	363	+
	364	+ cookies.add(cookie);
	365	+ } else {
	366	+ cookies = new ArrayList<HttpCookie>();
	367	+ cookies.add(cookie);
	368	+ indexStore.put(index, cookies);
	369	+ }
	370	+ }
	371	+ }
	372	+
	373	+
	374	+ //
	375	+ // for cookie purpose, the effective uri should only be http://host
	376	+ // the path will be taken into account when path-match algorithm applied
	377	+ //
	378	+ private URI getEffectiveURI(URI uri) {
	379	+ URI effectiveURI = null;
	380	+ try {
	381	+ effectiveURI = new URI("http",
	382	+ uri.getHost(),
	383	+ null, // path component
	384	+ null, // query component
	385	+ null // fragment component
	386	+ );
	387	+ } catch (URISyntaxException ignored) {
	388	+ effectiveURI = uri;
	389	+ }
	390	+
	391	+ return effectiveURI;
	392	+ }
	393	+}

java/pkg/java/net/Inet4Address.class+0−0

Binary file not shown.

java/pkg/java/net/Inet4Address.java+374−0

@@ -0,0 +1,374 @@
	1	+/*
	2	+ * Copyright (c) 2000, 2006, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.security.AccessController;
	29	+import java.io.ObjectStreamException;
	30	+import sun.security.action.*;
	31	+
	32	+/**
	33	+ * This class represents an Internet Protocol version 4 (IPv4) address.
	34	+ * Defined by <a href="http://www.ietf.org/rfc/rfc790.txt">
	35	+ * <i>RFC 790: Assigned Numbers</i></a>,
	36	+ * <a href="http://www.ietf.org/rfc/rfc1918.txt">
	37	+ * <i>RFC 1918: Address Allocation for Private Internets</i></a>,
	38	+ * and <a href="http://www.ietf.org/rfc/rfc2365.txt"><i>RFC 2365:
	39	+ * Administratively Scoped IP Multicast</i></a>
	40	+ *
	41	+ * <h4> <A NAME="format">Textual representation of IP addresses</a> </h4>
	42	+ *
	43	+ * Textual representation of IPv4 address used as input to methods
	44	+ * takes one of the following forms:
	45	+ *
	46	+ * <blockquote><table cellpadding=0 cellspacing=0 summary="layout">
	47	+ * <tr><td><tt>d.d.d.d</tt></td></tr>
	48	+ * <tr><td><tt>d.d.d</tt></td></tr>
	49	+ * <tr><td><tt>d.d</tt></td></tr>
	50	+ * <tr><td><tt>d</tt></td></tr>
	51	+ * </table></blockquote>
	52	+ *
	53	+ * <p> When four parts are specified, each is interpreted as a byte of
	54	+ * data and assigned, from left to right, to the four bytes of an IPv4
	55	+ * address.
	56	+
	57	+ * <p> When a three part address is specified, the last part is
	58	+ * interpreted as a 16-bit quantity and placed in the right most two
	59	+ * bytes of the network address. This makes the three part address
	60	+ * format convenient for specifying Class B net- work addresses as
	61	+ * 128.net.host.
	62	+ *
	63	+ * <p> When a two part address is supplied, the last part is
	64	+ * interpreted as a 24-bit quantity and placed in the right most three
	65	+ * bytes of the network address. This makes the two part address
	66	+ * format convenient for specifying Class A network addresses as
	67	+ * net.host.
	68	+ *
	69	+ * <p> When only one part is given, the value is stored directly in
	70	+ * the network address without any byte rearrangement.
	71	+ *
	72	+ * <p> For methods that return a textual representation as output
	73	+ * value, the first form, i.e. a dotted-quad string, is used.
	74	+ *
	75	+ * <h4> The Scope of a Multicast Address </h4>
	76	+ *
	77	+ * Historically the IPv4 TTL field in the IP header has doubled as a
	78	+ * multicast scope field: a TTL of 0 means node-local, 1 means
	79	+ * link-local, up through 32 means site-local, up through 64 means
	80	+ * region-local, up through 128 means continent-local, and up through
	81	+ * 255 are global. However, the administrative scoping is preferred.
	82	+ * Please refer to <a href="http://www.ietf.org/rfc/rfc2365.txt">
	83	+ * <i>RFC 2365: Administratively Scoped IP Multicast</i></a>
	84	+ * @since 1.4
	85	+ */
	86	+
	87	+public final
	88	+class Inet4Address extends InetAddress {
	89	+ final static int INADDRSZ = 4;
	90	+
	91	+ /** use serialVersionUID from InetAddress, but Inet4Address instance
	92	+ * is always replaced by an InetAddress instance before being
	93	+ * serialized */
	94	+ private static final long serialVersionUID = 3286316764910316507L;
	95	+
	96	+ /*
	97	+ * Perform initializations.
	98	+ */
	99	+ static {
	100	+ init();
	101	+ }
	102	+
	103	+ Inet4Address() {
	104	+ super();
	105	+ hostName = null;
	106	+ address = 0;
	107	+ family = IPv4;
	108	+ }
	109	+
	110	+ Inet4Address(String hostName, byte addr[]) {
	111	+ this.hostName = hostName;
	112	+ this.family = IPv4;
	113	+ if (addr != null) {
	114	+ if (addr.length == INADDRSZ) {
	115	+ address = addr[3] & 0xFF;
	116	+ address \|= ((addr[2] << 8) & 0xFF00);
	117	+ address \|= ((addr[1] << 16) & 0xFF0000);
	118	+ address \|= ((addr[0] << 24) & 0xFF000000);
	119	+ }
	120	+ }
	121	+ }
	122	+ Inet4Address(String hostName, int address) {
	123	+ this.hostName = hostName;
	124	+ this.family = IPv4;
	125	+ this.address = address;
	126	+ }
	127	+
	128	+ /**
	129	+ * Replaces the object to be serialized with an InetAddress object.
	130	+ *
	131	+ * @return the alternate object to be serialized.
	132	+ *
	133	+ * @throws ObjectStreamException if a new object replacing this
	134	+ * object could not be created
	135	+ */
	136	+ private Object writeReplace() throws ObjectStreamException {
	137	+ // will replace the to be serialized 'this' object
	138	+ InetAddress inet = new InetAddress();
	139	+ inet.hostName = this.hostName;
	140	+ inet.address = this.address;
	141	+
	142	+ /**
	143	+ * Prior to 1.4 an InetAddress was created with a family
	144	+ * based on the platform AF_INET value (usually 2).
	145	+ * For compatibility reasons we must therefore write the
	146	+ * the InetAddress with this family.
	147	+ */
	148	+ inet.family = 2;
	149	+
	150	+ return inet;
	151	+ }
	152	+
	153	+ /**
	154	+ * Utility routine to check if the InetAddress is an
	155	+ * IP multicast address. IP multicast address is a Class D
	156	+ * address i.e first four bits of the address are 1110.
	157	+ * @return a <code>boolean</code> indicating if the InetAddress is
	158	+ * an IP multicast address
	159	+ * @since JDK1.1
	160	+ */
	161	+ public boolean isMulticastAddress() {
	162	+ return ((address & 0xf0000000) == 0xe0000000);
	163	+ }
	164	+
	165	+ /**
	166	+ * Utility routine to check if the InetAddress in a wildcard address.
	167	+ * @return a <code>boolean</code> indicating if the Inetaddress is
	168	+ * a wildcard address.
	169	+ * @since 1.4
	170	+ */
	171	+ public boolean isAnyLocalAddress() {
	172	+ return address == 0;
	173	+ }
	174	+
	175	+ /**
	176	+ * Utility routine to check if the InetAddress is a loopback address.
	177	+ *
	178	+ * @return a <code>boolean</code> indicating if the InetAddress is
	179	+ * a loopback address; or false otherwise.
	180	+ * @since 1.4
	181	+ */
	182	+ private static final int loopback = 2130706433; /* 127.0.0.1 */
	183	+ public boolean isLoopbackAddress() {
	184	+ /* 127.x.x.x */
	185	+ byte[] byteAddr = getAddress();
	186	+ return byteAddr[0] == 127;
	187	+ }
	188	+
	189	+ /**
	190	+ * Utility routine to check if the InetAddress is an link local address.
	191	+ *
	192	+ * @return a <code>boolean</code> indicating if the InetAddress is
	193	+ * a link local address; or false if address is not a link local unicast address.
	194	+ * @since 1.4
	195	+ */
	196	+ public boolean isLinkLocalAddress() {
	197	+ // link-local unicast in IPv4 (169.254.0.0/16)
	198	+ // defined in "Documenting Special Use IPv4 Address Blocks
	199	+ // that have been Registered with IANA" by Bill Manning
	200	+ // draft-manning-dsua-06.txt
	201	+ return (((address >>> 24) & 0xFF) == 169)
	202	+ && (((address >>> 16) & 0xFF) == 254);
	203	+ }
	204	+
	205	+ /**
	206	+ * Utility routine to check if the InetAddress is a site local address.
	207	+ *
	208	+ * @return a <code>boolean</code> indicating if the InetAddress is
	209	+ * a site local address; or false if address is not a site local unicast address.
	210	+ * @since 1.4
	211	+ */
	212	+ public boolean isSiteLocalAddress() {
	213	+ // refer to RFC 1918
	214	+ // 10/8 prefix
	215	+ // 172.16/12 prefix
	216	+ // 192.168/16 prefix
	217	+ return (((address >>> 24) & 0xFF) == 10)
	218	+ \|\| ((((address >>> 24) & 0xFF) == 172)
	219	+ && (((address >>> 16) & 0xF0) == 16))
	220	+ \|\| ((((address >>> 24) & 0xFF) == 192)
	221	+ && (((address >>> 16) & 0xFF) == 168));
	222	+ }
	223	+
	224	+ /**
	225	+ * Utility routine to check if the multicast address has global scope.
	226	+ *
	227	+ * @return a <code>boolean</code> indicating if the address has
	228	+ * is a multicast address of global scope, false if it is not
	229	+ * of global scope or it is not a multicast address
	230	+ * @since 1.4
	231	+ */
	232	+ public boolean isMCGlobal() {
	233	+ // 224.0.1.0 to 238.255.255.255
	234	+ byte[] byteAddr = getAddress();
	235	+ return ((byteAddr[0] & 0xff) >= 224 && (byteAddr[0] & 0xff) <= 238 ) &&
	236	+ !((byteAddr[0] & 0xff) == 224 && byteAddr[1] == 0 &&
	237	+ byteAddr[2] == 0);
	238	+ }
	239	+
	240	+ /**
	241	+ * Utility routine to check if the multicast address has node scope.
	242	+ *
	243	+ * @return a <code>boolean</code> indicating if the address has
	244	+ * is a multicast address of node-local scope, false if it is not
	245	+ * of node-local scope or it is not a multicast address
	246	+ * @since 1.4
	247	+ */
	248	+ public boolean isMCNodeLocal() {
	249	+ // unless ttl == 0
	250	+ return false;
	251	+ }
	252	+
	253	+ /**
	254	+ * Utility routine to check if the multicast address has link scope.
	255	+ *
	256	+ * @return a <code>boolean</code> indicating if the address has
	257	+ * is a multicast address of link-local scope, false if it is not
	258	+ * of link-local scope or it is not a multicast address
	259	+ * @since 1.4
	260	+ */
	261	+ public boolean isMCLinkLocal() {
	262	+ // 224.0.0/24 prefix and ttl == 1
	263	+ return (((address >>> 24) & 0xFF) == 224)
	264	+ && (((address >>> 16) & 0xFF) == 0)
	265	+ && (((address >>> 8) & 0xFF) == 0);
	266	+ }
	267	+
	268	+ /**
	269	+ * Utility routine to check if the multicast address has site scope.
	270	+ *
	271	+ * @return a <code>boolean</code> indicating if the address has
	272	+ * is a multicast address of site-local scope, false if it is not
	273	+ * of site-local scope or it is not a multicast address
	274	+ * @since 1.4
	275	+ */
	276	+ public boolean isMCSiteLocal() {
	277	+ // 239.255/16 prefix or ttl < 32
	278	+ return (((address >>> 24) & 0xFF) == 239)
	279	+ && (((address >>> 16) & 0xFF) == 255);
	280	+ }
	281	+
	282	+ /**
	283	+ * Utility routine to check if the multicast address has organization scope.
	284	+ *
	285	+ * @return a <code>boolean</code> indicating if the address has
	286	+ * is a multicast address of organization-local scope,
	287	+ * false if it is not of organization-local scope
	288	+ * or it is not a multicast address
	289	+ * @since 1.4
	290	+ */
	291	+ public boolean isMCOrgLocal() {
	292	+ // 239.192 - 239.195
	293	+ return (((address >>> 24) & 0xFF) == 239)
	294	+ && (((address >>> 16) & 0xFF) >= 192)
	295	+ && (((address >>> 16) & 0xFF) <= 195);
	296	+ }
	297	+
	298	+ /**
	299	+ * Returns the raw IP address of this <code>InetAddress</code>
	300	+ * object. The result is in network byte order: the highest order
	301	+ * byte of the address is in <code>getAddress()[0]</code>.
	302	+ *
	303	+ * @return the raw IP address of this object.
	304	+ */
	305	+ public byte[] getAddress() {
	306	+ byte[] addr = new byte[INADDRSZ];
	307	+
	308	+ addr[0] = (byte) ((address >>> 24) & 0xFF);
	309	+ addr[1] = (byte) ((address >>> 16) & 0xFF);
	310	+ addr[2] = (byte) ((address >>> 8) & 0xFF);
	311	+ addr[3] = (byte) (address & 0xFF);
	312	+ return addr;
	313	+ }
	314	+
	315	+ /**
	316	+ * Returns the IP address string in textual presentation form.
	317	+ *
	318	+ * @return the raw IP address in a string format.
	319	+ * @since JDK1.0.2
	320	+ */
	321	+ public String getHostAddress() {
	322	+ return numericToTextFormat(getAddress());
	323	+ }
	324	+
	325	+ /**
	326	+ * Returns a hashcode for this IP address.
	327	+ *
	328	+ * @return a hash code value for this IP address.
	329	+ */
	330	+ public int hashCode() {
	331	+ return address;
	332	+ }
	333	+
	334	+ /**
	335	+ * Compares this object against the specified object.
	336	+ * The result is <code>true</code> if and only if the argument is
	337	+ * not <code>null</code> and it represents the same IP address as
	338	+ * this object.
	339	+ * <p>
	340	+ * Two instances of <code>InetAddress</code> represent the same IP
	341	+ * address if the length of the byte arrays returned by
	342	+ * <code>getAddress</code> is the same for both, and each of the
	343	+ * array components is the same for the byte arrays.
	344	+ *
	345	+ * @param obj the object to compare against.
	346	+ * @return <code>true</code> if the objects are the same;
	347	+ * <code>false</code> otherwise.
	348	+ * @see java.net.InetAddress#getAddress()
	349	+ */
	350	+ public boolean equals(Object obj) {
	351	+ return (obj != null) && (obj instanceof Inet4Address) &&
	352	+ (((InetAddress)obj).address == address);
	353	+ }
	354	+
	355	+ // Utilities
	356	+ /*
	357	+ * Converts IPv4 binary address into a string suitable for presentation.
	358	+ *
	359	+ * @param src a byte array representing an IPv4 numeric address
	360	+ * @return a String representing the IPv4 address in
	361	+ * textual representation format
	362	+ * @since 1.4
	363	+ */
	364	+
	365	+ static String numericToTextFormat(byte[] src)
	366	+ {
	367	+ return (src[0] & 0xff) + "." + (src[1] & 0xff) + "." + (src[2] & 0xff) + "." + (src[3] & 0xff);
	368	+ }
	369	+
	370	+ /**
	371	+ * Perform class load-time initializations.
	372	+ */
	373	+ private static native void init();
	374	+}

java/pkg/java/net/Inet4AddressImpl.class+0−0

Binary file not shown.

java/pkg/java/net/Inet4AddressImpl.java+74−0

@@ -0,0 +1,74 @@
	1	+/*
	2	+ * Copyright (c) 2002, 2005, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+package java.net;
	26	+import java.io.IOException;
	27	+
	28	+/*
	29	+ * Package private implementation of InetAddressImpl for IPv4.
	30	+ *
	31	+ * @since 1.4
	32	+ */
	33	+class Inet4AddressImpl implements InetAddressImpl {
	34	+ public native String getLocalHostName() throws UnknownHostException;
	35	+ public native InetAddress[]
	36	+ lookupAllHostAddr(String hostname) throws UnknownHostException;
	37	+ public native String getHostByAddr(byte[] addr) throws UnknownHostException;
	38	+ private native boolean isReachable0(byte[] addr, int timeout, byte[] ifaddr, int ttl) throws IOException;
	39	+
	40	+ public synchronized InetAddress anyLocalAddress() {
	41	+ if (anyLocalAddress == null) {
	42	+ anyLocalAddress = new Inet4Address(); // {0x00,0x00,0x00,0x00}
	43	+ anyLocalAddress.hostName = "0.0.0.0";
	44	+ }
	45	+ return anyLocalAddress;
	46	+ }
	47	+
	48	+ public synchronized InetAddress loopbackAddress() {
	49	+ if (loopbackAddress == null) {
	50	+ byte[] loopback = {0x7f,0x00,0x00,0x01};
	51	+ loopbackAddress = new Inet4Address("localhost", loopback);
	52	+ }
	53	+ return loopbackAddress;
	54	+ }
	55	+
	56	+ public boolean isReachable(InetAddress addr, int timeout, NetworkInterface netif, int ttl) throws IOException {
	57	+ byte[] ifaddr = null;
	58	+ if (netif != null) {
	59	+ /*
	60	+ * Let's make sure we use an address of the proper family
	61	+ */
	62	+ java.util.Enumeration it = netif.getInetAddresses();
	63	+ InetAddress inetaddr = null;
	64	+ while (!(inetaddr instanceof Inet4Address) &&
	65	+ it.hasMoreElements())
	66	+ inetaddr = (InetAddress) it.nextElement();
	67	+ if (inetaddr instanceof Inet4Address)
	68	+ ifaddr = inetaddr.getAddress();
	69	+ }
	70	+ return isReachable0(addr.getAddress(), timeout, ifaddr, ttl);
	71	+ }
	72	+ private InetAddress anyLocalAddress;
	73	+ private InetAddress loopbackAddress;
	74	+}

java/pkg/java/net/Inet6Address.class+0−0

Binary file not shown.

java/pkg/java/net/Inet6Address.java+774−0

@@ -0,0 +1,774 @@
	1	+/*
	2	+ * Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.io.ObjectInputStream;
	29	+import java.io.IOException;
	30	+import java.io.InvalidObjectException;
	31	+import java.util.Enumeration;
	32	+
	33	+/**
	34	+ * This class represents an Internet Protocol version 6 (IPv6) address.
	35	+ * Defined by <a href="http://www.ietf.org/rfc/rfc2373.txt">
	36	+ * <i>RFC 2373: IP Version 6 Addressing Architecture</i></a>.
	37	+ *
	38	+ * <h4> <A NAME="format">Textual representation of IP addresses</a> </h4>
	39	+ *
	40	+ * Textual representation of IPv6 address used as input to methods
	41	+ * takes one of the following forms:
	42	+ *
	43	+ * <ol>
	44	+ * <li><p> <A NAME="lform">The preferred form</a> is x:x:x:x:x:x:x:x,
	45	+ * where the 'x's are
	46	+ * the hexadecimal values of the eight 16-bit pieces of the
	47	+ * address. This is the full form. For example,
	48	+ *
	49	+ * <blockquote><table cellpadding=0 cellspacing=0 summary="layout">
	50	+ * <tr><td><tt>1080:0:0:0:8:800:200C:417A</tt><td></tr>
	51	+ * </table></blockquote>
	52	+ *
	53	+ * <p> Note that it is not necessary to write the leading zeros in
	54	+ * an individual field. However, there must be at least one numeral
	55	+ * in every field, except as described below.</li>
	56	+ *
	57	+ * <li><p> Due to some methods of allocating certain styles of IPv6
	58	+ * addresses, it will be common for addresses to contain long
	59	+ * strings of zero bits. In order to make writing addresses
	60	+ * containing zero bits easier, a special syntax is available to
	61	+ * compress the zeros. The use of "::" indicates multiple groups
	62	+ * of 16-bits of zeros. The "::" can only appear once in an address.
	63	+ * The "::" can also be used to compress the leading and/or trailing
	64	+ * zeros in an address. For example,
	65	+ *
	66	+ * <blockquote><table cellpadding=0 cellspacing=0 summary="layout">
	67	+ * <tr><td><tt>1080::8:800:200C:417A</tt><td></tr>
	68	+ * </table></blockquote>
	69	+ *
	70	+ * <li><p> An alternative form that is sometimes more convenient
	71	+ * when dealing with a mixed environment of IPv4 and IPv6 nodes is
	72	+ * x:x:x:x:x:x:d.d.d.d, where the 'x's are the hexadecimal values
	73	+ * of the six high-order 16-bit pieces of the address, and the 'd's
	74	+ * are the decimal values of the four low-order 8-bit pieces of the
	75	+ * standard IPv4 representation address, for example,
	76	+ *
	77	+ * <blockquote><table cellpadding=0 cellspacing=0 summary="layout">
	78	+ * <tr><td><tt>::FFFF:129.144.52.38</tt><td></tr>
	79	+ * <tr><td><tt>::129.144.52.38</tt><td></tr>
	80	+ * </table></blockquote>
	81	+ *
	82	+ * <p> where "::FFFF:d.d.d.d" and "::d.d.d.d" are, respectively, the
	83	+ * general forms of an IPv4-mapped IPv6 address and an
	84	+ * IPv4-compatible IPv6 address. Note that the IPv4 portion must be
	85	+ * in the "d.d.d.d" form. The following forms are invalid:
	86	+ *
	87	+ * <blockquote><table cellpadding=0 cellspacing=0 summary="layout">
	88	+ * <tr><td><tt>::FFFF:d.d.d</tt><td></tr>
	89	+ * <tr><td><tt>::FFFF:d.d</tt><td></tr>
	90	+ * <tr><td><tt>::d.d.d</tt><td></tr>
	91	+ * <tr><td><tt>::d.d</tt><td></tr>
	92	+ * </table></blockquote>
	93	+ *
	94	+ * <p> The following form:
	95	+ *
	96	+ * <blockquote><table cellpadding=0 cellspacing=0 summary="layout">
	97	+ * <tr><td><tt>::FFFF:d</tt><td></tr>
	98	+ * </table></blockquote>
	99	+ *
	100	+ * <p> is valid, however it is an unconventional representation of
	101	+ * the IPv4-compatible IPv6 address,
	102	+ *
	103	+ * <blockquote><table cellpadding=0 cellspacing=0 summary="layout">
	104	+ * <tr><td><tt>::255.255.0.d</tt><td></tr>
	105	+ * </table></blockquote>
	106	+ *
	107	+ * <p> while "::d" corresponds to the general IPv6 address
	108	+ * "0:0:0:0:0:0:0:d".</li>
	109	+ * </ol>
	110	+ *
	111	+ * <p> For methods that return a textual representation as output
	112	+ * value, the full form is used. Inet6Address will return the full
	113	+ * form because it is unambiguous when used in combination with other
	114	+ * textual data.
	115	+ *
	116	+ * <h4> Special IPv6 address </h4>
	117	+ *
	118	+ * <blockquote>
	119	+ * <table cellspacing=2 summary="Description of IPv4-mapped address"> <tr><th valign=top><i>IPv4-mapped address</i></th>
	120	+ * <td>Of the form::ffff:w.x.y.z, this IPv6 address is used to
	121	+ * represent an IPv4 address. It allows the native program to
	122	+ * use the same address data structure and also the same
	123	+ * socket when communicating with both IPv4 and IPv6 nodes.
	124	+ *
	125	+ * <p>In InetAddress and Inet6Address, it is used for internal
	126	+ * representation; it has no functional role. Java will never
	127	+ * return an IPv4-mapped address. These classes can take an
	128	+ * IPv4-mapped address as input, both in byte array and text
	129	+ * representation. However, it will be converted into an IPv4
	130	+ * address.</td></tr>
	131	+ * </table></blockquote>
	132	+ * <p>
	133	+ * <h4> <A NAME="scoped">Textual representation of IPv6 scoped addresses</a> </h4>
	134	+ * <p>
	135	+ * The textual representation of IPv6 addresses as described above can be extended
	136	+ * to specify IPv6 scoped addresses. This extension to the basic addressing architecture
	137	+ * is described in [draft-ietf-ipngwg-scoping-arch-04.txt].
	138	+ * <p>
	139	+ * Because link-local and site-local addresses are non-global, it is possible that different hosts
	140	+ * may have the same destination address and may be reachable through different interfaces on the
	141	+ * same originating system. In this case, the originating system is said to be connected
	142	+ * to multiple zones of the same scope. In order to disambiguate which is the intended destination
	143	+ * zone, it is possible to append a zone identifier (or <i>scope_id</i>) to an IPv6 address.
	144	+ * <p>
	145	+ * The general format for specifying the <i>scope_id</i> is the following:
	146	+ * <p><blockquote><i>IPv6-address</i>%<i>scope_id</i></blockquote>
	147	+ * <p> The IPv6-address is a literal IPv6 address as described above.
	148	+ * The <i>scope_id</i> refers to an interface on the local system, and it can be specified
	149	+ * in two ways.
	150	+ * <p><ol><li><i>As a numeric identifier.</i> This must be a positive integer that identifies the
	151	+ * particular interface and scope as understood by the system. Usually, the numeric
	152	+ * values can be determined through administration tools on the system. Each interface may
	153	+ * have multiple values, one for each scope. If the scope is unspecified, then the default value
	154	+ * used is zero.</li><p>
	155	+ * <li><i>As a string.</i> This must be the exact string that is returned by
	156	+ * {@link java.net.NetworkInterface#getName()} for the particular interface in question.
	157	+ * When an Inet6Address is created in this way, the numeric scope-id is determined at the time
	158	+ * the object is created by querying the relevant NetworkInterface.</li>
	159	+ * </ol><p>
	160	+ * Note also, that the numeric <i>scope_id</i> can be retrieved from Inet6Address instances returned from the
	161	+ * NetworkInterface class. This can be used to find out the current scope ids configured on the system.
	162	+ * @since 1.4
	163	+ */
	164	+
	165	+public final
	166	+class Inet6Address extends InetAddress {
	167	+ final static int INADDRSZ = 16;
	168	+
	169	+ /*
	170	+ * cached scope_id - for link-local address use only.
	171	+ */
	172	+ private transient int cached_scope_id = 0;
	173	+
	174	+ /**
	175	+ * Holds a 128-bit (16 bytes) IPv6 address.
	176	+ *
	177	+ * @serial
	178	+ */
	179	+ byte[] ipaddress;
	180	+
	181	+ /**
	182	+ * scope_id. The scope specified when the object is created. If the object is created
	183	+ * with an interface name, then the scope_id is not determined until the time it is needed.
	184	+ */
	185	+ private int scope_id = 0;
	186	+
	187	+ /**
	188	+ * This will be set to true when the scope_id field contains a valid
	189	+ * integer scope_id.
	190	+ */
	191	+ private boolean scope_id_set = false;
	192	+
	193	+ /**
	194	+ * scoped interface. scope_id is derived from this as the scope_id of the first
	195	+ * address whose scope is the same as this address for the named interface.
	196	+ */
	197	+ private transient NetworkInterface scope_ifname = null;
	198	+
	199	+ /**
	200	+ * set if the object is constructed with a scoped interface instead of a
	201	+ * numeric scope id.
	202	+ */
	203	+ private boolean scope_ifname_set = false;
	204	+
	205	+ private static final long serialVersionUID = 6880410070516793377L;
	206	+
	207	+ /*
	208	+ * Perform initializations.
	209	+ */
	210	+ static {
	211	+ init();
	212	+ }
	213	+
	214	+ Inet6Address() {
	215	+ super();
	216	+ hostName = null;
	217	+ ipaddress = new byte[INADDRSZ];
	218	+ family = IPv6;
	219	+ }
	220	+
	221	+ /* checking of value for scope_id should be done by caller
	222	+ * scope_id must be >= 0, or -1 to indicate not being set
	223	+ */
	224	+ Inet6Address(String hostName, byte addr[], int scope_id) {
	225	+ this.hostName = hostName;
	226	+ if (addr.length == INADDRSZ) { // normal IPv6 address
	227	+ family = IPv6;
	228	+ ipaddress = addr.clone();
	229	+ }
	230	+ if (scope_id >= 0) {
	231	+ this.scope_id = scope_id;
	232	+ scope_id_set = true;
	233	+ }
	234	+ }
	235	+
	236	+ Inet6Address(String hostName, byte addr[]) {
	237	+ try {
	238	+ initif (hostName, addr, null);
	239	+ } catch (UnknownHostException e) {} /* cant happen if ifname is null */
	240	+ }
	241	+
	242	+ Inet6Address (String hostName, byte addr[], NetworkInterface nif) throws UnknownHostException {
	243	+ initif (hostName, addr, nif);
	244	+ }
	245	+
	246	+ Inet6Address (String hostName, byte addr[], String ifname) throws UnknownHostException {
	247	+ initstr (hostName, addr, ifname);
	248	+ }
	249	+
	250	+ /**
	251	+ * Create an Inet6Address in the exact manner of {@link InetAddress#getByAddress(String,byte[])}
	252	+ * except that the IPv6 scope_id is set to the value corresponding to the given interface
	253	+ * for the address type specified in <code>addr</code>.
	254	+ * The call will fail with an UnknownHostException if the given interface does not have a numeric
	255	+ * scope_id assigned for the given address type (eg. link-local or site-local).
	256	+ * See <a href="Inet6Address.html#scoped">here</a> for a description of IPv6
	257	+ * scoped addresses.
	258	+ *
	259	+ * @param host the specified host
	260	+ * @param addr the raw IP address in network byte order
	261	+ * @param nif an interface this address must be associated with.
	262	+ * @return an Inet6Address object created from the raw IP address.
	263	+ * @exception UnknownHostException if IP address is of illegal length, or if the interface
	264	+ * does not have a numeric scope_id assigned for the given address type.
	265	+ *
	266	+ * @since 1.5
	267	+ */
	268	+
	269	+ public static Inet6Address getByAddress(String host, byte[] addr, NetworkInterface nif)
	270	+ throws UnknownHostException {
	271	+ if (host != null && host.length() > 0 && host.charAt(0) == '[') {
	272	+ if (host.charAt(host.length()-1) == ']') {
	273	+ host = host.substring(1, host.length() -1);
	274	+ }
	275	+ }
	276	+ if (addr != null) {
	277	+ if (addr.length == Inet6Address.INADDRSZ) {
	278	+ return new Inet6Address(host, addr, nif);
	279	+ }
	280	+ }
	281	+ throw new UnknownHostException("addr is of illegal length");
	282	+ }
	283	+
	284	+ /**
	285	+ * Create an Inet6Address in the exact manner of {@link InetAddress#getByAddress(String,byte[])}
	286	+ * except that the IPv6 scope_id is set to the given numeric value.
	287	+ * The scope_id is not checked to determine if it corresponds to any interface on the system.
	288	+ * See <a href="Inet6Address.html#scoped">here</a> for a description of IPv6
	289	+ * scoped addresses.
	290	+ *
	291	+ * @param host the specified host
	292	+ * @param addr the raw IP address in network byte order
	293	+ * @param scope_id the numeric scope_id for the address.
	294	+ * @return an Inet6Address object created from the raw IP address.
	295	+ * @exception UnknownHostException if IP address is of illegal length.
	296	+ *
	297	+ * @since 1.5
	298	+ */
	299	+
	300	+ public static Inet6Address getByAddress(String host, byte[] addr, int scope_id)
	301	+ throws UnknownHostException {
	302	+ if (host != null && host.length() > 0 && host.charAt(0) == '[') {
	303	+ if (host.charAt(host.length()-1) == ']') {
	304	+ host = host.substring(1, host.length() -1);
	305	+ }
	306	+ }
	307	+ if (addr != null) {
	308	+ if (addr.length == Inet6Address.INADDRSZ) {
	309	+ return new Inet6Address(host, addr, scope_id);
	310	+ }
	311	+ }
	312	+ throw new UnknownHostException("addr is of illegal length");
	313	+ }
	314	+
	315	+ private void initstr (String hostName, byte addr[], String ifname) throws UnknownHostException {
	316	+ try {
	317	+ NetworkInterface nif = NetworkInterface.getByName (ifname);
	318	+ if (nif == null) {
	319	+ throw new UnknownHostException ("no such interface " + ifname);
	320	+ }
	321	+ initif (hostName, addr, nif);
	322	+ } catch (SocketException e) {
	323	+ throw new UnknownHostException ("SocketException thrown" + ifname);
	324	+ }
	325	+ }
	326	+
	327	+ private void initif(String hostName, byte addr[],NetworkInterface nif) throws UnknownHostException {
	328	+ this.hostName = hostName;
	329	+ if (addr.length == INADDRSZ) { // normal IPv6 address
	330	+ family = IPv6;
	331	+ ipaddress = addr.clone();
	332	+ }
	333	+ if (nif != null) {
	334	+ this.scope_ifname = nif;
	335	+ scope_ifname_set = true;
	336	+ scope_id = deriveNumericScope (nif);
	337	+ scope_id_set = true;
	338	+ }
	339	+ }
	340	+
	341	+ /* check the two Ipv6 addresses and return false if they are both
	342	+ * non global address types, but not the same.
	343	+ * (ie. one is sitelocal and the other linklocal)
	344	+ * return true otherwise.
	345	+ */
	346	+ private boolean differentLocalAddressTypes(Inet6Address other) {
	347	+
	348	+ if (isLinkLocalAddress() && !other.isLinkLocalAddress()) {
	349	+ return false;
	350	+ }
	351	+ if (isSiteLocalAddress() && !other.isSiteLocalAddress()) {
	352	+ return false;
	353	+ }
	354	+ return true;
	355	+ }
	356	+
	357	+ private int deriveNumericScope (NetworkInterface ifc) throws UnknownHostException {
	358	+ Enumeration<InetAddress> addresses = ifc.getInetAddresses();
	359	+ while (addresses.hasMoreElements()) {
	360	+ InetAddress addr = addresses.nextElement();
	361	+ if (!(addr instanceof Inet6Address)) {
	362	+ continue;
	363	+ }
	364	+ Inet6Address ia6_addr = (Inet6Address)addr;
	365	+ /* check if site or link local prefixes match */
	366	+ if (!differentLocalAddressTypes(ia6_addr)){
	367	+ /* type not the same, so carry on searching */
	368	+ continue;
	369	+ }
	370	+ /* found a matching address - return its scope_id */
	371	+ return ia6_addr.scope_id;
	372	+ }
	373	+ throw new UnknownHostException ("no scope_id found");
	374	+ }
	375	+
	376	+ private int deriveNumericScope (String ifname) throws UnknownHostException {
	377	+ Enumeration<NetworkInterface> en;
	378	+ try {
	379	+ en = NetworkInterface.getNetworkInterfaces();
	380	+ } catch (SocketException e) {
	381	+ throw new UnknownHostException ("could not enumerate local network interfaces");
	382	+ }
	383	+ while (en.hasMoreElements()) {
	384	+ NetworkInterface ifc = en.nextElement();
	385	+ if (ifc.getName().equals (ifname)) {
	386	+ Enumeration addresses = ifc.getInetAddresses();
	387	+ while (addresses.hasMoreElements()) {
	388	+ InetAddress addr = (InetAddress)addresses.nextElement();
	389	+ if (!(addr instanceof Inet6Address)) {
	390	+ continue;
	391	+ }
	392	+ Inet6Address ia6_addr = (Inet6Address)addr;
	393	+ /* check if site or link local prefixes match */
	394	+ if (!differentLocalAddressTypes(ia6_addr)){
	395	+ /* type not the same, so carry on searching */
	396	+ continue;
	397	+ }
	398	+ /* found a matching address - return its scope_id */
	399	+ return ia6_addr.scope_id;
	400	+ }
	401	+ }
	402	+ }
	403	+ throw new UnknownHostException ("No matching address found for interface : " +ifname);
	404	+ }
	405	+
	406	+ /**
	407	+ * restore the state of this object from stream
	408	+ * including the scope information, only if the
	409	+ * scoped interface name is valid on this system
	410	+ */
	411	+ private void readObject(ObjectInputStream s)
	412	+ throws IOException, ClassNotFoundException {
	413	+ scope_ifname = null;
	414	+ scope_ifname_set = false;
	415	+ s.defaultReadObject();
	416	+
	417	+ if (ifname != null && !"".equals (ifname)) {
	418	+ try {
	419	+ scope_ifname = NetworkInterface.getByName(ifname);
	420	+ if (scope_ifname == null) {
	421	+ /* the interface does not exist on this system, so we clear
	422	+ * the scope information completely */
	423	+ scope_id_set = false;
	424	+ scope_ifname_set = false;
	425	+ scope_id = 0;
	426	+ } else {
	427	+ try {
	428	+ scope_id = deriveNumericScope (scope_ifname);
	429	+ } catch (UnknownHostException e) {
	430	+ // typically should not happen, but it may be that
	431	+ // the machine being used for deserialization has
	432	+ // the same interface name but without IPv6 configured.
	433	+ }
	434	+ }
	435	+ } catch (SocketException e) {}
	436	+
	437	+ }
	438	+ /* if ifname was not supplied, then the numeric info is used */
	439	+
	440	+ ipaddress = ipaddress.clone();
	441	+
	442	+ // Check that our invariants are satisfied
	443	+ if (ipaddress.length != INADDRSZ) {
	444	+ throw new InvalidObjectException("invalid address length: "+
	445	+ ipaddress.length);
	446	+ }
	447	+
	448	+ if (family != IPv6) {
	449	+ throw new InvalidObjectException("invalid address family type");
	450	+ }
	451	+ }
	452	+
	453	+ /**
	454	+ * Utility routine to check if the InetAddress is an IP multicast
	455	+ * address. 11111111 at the start of the address identifies the
	456	+ * address as being a multicast address.
	457	+ *
	458	+ * @return a <code>boolean</code> indicating if the InetAddress is
	459	+ * an IP multicast address
	460	+ * @since JDK1.1
	461	+ */
	462	+ @Override
	463	+ public boolean isMulticastAddress() {
	464	+ return ((ipaddress[0] & 0xff) == 0xff);
	465	+ }
	466	+
	467	+ /**
	468	+ * Utility routine to check if the InetAddress in a wildcard address.
	469	+ * @return a <code>boolean</code> indicating if the Inetaddress is
	470	+ * a wildcard address.
	471	+ * @since 1.4
	472	+ */
	473	+ @Override
	474	+ public boolean isAnyLocalAddress() {
	475	+ byte test = 0x00;
	476	+ for (int i = 0; i < INADDRSZ; i++) {
	477	+ test \|= ipaddress[i];
	478	+ }
	479	+ return (test == 0x00);
	480	+ }
	481	+
	482	+ /**
	483	+ * Utility routine to check if the InetAddress is a loopback address.
	484	+ *
	485	+ * @return a <code>boolean</code> indicating if the InetAddress is
	486	+ * a loopback address; or false otherwise.
	487	+ * @since 1.4
	488	+ */
	489	+ @Override
	490	+ public boolean isLoopbackAddress() {
	491	+ byte test = 0x00;
	492	+ for (int i = 0; i < 15; i++) {
	493	+ test \|= ipaddress[i];
	494	+ }
	495	+ return (test == 0x00) && (ipaddress[15] == 0x01);
	496	+ }
	497	+
	498	+ /**
	499	+ * Utility routine to check if the InetAddress is an link local address.
	500	+ *
	501	+ * @return a <code>boolean</code> indicating if the InetAddress is
	502	+ * a link local address; or false if address is not a link local unicast address.
	503	+ * @since 1.4
	504	+ */
	505	+ @Override
	506	+ public boolean isLinkLocalAddress() {
	507	+ return ((ipaddress[0] & 0xff) == 0xfe
	508	+ && (ipaddress[1] & 0xc0) == 0x80);
	509	+ }
	510	+
	511	+ /**
	512	+ * Utility routine to check if the InetAddress is a site local address.
	513	+ *
	514	+ * @return a <code>boolean</code> indicating if the InetAddress is
	515	+ * a site local address; or false if address is not a site local unicast address.
	516	+ * @since 1.4
	517	+ */
	518	+ @Override
	519	+ public boolean isSiteLocalAddress() {
	520	+ return ((ipaddress[0] & 0xff) == 0xfe
	521	+ && (ipaddress[1] & 0xc0) == 0xc0);
	522	+ }
	523	+
	524	+ /**
	525	+ * Utility routine to check if the multicast address has global scope.
	526	+ *
	527	+ * @return a <code>boolean</code> indicating if the address has
	528	+ * is a multicast address of global scope, false if it is not
	529	+ * of global scope or it is not a multicast address
	530	+ * @since 1.4
	531	+ */
	532	+ @Override
	533	+ public boolean isMCGlobal() {
	534	+ return ((ipaddress[0] & 0xff) == 0xff
	535	+ && (ipaddress[1] & 0x0f) == 0x0e);
	536	+ }
	537	+
	538	+ /**
	539	+ * Utility routine to check if the multicast address has node scope.
	540	+ *
	541	+ * @return a <code>boolean</code> indicating if the address has
	542	+ * is a multicast address of node-local scope, false if it is not
	543	+ * of node-local scope or it is not a multicast address
	544	+ * @since 1.4
	545	+ */
	546	+ @Override
	547	+ public boolean isMCNodeLocal() {
	548	+ return ((ipaddress[0] & 0xff) == 0xff
	549	+ && (ipaddress[1] & 0x0f) == 0x01);
	550	+ }
	551	+
	552	+ /**
	553	+ * Utility routine to check if the multicast address has link scope.
	554	+ *
	555	+ * @return a <code>boolean</code> indicating if the address has
	556	+ * is a multicast address of link-local scope, false if it is not
	557	+ * of link-local scope or it is not a multicast address
	558	+ * @since 1.4
	559	+ */
	560	+ @Override
	561	+ public boolean isMCLinkLocal() {
	562	+ return ((ipaddress[0] & 0xff) == 0xff
	563	+ && (ipaddress[1] & 0x0f) == 0x02);
	564	+ }
	565	+
	566	+ /**
	567	+ * Utility routine to check if the multicast address has site scope.
	568	+ *
	569	+ * @return a <code>boolean</code> indicating if the address has
	570	+ * is a multicast address of site-local scope, false if it is not
	571	+ * of site-local scope or it is not a multicast address
	572	+ * @since 1.4
	573	+ */
	574	+ @Override
	575	+ public boolean isMCSiteLocal() {
	576	+ return ((ipaddress[0] & 0xff) == 0xff
	577	+ && (ipaddress[1] & 0x0f) == 0x05);
	578	+ }
	579	+
	580	+ /**
	581	+ * Utility routine to check if the multicast address has organization scope.
	582	+ *
	583	+ * @return a <code>boolean</code> indicating if the address has
	584	+ * is a multicast address of organization-local scope,
	585	+ * false if it is not of organization-local scope
	586	+ * or it is not a multicast address
	587	+ * @since 1.4
	588	+ */
	589	+ @Override
	590	+ public boolean isMCOrgLocal() {
	591	+ return ((ipaddress[0] & 0xff) == 0xff
	592	+ && (ipaddress[1] & 0x0f) == 0x08);
	593	+ }
	594	+
	595	+ /**
	596	+ * Returns the raw IP address of this <code>InetAddress</code>
	597	+ * object. The result is in network byte order: the highest order
	598	+ * byte of the address is in <code>getAddress()[0]</code>.
	599	+ *
	600	+ * @return the raw IP address of this object.
	601	+ */
	602	+ @Override
	603	+ public byte[] getAddress() {
	604	+ return ipaddress.clone();
	605	+ }
	606	+
	607	+ /**
	608	+ * Returns the numeric scopeId, if this instance is associated with
	609	+ * an interface. If no scoped_id is set, the returned value is zero.
	610	+ *
	611	+ * @return the scopeId, or zero if not set.
	612	+ * @since 1.5
	613	+ */
	614	+ public int getScopeId () {
	615	+ return scope_id;
	616	+ }
	617	+
	618	+ /**
	619	+ * Returns the scoped interface, if this instance was created with
	620	+ * with a scoped interface.
	621	+ *
	622	+ * @return the scoped interface, or null if not set.
	623	+ * @since 1.5
	624	+ */
	625	+ public NetworkInterface getScopedInterface () {
	626	+ return scope_ifname;
	627	+ }
	628	+
	629	+ /**
	630	+ * Returns the IP address string in textual presentation. If the instance was created
	631	+ * specifying a scope identifier then the scope id is appended to the IP address preceded by
	632	+ * a "%" (per-cent) character. This can be either a numeric value or a string, depending on which
	633	+ * was used to createthe instance.
	634	+ *
	635	+ * @return the raw IP address in a string format.
	636	+ */
	637	+ @Override
	638	+ public String getHostAddress() {
	639	+ String s = numericToTextFormat(ipaddress);
	640	+ if (scope_ifname_set) { /* must check this first */
	641	+ s = s + "%" + scope_ifname.getName();
	642	+ } else if (scope_id_set) {
	643	+ s = s + "%" + scope_id;
	644	+ }
	645	+ return s;
	646	+ }
	647	+
	648	+ /**
	649	+ * Returns a hashcode for this IP address.
	650	+ *
	651	+ * @return a hash code value for this IP address.
	652	+ */
	653	+ @Override
	654	+ public int hashCode() {
	655	+ if (ipaddress != null) {
	656	+
	657	+ int hash = 0;
	658	+ int i=0;
	659	+ while (i<INADDRSZ) {
	660	+ int j=0;
	661	+ int component=0;
	662	+ while (j<4 && i<INADDRSZ) {
	663	+ component = (component << 8) + ipaddress[i];
	664	+ j++;
	665	+ i++;
	666	+ }
	667	+ hash += component;
	668	+ }
	669	+ return hash;
	670	+
	671	+ } else {
	672	+ return 0;
	673	+ }
	674	+ }
	675	+
	676	+ /**
	677	+ * Compares this object against the specified object.
	678	+ * The result is <code>true</code> if and only if the argument is
	679	+ * not <code>null</code> and it represents the same IP address as
	680	+ * this object.
	681	+ * <p>
	682	+ * Two instances of <code>InetAddress</code> represent the same IP
	683	+ * address if the length of the byte arrays returned by
	684	+ * <code>getAddress</code> is the same for both, and each of the
	685	+ * array components is the same for the byte arrays.
	686	+ *
	687	+ * @param obj the object to compare against.
	688	+ * @return <code>true</code> if the objects are the same;
	689	+ * <code>false</code> otherwise.
	690	+ * @see java.net.InetAddress#getAddress()
	691	+ */
	692	+ @Override
	693	+ public boolean equals(Object obj) {
	694	+ if (obj == null \|\|
	695	+ !(obj instanceof Inet6Address))
	696	+ return false;
	697	+
	698	+ Inet6Address inetAddr = (Inet6Address)obj;
	699	+
	700	+ for (int i = 0; i < INADDRSZ; i++) {
	701	+ if (ipaddress[i] != inetAddr.ipaddress[i])
	702	+ return false;
	703	+ }
	704	+
	705	+ return true;
	706	+ }
	707	+
	708	+ /**
	709	+ * Utility routine to check if the InetAddress is an
	710	+ * IPv4 compatible IPv6 address.
	711	+ *
	712	+ * @return a <code>boolean</code> indicating if the InetAddress is
	713	+ * an IPv4 compatible IPv6 address; or false if address is IPv4 address.
	714	+ * @since 1.4
	715	+ */
	716	+ public boolean isIPv4CompatibleAddress() {
	717	+ if ((ipaddress[0] == 0x00) && (ipaddress[1] == 0x00) &&
	718	+ (ipaddress[2] == 0x00) && (ipaddress[3] == 0x00) &&
	719	+ (ipaddress[4] == 0x00) && (ipaddress[5] == 0x00) &&
	720	+ (ipaddress[6] == 0x00) && (ipaddress[7] == 0x00) &&
	721	+ (ipaddress[8] == 0x00) && (ipaddress[9] == 0x00) &&
	722	+ (ipaddress[10] == 0x00) && (ipaddress[11] == 0x00)) {
	723	+ return true;
	724	+ }
	725	+ return false;
	726	+ }
	727	+
	728	+ // Utilities
	729	+ private final static int INT16SZ = 2;
	730	+ /*
	731	+ * Convert IPv6 binary address into presentation (printable) format.
	732	+ *
	733	+ * @param src a byte array representing the IPv6 numeric address
	734	+ * @return a String representing an IPv6 address in
	735	+ * textual representation format
	736	+ * @since 1.4
	737	+ */
	738	+ static String numericToTextFormat(byte[] src)
	739	+ {
	740	+ StringBuffer sb = new StringBuffer(39);
	741	+ for (int i = 0; i < (INADDRSZ / INT16SZ); i++) {
	742	+ sb.append(Integer.toHexString(((src[i<<1]<<8) & 0xff00)
	743	+ \| (src[(i<<1)+1] & 0xff)));
	744	+ if (i < (INADDRSZ / INT16SZ) -1 ) {
	745	+ sb.append(":");
	746	+ }
	747	+ }
	748	+ return sb.toString();
	749	+ }
	750	+
	751	+ /**
	752	+ * Perform class load-time initializations.
	753	+ */
	754	+ private static native void init();
	755	+
	756	+ /**
	757	+ * Following field is only used during (de)/serialization
	758	+ */
	759	+ private String ifname;
	760	+
	761	+ /**
	762	+ * default behavior is overridden in order to write the
	763	+ * scope_ifname field as a String, rather than a NetworkInterface
	764	+ * which is not serializable
	765	+ */
	766	+ private synchronized void writeObject(java.io.ObjectOutputStream s)
	767	+ throws IOException
	768	+ {
	769	+ if (scope_ifname_set) {
	770	+ ifname = scope_ifname.getName();
	771	+ }
	772	+ s.defaultWriteObject();
	773	+ }
	774	+}

java/pkg/java/net/Inet6AddressImpl.class+0−0

Binary file not shown.

java/pkg/java/net/Inet6AddressImpl.java+108−0

@@ -0,0 +1,108 @@
	1	+/*
	2	+ * Copyright (c) 2002, 2005, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+package java.net;
	26	+import java.io.IOException;
	27	+
	28	+/*
	29	+ * Package private implementation of InetAddressImpl for dual
	30	+ * IPv4/IPv6 stack.
	31	+ * <p>
	32	+ * If InetAddress.preferIPv6Address is true then anyLocalAddress(),
	33	+ * loopbackAddress(), and localHost() will return IPv6 addresses,
	34	+ * otherwise IPv4 addresses.
	35	+ *
	36	+ * @since 1.4
	37	+ */
	38	+
	39	+class Inet6AddressImpl implements InetAddressImpl {
	40	+ public native String getLocalHostName() throws UnknownHostException;
	41	+ public native InetAddress[]
	42	+ lookupAllHostAddr(String hostname) throws UnknownHostException;
	43	+ public native String getHostByAddr(byte[] addr) throws UnknownHostException;
	44	+ private native boolean isReachable0(byte[] addr, int scope, int timeout, byte[] inf, int ttl, int if_scope) throws IOException;
	45	+
	46	+ public boolean isReachable(InetAddress addr, int timeout, NetworkInterface netif, int ttl) throws IOException {
	47	+ byte[] ifaddr = null;
	48	+ int scope = -1;
	49	+ int netif_scope = -1;
	50	+ if (netif != null) {
	51	+ /*
	52	+ * Let's make sure we bind to an address of the proper family.
	53	+ * Which means same family as addr because at this point it could
	54	+ * be either an IPv6 address or an IPv4 address (case of a dual
	55	+ * stack system).
	56	+ */
	57	+ java.util.Enumeration it = netif.getInetAddresses();
	58	+ InetAddress inetaddr = null;
	59	+ while (it.hasMoreElements()) {
	60	+ inetaddr = (InetAddress) it.nextElement();
	61	+ if (inetaddr.getClass().isInstance(addr)) {
	62	+ ifaddr = inetaddr.getAddress();
	63	+ if (inetaddr instanceof Inet6Address) {
	64	+ netif_scope = ((Inet6Address) inetaddr).getScopeId();
	65	+ }
	66	+ break;
	67	+ }
	68	+ }
	69	+ if (ifaddr == null) {
	70	+ // Interface doesn't support the address family of
	71	+ // the destination
	72	+ return false;
	73	+ }
	74	+ }
	75	+ if (addr instanceof Inet6Address)
	76	+ scope = ((Inet6Address) addr).getScopeId();
	77	+ return isReachable0(addr.getAddress(), scope, timeout, ifaddr, ttl, netif_scope);
	78	+ }
	79	+
	80	+ public synchronized InetAddress anyLocalAddress() {
	81	+ if (anyLocalAddress == null) {
	82	+ if (InetAddress.preferIPv6Address) {
	83	+ anyLocalAddress = new Inet6Address();
	84	+ anyLocalAddress.hostName = "::";
	85	+ } else {
	86	+ anyLocalAddress = (new Inet4AddressImpl()).anyLocalAddress();
	87	+ }
	88	+ }
	89	+ return anyLocalAddress;
	90	+ }
	91	+
	92	+ public synchronized InetAddress loopbackAddress() {
	93	+ if (loopbackAddress == null) {
	94	+ if (InetAddress.preferIPv6Address) {
	95	+ byte[] loopback =
	96	+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	97	+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
	98	+ loopbackAddress = new Inet6Address("localhost", loopback);
	99	+ } else {
	100	+ loopbackAddress = (new Inet4AddressImpl()).loopbackAddress();
	101	+ }
	102	+ }
	103	+ return loopbackAddress;
	104	+ }
	105	+
	106	+ private InetAddress anyLocalAddress;
	107	+ private InetAddress loopbackAddress;
	108	+}

java/pkg/java/net/InetAddress$1.class+0−0

Binary file not shown.

java/pkg/java/net/InetAddress$2.class+0−0

Binary file not shown.

java/pkg/java/net/InetAddress$Cache$Type.class+0−0

Binary file not shown.

java/pkg/java/net/InetAddress$Cache.class+0−0

Binary file not shown.

java/pkg/java/net/InetAddress$CacheEntry.class+0−0

Binary file not shown.

java/pkg/java/net/InetAddress.class+0−0

Binary file not shown.

java/pkg/java/net/InetAddress.java+1540−0

@@ -0,0 +1,1540 @@
	1	+/*
	2	+ * Copyright (c) 1995, 2011, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.util.HashMap;
	29	+import java.util.LinkedHashMap;
	30	+import java.util.Random;
	31	+import java.util.Iterator;
	32	+import java.util.LinkedList;
	33	+import java.util.List;
	34	+import java.util.ArrayList;
	35	+import java.security.AccessController;
	36	+import java.io.ObjectStreamException;
	37	+import java.io.IOException;
	38	+import java.io.ObjectInputStream;
	39	+import sun.security.action.*;
	40	+import sun.net.InetAddressCachePolicy;
	41	+import sun.net.util.IPAddressUtil;
	42	+import sun.misc.Service;
	43	+import sun.net.spi.nameservice.*;
	44	+
	45	+/**
	46	+ * This class represents an Internet Protocol (IP) address.
	47	+ *
	48	+ * <p> An IP address is either a 32-bit or 128-bit unsigned number
	49	+ * used by IP, a lower-level protocol on which protocols like UDP and
	50	+ * TCP are built. The IP address architecture is defined by <a
	51	+ * href="http://www.ietf.org/rfc/rfc790.txt"><i>RFC 790:
	52	+ * Assigned Numbers</i></a>, <a
	53	+ * href="http://www.ietf.org/rfc/rfc1918.txt"> <i>RFC 1918:
	54	+ * Address Allocation for Private Internets</i></a>, <a
	55	+ * href="http://www.ietf.org/rfc/rfc2365.txt"><i>RFC 2365:
	56	+ * Administratively Scoped IP Multicast</i></a>, and <a
	57	+ * href="http://www.ietf.org/rfc/rfc2373.txt"><i>RFC 2373: IP
	58	+ * Version 6 Addressing Architecture</i></a>. An instance of an
	59	+ * InetAddress consists of an IP address and possibly its
	60	+ * corresponding host name (depending on whether it is constructed
	61	+ * with a host name or whether it has already done reverse host name
	62	+ * resolution).
	63	+ *
	64	+ * <h4> Address types </h4>
	65	+ *
	66	+ * <blockquote><table cellspacing=2 summary="Description of unicast and multicast address types">
	67	+ * <tr><th valign=top><i>unicast</i></th>
	68	+ * <td>An identifier for a single interface. A packet sent to
	69	+ * a unicast address is delivered to the interface identified by
	70	+ * that address.
	71	+ *
	72	+ * <p> The Unspecified Address -- Also called anylocal or wildcard
	73	+ * address. It must never be assigned to any node. It indicates the
	74	+ * absence of an address. One example of its use is as the target of
	75	+ * bind, which allows a server to accept a client connection on any
	76	+ * interface, in case the server host has multiple interfaces.
	77	+ *
	78	+ * <p> The <i>unspecified</i> address must not be used as
	79	+ * the destination address of an IP packet.
	80	+ *
	81	+ * <p> The <i>Loopback</i> Addresses -- This is the address
	82	+ * assigned to the loopback interface. Anything sent to this
	83	+ * IP address loops around and becomes IP input on the local
	84	+ * host. This address is often used when testing a
	85	+ * client.</td></tr>
	86	+ * <tr><th valign=top><i>multicast</i></th>
	87	+ * <td>An identifier for a set of interfaces (typically belonging
	88	+ * to different nodes). A packet sent to a multicast address is
	89	+ * delivered to all interfaces identified by that address.</td></tr>
	90	+ * </table></blockquote>
	91	+ *
	92	+ * <h4> IP address scope </h4>
	93	+ *
	94	+ * <p> <i>Link-local</i> addresses are designed to be used for addressing
	95	+ * on a single link for purposes such as auto-address configuration,
	96	+ * neighbor discovery, or when no routers are present.
	97	+ *
	98	+ * <p> <i>Site-local</i> addresses are designed to be used for addressing
	99	+ * inside of a site without the need for a global prefix.
	100	+ *
	101	+ * <p> <i>Global</i> addresses are unique across the internet.
	102	+ *
	103	+ * <h4> Textual representation of IP addresses </h4>
	104	+ *
	105	+ * The textual representation of an IP address is address family specific.
	106	+ *
	107	+ * <p>
	108	+ *
	109	+ * For IPv4 address format, please refer to <A
	110	+ * HREF="Inet4Address.html#format">Inet4Address#format</A>; For IPv6
	111	+ * address format, please refer to <A
	112	+ * HREF="Inet6Address.html#format">Inet6Address#format</A>.
	113	+ *
	114	+ * <P>There is a <a href="doc-files/net-properties.html#Ipv4IPv6">couple of
	115	+ * System Properties</a> affecting how IPv4 and IPv6 addresses are used.</P>
	116	+ *
	117	+ * <h4> Host Name Resolution </h4>
	118	+ *
	119	+ * Host name-to-IP address <i>resolution</i> is accomplished through
	120	+ * the use of a combination of local machine configuration information
	121	+ * and network naming services such as the Domain Name System (DNS)
	122	+ * and Network Information Service(NIS). The particular naming
	123	+ * services(s) being used is by default the local machine configured
	124	+ * one. For any host name, its corresponding IP address is returned.
	125	+ *
	126	+ * <p> <i>Reverse name resolution</i> means that for any IP address,
	127	+ * the host associated with the IP address is returned.
	128	+ *
	129	+ * <p> The InetAddress class provides methods to resolve host names to
	130	+ * their IP addresses and vice versa.
	131	+ *
	132	+ * <h4> InetAddress Caching </h4>
	133	+ *
	134	+ * The InetAddress class has a cache to store successful as well as
	135	+ * unsuccessful host name resolutions.
	136	+ *
	137	+ * <p> By default, when a security manager is installed, in order to
	138	+ * protect against DNS spoofing attacks,
	139	+ * the result of positive host name resolutions are
	140	+ * cached forever. When a security manager is not installed, the default
	141	+ * behavior is to cache entries for a finite (implementation dependent)
	142	+ * period of time. The result of unsuccessful host
	143	+ * name resolution is cached for a very short period of time (10
	144	+ * seconds) to improve performance.
	145	+ *
	146	+ * <p> If the default behavior is not desired, then a Java security property
	147	+ * can be set to a different Time-to-live (TTL) value for positive
	148	+ * caching. Likewise, a system admin can configure a different
	149	+ * negative caching TTL value when needed.
	150	+ *
	151	+ * <p> Two Java security properties control the TTL values used for
	152	+ * positive and negative host name resolution caching:
	153	+ *
	154	+ * <blockquote>
	155	+ * <dl>
	156	+ * <dt><b>networkaddress.cache.ttl</b></dt>
	157	+ * <dd>Indicates the caching policy for successful name lookups from
	158	+ * the name service. The value is specified as as integer to indicate
	159	+ * the number of seconds to cache the successful lookup. The default
	160	+ * setting is to cache for an implementation specific period of time.
	161	+ * <p>
	162	+ * A value of -1 indicates "cache forever".
	163	+ * </dd>
	164	+ * <p>
	165	+ * <dt><b>networkaddress.cache.negative.ttl</b> (default: 10)</dt>
	166	+ * <dd>Indicates the caching policy for un-successful name lookups
	167	+ * from the name service. The value is specified as as integer to
	168	+ * indicate the number of seconds to cache the failure for
	169	+ * un-successful lookups.
	170	+ * <p>
	171	+ * A value of 0 indicates "never cache".
	172	+ * A value of -1 indicates "cache forever".
	173	+ * </dd>
	174	+ * </dl>
	175	+ * </blockquote>
	176	+ *
	177	+ * @author Chris Warth
	178	+ * @see java.net.InetAddress#getByAddress(byte[])
	179	+ * @see java.net.InetAddress#getByAddress(java.lang.String, byte[])
	180	+ * @see java.net.InetAddress#getAllByName(java.lang.String)
	181	+ * @see java.net.InetAddress#getByName(java.lang.String)
	182	+ * @see java.net.InetAddress#getLocalHost()
	183	+ * @since JDK1.0
	184	+ */
	185	+public
	186	+class InetAddress implements java.io.Serializable {
	187	+ /**
	188	+ * Specify the address family: Internet Protocol, Version 4
	189	+ * @since 1.4
	190	+ */
	191	+ static final int IPv4 = 1;
	192	+
	193	+ /**
	194	+ * Specify the address family: Internet Protocol, Version 6
	195	+ * @since 1.4
	196	+ */
	197	+ static final int IPv6 = 2;
	198	+
	199	+ /* Specify address family preference */
	200	+ static transient boolean preferIPv6Address = false;
	201	+
	202	+ /**
	203	+ * @serial
	204	+ */
	205	+ String hostName;
	206	+
	207	+ /**
	208	+ * Holds a 32-bit IPv4 address.
	209	+ *
	210	+ * @serial
	211	+ */
	212	+ int address;
	213	+
	214	+ /**
	215	+ * Specifies the address family type, for instance, '1' for IPv4
	216	+ * addresses, and '2' for IPv6 addresses.
	217	+ *
	218	+ * @serial
	219	+ */
	220	+ int family;
	221	+
	222	+ /* Used to store the name service provider */
	223	+ private static List<NameService> nameServices = null;
	224	+
	225	+ /* Used to store the best available hostname */
	226	+ private transient String canonicalHostName = null;
	227	+
	228	+ /** use serialVersionUID from JDK 1.0.2 for interoperability */
	229	+ private static final long serialVersionUID = 3286316764910316507L;
	230	+
	231	+ /*
	232	+ * Load net library into runtime, and perform initializations.
	233	+ */
	234	+ static {
	235	+ preferIPv6Address = java.security.AccessController.doPrivileged(
	236	+ new GetBooleanAction("java.net.preferIPv6Addresses")).booleanValue();
	237	+ AccessController.doPrivileged(new LoadLibraryAction("net"));
	238	+ init();
	239	+ }
	240	+
	241	+ /**
	242	+ * Constructor for the Socket.accept() method.
	243	+ * This creates an empty InetAddress, which is filled in by
	244	+ * the accept() method. This InetAddress, however, is not
	245	+ * put in the address cache, since it is not created by name.
	246	+ */
	247	+ InetAddress() {
	248	+ }
	249	+
	250	+ /**
	251	+ * Replaces the de-serialized object with an Inet4Address object.
	252	+ *
	253	+ * @return the alternate object to the de-serialized object.
	254	+ *
	255	+ * @throws ObjectStreamException if a new object replacing this
	256	+ * object could not be created
	257	+ */
	258	+ private Object readResolve() throws ObjectStreamException {
	259	+ // will replace the deserialized 'this' object
	260	+ return new Inet4Address(this.hostName, this.address);
	261	+ }
	262	+
	263	+ /**
	264	+ * Utility routine to check if the InetAddress is an
	265	+ * IP multicast address.
	266	+ * @return a <code>boolean</code> indicating if the InetAddress is
	267	+ * an IP multicast address
	268	+ * @since JDK1.1
	269	+ */
	270	+ public boolean isMulticastAddress() {
	271	+ return false;
	272	+ }
	273	+
	274	+ /**
	275	+ * Utility routine to check if the InetAddress in a wildcard address.
	276	+ * @return a <code>boolean</code> indicating if the Inetaddress is
	277	+ * a wildcard address.
	278	+ * @since 1.4
	279	+ */
	280	+ public boolean isAnyLocalAddress() {
	281	+ return false;
	282	+ }
	283	+
	284	+ /**
	285	+ * Utility routine to check if the InetAddress is a loopback address.
	286	+ *
	287	+ * @return a <code>boolean</code> indicating if the InetAddress is
	288	+ * a loopback address; or false otherwise.
	289	+ * @since 1.4
	290	+ */
	291	+ public boolean isLoopbackAddress() {
	292	+ return false;
	293	+ }
	294	+
	295	+ /**
	296	+ * Utility routine to check if the InetAddress is an link local address.
	297	+ *
	298	+ * @return a <code>boolean</code> indicating if the InetAddress is
	299	+ * a link local address; or false if address is not a link local unicast address.
	300	+ * @since 1.4
	301	+ */
	302	+ public boolean isLinkLocalAddress() {
	303	+ return false;
	304	+ }
	305	+
	306	+ /**
	307	+ * Utility routine to check if the InetAddress is a site local address.
	308	+ *
	309	+ * @return a <code>boolean</code> indicating if the InetAddress is
	310	+ * a site local address; or false if address is not a site local unicast address.
	311	+ * @since 1.4
	312	+ */
	313	+ public boolean isSiteLocalAddress() {
	314	+ return false;
	315	+ }
	316	+
	317	+ /**
	318	+ * Utility routine to check if the multicast address has global scope.
	319	+ *
	320	+ * @return a <code>boolean</code> indicating if the address has
	321	+ * is a multicast address of global scope, false if it is not
	322	+ * of global scope or it is not a multicast address
	323	+ * @since 1.4
	324	+ */
	325	+ public boolean isMCGlobal() {
	326	+ return false;
	327	+ }
	328	+
	329	+ /**
	330	+ * Utility routine to check if the multicast address has node scope.
	331	+ *
	332	+ * @return a <code>boolean</code> indicating if the address has
	333	+ * is a multicast address of node-local scope, false if it is not
	334	+ * of node-local scope or it is not a multicast address
	335	+ * @since 1.4
	336	+ */
	337	+ public boolean isMCNodeLocal() {
	338	+ return false;
	339	+ }
	340	+
	341	+ /**
	342	+ * Utility routine to check if the multicast address has link scope.
	343	+ *
	344	+ * @return a <code>boolean</code> indicating if the address has
	345	+ * is a multicast address of link-local scope, false if it is not
	346	+ * of link-local scope or it is not a multicast address
	347	+ * @since 1.4
	348	+ */
	349	+ public boolean isMCLinkLocal() {
	350	+ return false;
	351	+ }
	352	+
	353	+ /**
	354	+ * Utility routine to check if the multicast address has site scope.
	355	+ *
	356	+ * @return a <code>boolean</code> indicating if the address has
	357	+ * is a multicast address of site-local scope, false if it is not
	358	+ * of site-local scope or it is not a multicast address
	359	+ * @since 1.4
	360	+ */
	361	+ public boolean isMCSiteLocal() {
	362	+ return false;
	363	+ }
	364	+
	365	+ /**
	366	+ * Utility routine to check if the multicast address has organization scope.
	367	+ *
	368	+ * @return a <code>boolean</code> indicating if the address has
	369	+ * is a multicast address of organization-local scope,
	370	+ * false if it is not of organization-local scope
	371	+ * or it is not a multicast address
	372	+ * @since 1.4
	373	+ */
	374	+ public boolean isMCOrgLocal() {
	375	+ return false;
	376	+ }
	377	+
	378	+
	379	+ /**
	380	+ * Test whether that address is reachable. Best effort is made by the
	381	+ * implementation to try to reach the host, but firewalls and server
	382	+ * configuration may block requests resulting in a unreachable status
	383	+ * while some specific ports may be accessible.
	384	+ * A typical implementation will use ICMP ECHO REQUESTs if the
	385	+ * privilege can be obtained, otherwise it will try to establish
	386	+ * a TCP connection on port 7 (Echo) of the destination host.
	387	+ * <p>
	388	+ * The timeout value, in milliseconds, indicates the maximum amount of time
	389	+ * the try should take. If the operation times out before getting an
	390	+ * answer, the host is deemed unreachable. A negative value will result
	391	+ * in an IllegalArgumentException being thrown.
	392	+ *
	393	+ * @param timeout the time, in milliseconds, before the call aborts
	394	+ * @return a <code>boolean</code> indicating if the address is reachable.
	395	+ * @throws IOException if a network error occurs
	396	+ * @throws IllegalArgumentException if <code>timeout</code> is negative.
	397	+ * @since 1.5
	398	+ */
	399	+ public boolean isReachable(int timeout) throws IOException {
	400	+ return isReachable(null, 0 , timeout);
	401	+ }
	402	+
	403	+ /**
	404	+ * Test whether that address is reachable. Best effort is made by the
	405	+ * implementation to try to reach the host, but firewalls and server
	406	+ * configuration may block requests resulting in a unreachable status
	407	+ * while some specific ports may be accessible.
	408	+ * A typical implementation will use ICMP ECHO REQUESTs if the
	409	+ * privilege can be obtained, otherwise it will try to establish
	410	+ * a TCP connection on port 7 (Echo) of the destination host.
	411	+ * <p>
	412	+ * The <code>network interface</code> and <code>ttl</code> parameters
	413	+ * let the caller specify which network interface the test will go through
	414	+ * and the maximum number of hops the packets should go through.
	415	+ * A negative value for the <code>ttl</code> will result in an
	416	+ * IllegalArgumentException being thrown.
	417	+ * <p>
	418	+ * The timeout value, in milliseconds, indicates the maximum amount of time
	419	+ * the try should take. If the operation times out before getting an
	420	+ * answer, the host is deemed unreachable. A negative value will result
	421	+ * in an IllegalArgumentException being thrown.
	422	+ *
	423	+ * @param netif the NetworkInterface through which the
	424	+ * test will be done, or null for any interface
	425	+ * @param ttl the maximum numbers of hops to try or 0 for the
	426	+ * default
	427	+ * @param timeout the time, in milliseconds, before the call aborts
	428	+ * @throws IllegalArgumentException if either <code>timeout</code>
	429	+ * or <code>ttl</code> are negative.
	430	+ * @return a <code>boolean</code>indicating if the address is reachable.
	431	+ * @throws IOException if a network error occurs
	432	+ * @since 1.5
	433	+ */
	434	+ public boolean isReachable(NetworkInterface netif, int ttl,
	435	+ int timeout) throws IOException {
	436	+ if (ttl < 0)
	437	+ throw new IllegalArgumentException("ttl can't be negative");
	438	+ if (timeout < 0)
	439	+ throw new IllegalArgumentException("timeout can't be negative");
	440	+
	441	+ return impl.isReachable(this, timeout, netif, ttl);
	442	+ }
	443	+
	444	+ /**
	445	+ * Gets the host name for this IP address.
	446	+ *
	447	+ * <p>If this InetAddress was created with a host name,
	448	+ * this host name will be remembered and returned;
	449	+ * otherwise, a reverse name lookup will be performed
	450	+ * and the result will be returned based on the system
	451	+ * configured name lookup service. If a lookup of the name service
	452	+ * is required, call
	453	+ * {@link #getCanonicalHostName() getCanonicalHostName}.
	454	+ *
	455	+ * <p>If there is a security manager, its
	456	+ * <code>checkConnect</code> method is first called
	457	+ * with the hostname and <code>-1</code>
	458	+ * as its arguments to see if the operation is allowed.
	459	+ * If the operation is not allowed, it will return
	460	+ * the textual representation of the IP address.
	461	+ *
	462	+ * @return the host name for this IP address, or if the operation
	463	+ * is not allowed by the security check, the textual
	464	+ * representation of the IP address.
	465	+ *
	466	+ * @see InetAddress#getCanonicalHostName
	467	+ * @see SecurityManager#checkConnect
	468	+ */
	469	+ public String getHostName() {
	470	+ return getHostName(true);
	471	+ }
	472	+
	473	+ /**
	474	+ * Returns the hostname for this address.
	475	+ * If the host is equal to null, then this address refers to any
	476	+ * of the local machine's available network addresses.
	477	+ * this is package private so SocketPermission can make calls into
	478	+ * here without a security check.
	479	+ *
	480	+ * <p>If there is a security manager, this method first
	481	+ * calls its <code>checkConnect</code> method
	482	+ * with the hostname and <code>-1</code>
	483	+ * as its arguments to see if the calling code is allowed to know
	484	+ * the hostname for this IP address, i.e., to connect to the host.
	485	+ * If the operation is not allowed, it will return
	486	+ * the textual representation of the IP address.
	487	+ *
	488	+ * @return the host name for this IP address, or if the operation
	489	+ * is not allowed by the security check, the textual
	490	+ * representation of the IP address.
	491	+ *
	492	+ * @param check make security check if true
	493	+ *
	494	+ * @see SecurityManager#checkConnect
	495	+ */
	496	+ String getHostName(boolean check) {
	497	+ if (hostName == null) {
	498	+ hostName = InetAddress.getHostFromNameService(this, check);
	499	+ }
	500	+ return hostName;
	501	+ }
	502	+
	503	+ /**
	504	+ * Gets the fully qualified domain name for this IP address.
	505	+ * Best effort method, meaning we may not be able to return
	506	+ * the FQDN depending on the underlying system configuration.
	507	+ *
	508	+ * <p>If there is a security manager, this method first
	509	+ * calls its <code>checkConnect</code> method
	510	+ * with the hostname and <code>-1</code>
	511	+ * as its arguments to see if the calling code is allowed to know
	512	+ * the hostname for this IP address, i.e., to connect to the host.
	513	+ * If the operation is not allowed, it will return
	514	+ * the textual representation of the IP address.
	515	+ *
	516	+ * @return the fully qualified domain name for this IP address,
	517	+ * or if the operation is not allowed by the security check,
	518	+ * the textual representation of the IP address.
	519	+ *
	520	+ * @see SecurityManager#checkConnect
	521	+ *
	522	+ * @since 1.4
	523	+ */
	524	+ public String getCanonicalHostName() {
	525	+ if (canonicalHostName == null) {
	526	+ canonicalHostName =
	527	+ InetAddress.getHostFromNameService(this, true);
	528	+ }
	529	+ return canonicalHostName;
	530	+ }
	531	+
	532	+ /**
	533	+ * Returns the hostname for this address.
	534	+ *
	535	+ * <p>If there is a security manager, this method first
	536	+ * calls its <code>checkConnect</code> method
	537	+ * with the hostname and <code>-1</code>
	538	+ * as its arguments to see if the calling code is allowed to know
	539	+ * the hostname for this IP address, i.e., to connect to the host.
	540	+ * If the operation is not allowed, it will return
	541	+ * the textual representation of the IP address.
	542	+ *
	543	+ * @return the host name for this IP address, or if the operation
	544	+ * is not allowed by the security check, the textual
	545	+ * representation of the IP address.
	546	+ *
	547	+ * @param check make security check if true
	548	+ *
	549	+ * @see SecurityManager#checkConnect
	550	+ */
	551	+ private static String getHostFromNameService(InetAddress addr, boolean check) {
	552	+ String host = null;
	553	+ for (NameService nameService : nameServices) {
	554	+ try {
	555	+ // first lookup the hostname
	556	+ host = nameService.getHostByAddr(addr.getAddress());
	557	+
	558	+ /* check to see if calling code is allowed to know
	559	+ * the hostname for this IP address, ie, connect to the host
	560	+ */
	561	+ if (check) {
	562	+ SecurityManager sec = System.getSecurityManager();
	563	+ if (sec != null) {
	564	+ sec.checkConnect(host, -1);
	565	+ }
	566	+ }
	567	+
	568	+ /* now get all the IP addresses for this hostname,
	569	+ * and make sure one of them matches the original IP
	570	+ * address. We do this to try and prevent spoofing.
	571	+ */
	572	+
	573	+ InetAddress[] arr = InetAddress.getAllByName0(host, check);
	574	+ boolean ok = false;
	575	+
	576	+ if(arr != null) {
	577	+ for(int i = 0; !ok && i < arr.length; i++) {
	578	+ ok = addr.equals(arr[i]);
	579	+ }
	580	+ }
	581	+
	582	+ //XXX: if it looks a spoof just return the address?
	583	+ if (!ok) {
	584	+ host = addr.getHostAddress();
	585	+ return host;
	586	+ }
	587	+
	588	+ break;
	589	+
	590	+ } catch (SecurityException e) {
	591	+ host = addr.getHostAddress();
	592	+ break;
	593	+ } catch (UnknownHostException e) {
	594	+ host = addr.getHostAddress();
	595	+ // let next provider resolve the hostname
	596	+ }
	597	+ }
	598	+
	599	+ return host;
	600	+ }
	601	+
	602	+ /**
	603	+ * Returns the raw IP address of this <code>InetAddress</code>
	604	+ * object. The result is in network byte order: the highest order
	605	+ * byte of the address is in <code>getAddress()[0]</code>.
	606	+ *
	607	+ * @return the raw IP address of this object.
	608	+ */
	609	+ public byte[] getAddress() {
	610	+ return null;
	611	+ }
	612	+
	613	+ /**
	614	+ * Returns the IP address string in textual presentation.
	615	+ *
	616	+ * @return the raw IP address in a string format.
	617	+ * @since JDK1.0.2
	618	+ */
	619	+ public String getHostAddress() {
	620	+ return null;
	621	+ }
	622	+
	623	+ /**
	624	+ * Returns a hashcode for this IP address.
	625	+ *
	626	+ * @return a hash code value for this IP address.
	627	+ */
	628	+ public int hashCode() {
	629	+ return -1;
	630	+ }
	631	+
	632	+ /**
	633	+ * Compares this object against the specified object.
	634	+ * The result is <code>true</code> if and only if the argument is
	635	+ * not <code>null</code> and it represents the same IP address as
	636	+ * this object.
	637	+ * <p>
	638	+ * Two instances of <code>InetAddress</code> represent the same IP
	639	+ * address if the length of the byte arrays returned by
	640	+ * <code>getAddress</code> is the same for both, and each of the
	641	+ * array components is the same for the byte arrays.
	642	+ *
	643	+ * @param obj the object to compare against.
	644	+ * @return <code>true</code> if the objects are the same;
	645	+ * <code>false</code> otherwise.
	646	+ * @see java.net.InetAddress#getAddress()
	647	+ */
	648	+ public boolean equals(Object obj) {
	649	+ return false;
	650	+ }
	651	+
	652	+ /**
	653	+ * Converts this IP address to a <code>String</code>. The
	654	+ * string returned is of the form: hostname / literal IP
	655	+ * address.
	656	+ *
	657	+ * If the host name is unresolved, no reverse name service lookup
	658	+ * is performed. The hostname part will be represented by an empty string.
	659	+ *
	660	+ * @return a string representation of this IP address.
	661	+ */
	662	+ public String toString() {
	663	+ return ((hostName != null) ? hostName : "")
	664	+ + "/" + getHostAddress();
	665	+ }
	666	+
	667	+ /*
	668	+ * Cached addresses - our own litle nis, not!
	669	+ */
	670	+ private static Cache addressCache = new Cache(Cache.Type.Positive);
	671	+
	672	+ private static Cache negativeCache = new Cache(Cache.Type.Negative);
	673	+
	674	+ private static boolean addressCacheInit = false;
	675	+
	676	+ static InetAddress[] unknown_array; // put THIS in cache
	677	+
	678	+ static InetAddressImpl impl;
	679	+
	680	+ private static final HashMap<String, Void> lookupTable = new HashMap<>();
	681	+
	682	+ /**
	683	+ * Represents a cache entry
	684	+ */
	685	+ static final class CacheEntry {
	686	+
	687	+ CacheEntry(InetAddress[] addresses, long expiration) {
	688	+ this.addresses = addresses;
	689	+ this.expiration = expiration;
	690	+ }
	691	+
	692	+ InetAddress[] addresses;
	693	+ long expiration;
	694	+ }
	695	+
	696	+ /**
	697	+ * A cache that manages entries based on a policy specified
	698	+ * at creation time.
	699	+ */
	700	+ static final class Cache {
	701	+ private LinkedHashMap<String, CacheEntry> cache;
	702	+ private Type type;
	703	+
	704	+ enum Type {Positive, Negative};
	705	+
	706	+ /**
	707	+ * Create cache
	708	+ */
	709	+ public Cache(Type type) {
	710	+ this.type = type;
	711	+ cache = new LinkedHashMap<String, CacheEntry>();
	712	+ }
	713	+
	714	+ private int getPolicy() {
	715	+ if (type == Type.Positive) {
	716	+ return InetAddressCachePolicy.get();
	717	+ } else {
	718	+ return InetAddressCachePolicy.getNegative();
	719	+ }
	720	+ }
	721	+
	722	+ /**
	723	+ * Add an entry to the cache. If there's already an
	724	+ * entry then for this host then the entry will be
	725	+ * replaced.
	726	+ */
	727	+ public Cache put(String host, InetAddress[] addresses) {
	728	+ int policy = getPolicy();
	729	+ if (policy == InetAddressCachePolicy.NEVER) {
	730	+ return this;
	731	+ }
	732	+
	733	+ // purge any expired entries
	734	+
	735	+ if (policy != InetAddressCachePolicy.FOREVER) {
	736	+
	737	+ // As we iterate in insertion order we can
	738	+ // terminate when a non-expired entry is found.
	739	+ LinkedList<String> expired = new LinkedList<>();
	740	+ long now = System.currentTimeMillis();
	741	+ for (String key : cache.keySet()) {
	742	+ CacheEntry entry = cache.get(key);
	743	+
	744	+ if (entry.expiration >= 0 && entry.expiration < now) {
	745	+ expired.add(key);
	746	+ } else {
	747	+ break;
	748	+ }
	749	+ }
	750	+
	751	+ for (String key : expired) {
	752	+ cache.remove(key);
	753	+ }
	754	+ }
	755	+
	756	+ // create new entry and add it to the cache
	757	+ // -- as a HashMap replaces existing entries we
	758	+ // don't need to explicitly check if there is
	759	+ // already an entry for this host.
	760	+ long expiration;
	761	+ if (policy == InetAddressCachePolicy.FOREVER) {
	762	+ expiration = -1;
	763	+ } else {
	764	+ expiration = System.currentTimeMillis() + (policy * 1000);
	765	+ }
	766	+ CacheEntry entry = new CacheEntry(addresses, expiration);
	767	+ cache.put(host, entry);
	768	+ return this;
	769	+ }
	770	+
	771	+ /**
	772	+ * Query the cache for the specific host. If found then
	773	+ * return its CacheEntry, or null if not found.
	774	+ */
	775	+ public CacheEntry get(String host) {
	776	+ int policy = getPolicy();
	777	+ if (policy == InetAddressCachePolicy.NEVER) {
	778	+ return null;
	779	+ }
	780	+ CacheEntry entry = cache.get(host);
	781	+
	782	+ // check if entry has expired
	783	+ if (entry != null && policy != InetAddressCachePolicy.FOREVER) {
	784	+ if (entry.expiration >= 0 &&
	785	+ entry.expiration < System.currentTimeMillis()) {
	786	+ cache.remove(host);
	787	+ entry = null;
	788	+ }
	789	+ }
	790	+
	791	+ return entry;
	792	+ }
	793	+ }
	794	+
	795	+ /*
	796	+ * Initialize cache and insert anyLocalAddress into the
	797	+ * unknown array with no expiry.
	798	+ */
	799	+ private static void cacheInitIfNeeded() {
	800	+ assert Thread.holdsLock(addressCache);
	801	+ if (addressCacheInit) {
	802	+ return;
	803	+ }
	804	+ unknown_array = new InetAddress[1];
	805	+ unknown_array[0] = impl.anyLocalAddress();
	806	+
	807	+ addressCache.put(impl.anyLocalAddress().getHostName(),
	808	+ unknown_array);
	809	+
	810	+ addressCacheInit = true;
	811	+ }
	812	+
	813	+ /*
	814	+ * Cache the given hostname and addresses.
	815	+ */
	816	+ private static void cacheAddresses(String hostname,
	817	+ InetAddress[] addresses,
	818	+ boolean success) {
	819	+ hostname = hostname.toLowerCase();
	820	+ synchronized (addressCache) {
	821	+ cacheInitIfNeeded();
	822	+ if (success) {
	823	+ addressCache.put(hostname, addresses);
	824	+ } else {
	825	+ negativeCache.put(hostname, addresses);
	826	+ }
	827	+ }
	828	+ }
	829	+
	830	+ /*
	831	+ * Lookup hostname in cache (positive & negative cache). If
	832	+ * found return addresses, null if not found.
	833	+ */
	834	+ private static InetAddress[] getCachedAddresses(String hostname) {
	835	+ hostname = hostname.toLowerCase();
	836	+
	837	+ // search both positive & negative caches
	838	+
	839	+ synchronized (addressCache) {
	840	+ cacheInitIfNeeded();
	841	+
	842	+ CacheEntry entry = addressCache.get(hostname);
	843	+ if (entry == null) {
	844	+ entry = negativeCache.get(hostname);
	845	+ }
	846	+
	847	+ if (entry != null) {
	848	+ return entry.addresses;
	849	+ }
	850	+ }
	851	+
	852	+ // not found
	853	+ return null;
	854	+ }
	855	+
	856	+ private static NameService createNSProvider(String provider) {
	857	+ if (provider == null)
	858	+ return null;
	859	+
	860	+ NameService nameService = null;
	861	+ if (provider.equals("default")) {
	862	+ // initialize the default name service
	863	+ nameService = new NameService() {
	864	+ public InetAddress[] lookupAllHostAddr(String host)
	865	+ throws UnknownHostException {
	866	+ return impl.lookupAllHostAddr(host);
	867	+ }
	868	+ public String getHostByAddr(byte[] addr)
	869	+ throws UnknownHostException {
	870	+ return impl.getHostByAddr(addr);
	871	+ }
	872	+ };
	873	+ } else {
	874	+ final String providerName = provider;
	875	+ try {
	876	+ nameService = java.security.AccessController.doPrivileged(
	877	+ new java.security.PrivilegedExceptionAction<NameService>() {
	878	+ public NameService run() {
	879	+ Iterator itr = Service.providers(NameServiceDescriptor.class);
	880	+ while (itr.hasNext()) {
	881	+ NameServiceDescriptor nsd
	882	+ = (NameServiceDescriptor)itr.next();
	883	+ if (providerName.
	884	+ equalsIgnoreCase(nsd.getType()+","
	885	+ +nsd.getProviderName())) {
	886	+ try {
	887	+ return nsd.createNameService();
	888	+ } catch (Exception e) {
	889	+ e.printStackTrace();
	890	+ System.err.println(
	891	+ "Cannot create name service:"
	892	+ +providerName+": " + e);
	893	+ }
	894	+ }
	895	+ }
	896	+
	897	+ return null;
	898	+ }
	899	+ }
	900	+ );
	901	+ } catch (java.security.PrivilegedActionException e) {
	902	+ }
	903	+ }
	904	+
	905	+ return nameService;
	906	+ }
	907	+
	908	+ static {
	909	+ // create the impl
	910	+ impl = InetAddressImplFactory.create();
	911	+
	912	+ // get name service if provided and requested
	913	+ String provider = null;;
	914	+ String propPrefix = "sun.net.spi.nameservice.provider.";
	915	+ int n = 1;
	916	+ nameServices = new ArrayList<NameService>();
	917	+ provider = AccessController.doPrivileged(
	918	+ new GetPropertyAction(propPrefix + n));
	919	+ while (provider != null) {
	920	+ NameService ns = createNSProvider(provider);
	921	+ if (ns != null)
	922	+ nameServices.add(ns);
	923	+
	924	+ n++;
	925	+ provider = AccessController.doPrivileged(
	926	+ new GetPropertyAction(propPrefix + n));
	927	+ }
	928	+
	929	+ // if not designate any name services provider,
	930	+ // create a default one
	931	+ if (nameServices.size() == 0) {
	932	+ NameService ns = createNSProvider("default");
	933	+ nameServices.add(ns);
	934	+ }
	935	+ }
	936	+
	937	+ /**
	938	+ * Creates an InetAddress based on the provided host name and IP address.
	939	+ * No name service is checked for the validity of the address.
	940	+ *
	941	+ * <p> The host name can either be a machine name, such as
	942	+ * "<code>java.sun.com</code>", or a textual representation of its IP
	943	+ * address.
	944	+ * <p> No validity checking is done on the host name either.
	945	+ *
	946	+ * <p> If addr specifies an IPv4 address an instance of Inet4Address
	947	+ * will be returned; otherwise, an instance of Inet6Address
	948	+ * will be returned.
	949	+ *
	950	+ * <p> IPv4 address byte array must be 4 bytes long and IPv6 byte array
	951	+ * must be 16 bytes long
	952	+ *
	953	+ * @param host the specified host
	954	+ * @param addr the raw IP address in network byte order
	955	+ * @return an InetAddress object created from the raw IP address.
	956	+ * @exception UnknownHostException if IP address is of illegal length
	957	+ * @since 1.4
	958	+ */
	959	+ public static InetAddress getByAddress(String host, byte[] addr)
	960	+ throws UnknownHostException {
	961	+ if (host != null && host.length() > 0 && host.charAt(0) == '[') {
	962	+ if (host.charAt(host.length()-1) == ']') {
	963	+ host = host.substring(1, host.length() -1);
	964	+ }
	965	+ }
	966	+ if (addr != null) {
	967	+ if (addr.length == Inet4Address.INADDRSZ) {
	968	+ return new Inet4Address(host, addr);
	969	+ } else if (addr.length == Inet6Address.INADDRSZ) {
	970	+ byte[] newAddr
	971	+ = IPAddressUtil.convertFromIPv4MappedAddress(addr);
	972	+ if (newAddr != null) {
	973	+ return new Inet4Address(host, newAddr);
	974	+ } else {
	975	+ return new Inet6Address(host, addr);
	976	+ }
	977	+ }
	978	+ }
	979	+ throw new UnknownHostException("addr is of illegal length");
	980	+ }
	981	+
	982	+
	983	+ /**
	984	+ * Determines the IP address of a host, given the host's name.
	985	+ *
	986	+ * <p> The host name can either be a machine name, such as
	987	+ * "<code>java.sun.com</code>", or a textual representation of its
	988	+ * IP address. If a literal IP address is supplied, only the
	989	+ * validity of the address format is checked.
	990	+ *
	991	+ * <p> For <code>host</code> specified in literal IPv6 address,
	992	+ * either the form defined in RFC 2732 or the literal IPv6 address
	993	+ * format defined in RFC 2373 is accepted. IPv6 scoped addresses are also
	994	+ * supported. See <a href="Inet6Address.html#scoped">here</a> for a description of IPv6
	995	+ * scoped addresses.
	996	+ *
	997	+ * <p> If the host is <tt>null</tt> then an <tt>InetAddress</tt>
	998	+ * representing an address of the loopback interface is returned.
	999	+ * See <a href="http://www.ietf.org/rfc/rfc3330.txt">RFC 3330</a>
	1000	+ * section 2 and <a href="http://www.ietf.org/rfc/rfc2373.txt">RFC 2373</a>
	1001	+ * section 2.5.3. </p>
	1002	+ *
	1003	+ * @param host the specified host, or <code>null</code>.
	1004	+ * @return an IP address for the given host name.
	1005	+ * @exception UnknownHostException if no IP address for the
	1006	+ * <code>host</code> could be found, or if a scope_id was specified
	1007	+ * for a global IPv6 address.
	1008	+ * @exception SecurityException if a security manager exists
	1009	+ * and its checkConnect method doesn't allow the operation
	1010	+ */
	1011	+ public static InetAddress getByName(String host)
	1012	+ throws UnknownHostException {
	1013	+ return InetAddress.getAllByName(host)[0];
	1014	+ }
	1015	+
	1016	+ // called from deployment cache manager
	1017	+ private static InetAddress getByName(String host, InetAddress reqAddr)
	1018	+ throws UnknownHostException {
	1019	+ return InetAddress.getAllByName(host, reqAddr)[0];
	1020	+ }
	1021	+
	1022	+ /**
	1023	+ * Given the name of a host, returns an array of its IP addresses,
	1024	+ * based on the configured name service on the system.
	1025	+ *
	1026	+ * <p> The host name can either be a machine name, such as
	1027	+ * "<code>java.sun.com</code>", or a textual representation of its IP
	1028	+ * address. If a literal IP address is supplied, only the
	1029	+ * validity of the address format is checked.
	1030	+ *
	1031	+ * <p> For <code>host</code> specified in <i>literal IPv6 address</i>,
	1032	+ * either the form defined in RFC 2732 or the literal IPv6 address
	1033	+ * format defined in RFC 2373 is accepted. A literal IPv6 address may
	1034	+ * also be qualified by appending a scoped zone identifier or scope_id.
	1035	+ * The syntax and usage of scope_ids is described
	1036	+ * <a href="Inet6Address.html#scoped">here</a>.
	1037	+ * <p> If the host is <tt>null</tt> then an <tt>InetAddress</tt>
	1038	+ * representing an address of the loopback interface is returned.
	1039	+ * See <a href="http://www.ietf.org/rfc/rfc3330.txt">RFC 3330</a>
	1040	+ * section 2 and <a href="http://www.ietf.org/rfc/rfc2373.txt">RFC 2373</a>
	1041	+ * section 2.5.3. </p>
	1042	+ *
	1043	+ * <p> If there is a security manager and <code>host</code> is not
	1044	+ * null and <code>host.length() </code> is not equal to zero, the
	1045	+ * security manager's
	1046	+ * <code>checkConnect</code> method is called
	1047	+ * with the hostname and <code>-1</code>
	1048	+ * as its arguments to see if the operation is allowed.
	1049	+ *
	1050	+ * @param host the name of the host, or <code>null</code>.
	1051	+ * @return an array of all the IP addresses for a given host name.
	1052	+ *
	1053	+ * @exception UnknownHostException if no IP address for the
	1054	+ * <code>host</code> could be found, or if a scope_id was specified
	1055	+ * for a global IPv6 address.
	1056	+ * @exception SecurityException if a security manager exists and its
	1057	+ * <code>checkConnect</code> method doesn't allow the operation.
	1058	+ *
	1059	+ * @see SecurityManager#checkConnect
	1060	+ */
	1061	+ public static InetAddress[] getAllByName(String host)
	1062	+ throws UnknownHostException {
	1063	+ return getAllByName(host, null);
	1064	+ }
	1065	+
	1066	+ private static InetAddress[] getAllByName(String host, InetAddress reqAddr)
	1067	+ throws UnknownHostException {
	1068	+
	1069	+ if (host == null \|\| host.length() == 0) {
	1070	+ InetAddress[] ret = new InetAddress[1];
	1071	+ ret[0] = impl.loopbackAddress();
	1072	+ return ret;
	1073	+ }
	1074	+
	1075	+ boolean ipv6Expected = false;
	1076	+ if (host.charAt(0) == '[') {
	1077	+ // This is supposed to be an IPv6 literal
	1078	+ if (host.length() > 2 && host.charAt(host.length()-1) == ']') {
	1079	+ host = host.substring(1, host.length() -1);
	1080	+ ipv6Expected = true;
	1081	+ } else {
	1082	+ // This was supposed to be a IPv6 address, but it's not!
	1083	+ throw new UnknownHostException(host + ": invalid IPv6 address");
	1084	+ }
	1085	+ }
	1086	+
	1087	+ // if host is an IP address, we won't do further lookup
	1088	+ if (Character.digit(host.charAt(0), 16) != -1
	1089	+ \|\| (host.charAt(0) == ':')) {
	1090	+ byte[] addr = null;
	1091	+ int numericZone = -1;
	1092	+ String ifname = null;
	1093	+ // see if it is IPv4 address
	1094	+ addr = IPAddressUtil.textToNumericFormatV4(host);
	1095	+ if (addr == null) {
	1096	+ // see if it is IPv6 address
	1097	+ // Check if a numeric or string zone id is present
	1098	+ int pos;
	1099	+ if ((pos=host.indexOf ("%")) != -1) {
	1100	+ numericZone = checkNumericZone (host);
	1101	+ if (numericZone == -1) { /* remainder of string must be an ifname */
	1102	+ ifname = host.substring (pos+1);
	1103	+ }
	1104	+ }
	1105	+ addr = IPAddressUtil.textToNumericFormatV6(host);
	1106	+ } else if (ipv6Expected) {
	1107	+ // Means an IPv4 litteral between brackets!
	1108	+ throw new UnknownHostException("["+host+"]");
	1109	+ }
	1110	+ InetAddress[] ret = new InetAddress[1];
	1111	+ if(addr != null) {
	1112	+ if (addr.length == Inet4Address.INADDRSZ) {
	1113	+ ret[0] = new Inet4Address(null, addr);
	1114	+ } else {
	1115	+ if (ifname != null) {
	1116	+ ret[0] = new Inet6Address(null, addr, ifname);
	1117	+ } else {
	1118	+ ret[0] = new Inet6Address(null, addr, numericZone);
	1119	+ }
	1120	+ }
	1121	+ return ret;
	1122	+ }
	1123	+ } else if (ipv6Expected) {
	1124	+ // We were expecting an IPv6 Litteral, but got something else
	1125	+ throw new UnknownHostException("["+host+"]");
	1126	+ }
	1127	+ return getAllByName0(host, reqAddr, true);
	1128	+ }
	1129	+
	1130	+ /**
	1131	+ * Returns the loopback address.
	1132	+ * <p>
	1133	+ * The InetAddress returned will represent the IPv4
	1134	+ * loopback address, 127.0.0.1, or the IPv6 loopback
	1135	+ * address, ::1. The IPv4 loopback address returned
	1136	+ * is only one of many in the form 127...*
	1137	+ *
	1138	+ * @return the InetAddress loopback instance.
	1139	+ * @since 1.7
	1140	+ */
	1141	+ public static InetAddress getLoopbackAddress() {
	1142	+ return impl.loopbackAddress();
	1143	+ }
	1144	+
	1145	+
	1146	+ /**
	1147	+ * check if the literal address string has %nn appended
	1148	+ * returns -1 if not, or the numeric value otherwise.
	1149	+ *
	1150	+ * %nn may also be a string that represents the displayName of
	1151	+ * a currently available NetworkInterface.
	1152	+ */
	1153	+ private static int checkNumericZone (String s) throws UnknownHostException {
	1154	+ int percent = s.indexOf ('%');
	1155	+ int slen = s.length();
	1156	+ int digit, zone=0;
	1157	+ if (percent == -1) {
	1158	+ return -1;
	1159	+ }
	1160	+ for (int i=percent+1; i<slen; i++) {
	1161	+ char c = s.charAt(i);
	1162	+ if (c == ']') {
	1163	+ if (i == percent+1) {
	1164	+ /* empty per-cent field */
	1165	+ return -1;
	1166	+ }
	1167	+ break;
	1168	+ }
	1169	+ if ((digit = Character.digit (c, 10)) < 0) {
	1170	+ return -1;
	1171	+ }
	1172	+ zone = (zone * 10) + digit;
	1173	+ }
	1174	+ return zone;
	1175	+ }
	1176	+
	1177	+ private static InetAddress[] getAllByName0 (String host)
	1178	+ throws UnknownHostException
	1179	+ {
	1180	+ return getAllByName0(host, true);
	1181	+ }
	1182	+
	1183	+ /**
	1184	+ * package private so SocketPermission can call it
	1185	+ */
	1186	+ static InetAddress[] getAllByName0 (String host, boolean check)
	1187	+ throws UnknownHostException {
	1188	+ return getAllByName0 (host, null, check);
	1189	+ }
	1190	+
	1191	+ private static InetAddress[] getAllByName0 (String host, InetAddress reqAddr, boolean check)
	1192	+ throws UnknownHostException {
	1193	+
	1194	+ /* If it gets here it is presumed to be a hostname */
	1195	+ /* Cache.get can return: null, unknownAddress, or InetAddress[] */
	1196	+
	1197	+ /* make sure the connection to the host is allowed, before we
	1198	+ * give out a hostname
	1199	+ */
	1200	+ if (check) {
	1201	+ SecurityManager security = System.getSecurityManager();
	1202	+ if (security != null) {
	1203	+ security.checkConnect(host, -1);
	1204	+ }
	1205	+ }
	1206	+
	1207	+ InetAddress[] addresses = getCachedAddresses(host);
	1208	+
	1209	+ /* If no entry in cache, then do the host lookup */
	1210	+ if (addresses == null) {
	1211	+ addresses = getAddressesFromNameService(host, reqAddr);
	1212	+ }
	1213	+
	1214	+ if (addresses == unknown_array)
	1215	+ throw new UnknownHostException(host);
	1216	+
	1217	+ return addresses.clone();
	1218	+ }
	1219	+
	1220	+ private static InetAddress[] getAddressesFromNameService(String host, InetAddress reqAddr)
	1221	+ throws UnknownHostException
	1222	+ {
	1223	+ InetAddress[] addresses = null;
	1224	+ boolean success = false;
	1225	+ UnknownHostException ex = null;
	1226	+
	1227	+ // Check whether the host is in the lookupTable.
	1228	+ // 1) If the host isn't in the lookupTable when
	1229	+ // checkLookupTable() is called, checkLookupTable()
	1230	+ // would add the host in the lookupTable and
	1231	+ // return null. So we will do the lookup.
	1232	+ // 2) If the host is in the lookupTable when
	1233	+ // checkLookupTable() is called, the current thread
	1234	+ // would be blocked until the host is removed
	1235	+ // from the lookupTable. Then this thread
	1236	+ // should try to look up the addressCache.
	1237	+ // i) if it found the addresses in the
	1238	+ // addressCache, checkLookupTable() would
	1239	+ // return the addresses.
	1240	+ // ii) if it didn't find the addresses in the
	1241	+ // addressCache for any reason,
	1242	+ // it should add the host in the
	1243	+ // lookupTable and return null so the
	1244	+ // following code would do a lookup itself.
	1245	+ if ((addresses = checkLookupTable(host)) == null) {
	1246	+ try {
	1247	+ // This is the first thread which looks up the addresses
	1248	+ // this host or the cache entry for this host has been
	1249	+ // expired so this thread should do the lookup.
	1250	+ for (NameService nameService : nameServices) {
	1251	+ try {
	1252	+ /*
	1253	+ * Do not put the call to lookup() inside the
	1254	+ * constructor. if you do you will still be
	1255	+ * allocating space when the lookup fails.
	1256	+ */
	1257	+
	1258	+ addresses = nameService.lookupAllHostAddr(host);
	1259	+ success = true;
	1260	+ break;
	1261	+ } catch (UnknownHostException uhe) {
	1262	+ if (host.equalsIgnoreCase("localhost")) {
	1263	+ InetAddress[] local = new InetAddress[] { impl.loopbackAddress() };
	1264	+ addresses = local;
	1265	+ success = true;
	1266	+ break;
	1267	+ }
	1268	+ else {
	1269	+ addresses = unknown_array;
	1270	+ success = false;
	1271	+ ex = uhe;
	1272	+ }
	1273	+ }
	1274	+ }
	1275	+
	1276	+ // More to do?
	1277	+ if (reqAddr != null && addresses.length > 1 && !addresses[0].equals(reqAddr)) {
	1278	+ // Find it?
	1279	+ int i = 1;
	1280	+ for (; i < addresses.length; i++) {
	1281	+ if (addresses[i].equals(reqAddr)) {
	1282	+ break;
	1283	+ }
	1284	+ }
	1285	+ // Rotate
	1286	+ if (i < addresses.length) {
	1287	+ InetAddress tmp, tmp2 = reqAddr;
	1288	+ for (int j = 0; j < i; j++) {
	1289	+ tmp = addresses[j];
	1290	+ addresses[j] = tmp2;
	1291	+ tmp2 = tmp;
	1292	+ }
	1293	+ addresses[i] = tmp2;
	1294	+ }
	1295	+ }
	1296	+ // Cache the address.
	1297	+ cacheAddresses(host, addresses, success);
	1298	+
	1299	+ if (!success && ex != null)
	1300	+ throw ex;
	1301	+
	1302	+ } finally {
	1303	+ // Delete host from the lookupTable and notify
	1304	+ // all threads waiting on the lookupTable monitor.
	1305	+ updateLookupTable(host);
	1306	+ }
	1307	+ }
	1308	+
	1309	+ return addresses;
	1310	+ }
	1311	+
	1312	+
	1313	+ private static InetAddress[] checkLookupTable(String host) {
	1314	+ synchronized (lookupTable) {
	1315	+ // If the host isn't in the lookupTable, add it in the
	1316	+ // lookuptable and return null. The caller should do
	1317	+ // the lookup.
	1318	+ if (lookupTable.containsKey(host) == false) {
	1319	+ lookupTable.put(host, null);
	1320	+ return null;
	1321	+ }
	1322	+
	1323	+ // If the host is in the lookupTable, it means that another
	1324	+ // thread is trying to look up the addresses of this host.
	1325	+ // This thread should wait.
	1326	+ while (lookupTable.containsKey(host)) {
	1327	+ try {
	1328	+ lookupTable.wait();
	1329	+ } catch (InterruptedException e) {
	1330	+ }
	1331	+ }
	1332	+ }
	1333	+
	1334	+ // The other thread has finished looking up the addresses of
	1335	+ // the host. This thread should retry to get the addresses
	1336	+ // from the addressCache. If it doesn't get the addresses from
	1337	+ // the cache, it will try to look up the addresses itself.
	1338	+ InetAddress[] addresses = getCachedAddresses(host);
	1339	+ if (addresses == null) {
	1340	+ synchronized (lookupTable) {
	1341	+ lookupTable.put(host, null);
	1342	+ return null;
	1343	+ }
	1344	+ }
	1345	+
	1346	+ return addresses;
	1347	+ }
	1348	+
	1349	+ private static void updateLookupTable(String host) {
	1350	+ synchronized (lookupTable) {
	1351	+ lookupTable.remove(host);
	1352	+ lookupTable.notifyAll();
	1353	+ }
	1354	+ }
	1355	+
	1356	+ /**
	1357	+ * Returns an <code>InetAddress</code> object given the raw IP address .
	1358	+ * The argument is in network byte order: the highest order
	1359	+ * byte of the address is in <code>getAddress()[0]</code>.
	1360	+ *
	1361	+ * <p> This method doesn't block, i.e. no reverse name service lookup
	1362	+ * is performed.
	1363	+ *
	1364	+ * <p> IPv4 address byte array must be 4 bytes long and IPv6 byte array
	1365	+ * must be 16 bytes long
	1366	+ *
	1367	+ * @param addr the raw IP address in network byte order
	1368	+ * @return an InetAddress object created from the raw IP address.
	1369	+ * @exception UnknownHostException if IP address is of illegal length
	1370	+ * @since 1.4
	1371	+ */
	1372	+ public static InetAddress getByAddress(byte[] addr)
	1373	+ throws UnknownHostException {
	1374	+ return getByAddress(null, addr);
	1375	+ }
	1376	+
	1377	+ private static InetAddress cachedLocalHost = null;
	1378	+ private static long cacheTime = 0;
	1379	+ private static final long maxCacheTime = 5000L;
	1380	+ private static final Object cacheLock = new Object();
	1381	+
	1382	+ /**
	1383	+ * Returns the address of the local host. This is achieved by retrieving
	1384	+ * the name of the host from the system, then resolving that name into
	1385	+ * an <code>InetAddress</code>.
	1386	+ *
	1387	+ * <P>Note: The resolved address may be cached for a short period of time.
	1388	+ * </P>
	1389	+ *
	1390	+ * <p>If there is a security manager, its
	1391	+ * <code>checkConnect</code> method is called
	1392	+ * with the local host name and <code>-1</code>
	1393	+ * as its arguments to see if the operation is allowed.
	1394	+ * If the operation is not allowed, an InetAddress representing
	1395	+ * the loopback address is returned.
	1396	+ *
	1397	+ * @return the address of the local host.
	1398	+ *
	1399	+ * @exception UnknownHostException if the local host name could not
	1400	+ * be resolved into an address.
	1401	+ *
	1402	+ * @see SecurityManager#checkConnect
	1403	+ * @see java.net.InetAddress#getByName(java.lang.String)
	1404	+ */
	1405	+ public static InetAddress getLocalHost() throws UnknownHostException {
	1406	+
	1407	+ SecurityManager security = System.getSecurityManager();
	1408	+ try {
	1409	+ String local = impl.getLocalHostName();
	1410	+
	1411	+ if (security != null) {
	1412	+ security.checkConnect(local, -1);
	1413	+ }
	1414	+
	1415	+ if (local.equals("localhost")) {
	1416	+ return impl.loopbackAddress();
	1417	+ }
	1418	+
	1419	+ InetAddress ret = null;
	1420	+ synchronized (cacheLock) {
	1421	+ long now = System.currentTimeMillis();
	1422	+ if (cachedLocalHost != null) {
	1423	+ if ((now - cacheTime) < maxCacheTime) // Less than 5s old?
	1424	+ ret = cachedLocalHost;
	1425	+ else
	1426	+ cachedLocalHost = null;
	1427	+ }
	1428	+
	1429	+ // we are calling getAddressesFromNameService directly
	1430	+ // to avoid getting localHost from cache
	1431	+ if (ret == null) {
	1432	+ InetAddress[] localAddrs;
	1433	+ try {
	1434	+ localAddrs =
	1435	+ InetAddress.getAddressesFromNameService(local, null);
	1436	+ } catch (UnknownHostException uhe) {
	1437	+ // Rethrow with a more informative error message.
	1438	+ UnknownHostException uhe2 =
	1439	+ new UnknownHostException(local + ": " +
	1440	+ uhe.getMessage());
	1441	+ uhe2.initCause(uhe);
	1442	+ throw uhe2;
	1443	+ }
	1444	+ cachedLocalHost = localAddrs[0];
	1445	+ cacheTime = now;
	1446	+ ret = localAddrs[0];
	1447	+ }
	1448	+ }
	1449	+ return ret;
	1450	+ } catch (java.lang.SecurityException e) {
	1451	+ return impl.loopbackAddress();
	1452	+ }
	1453	+ }
	1454	+
	1455	+ /**
	1456	+ * Perform class load-time initializations.
	1457	+ */
	1458	+ private static native void init();
	1459	+
	1460	+
	1461	+ /*
	1462	+ * Returns the InetAddress representing anyLocalAddress
	1463	+ * (typically 0.0.0.0 or ::0)
	1464	+ */
	1465	+ static InetAddress anyLocalAddress() {
	1466	+ return impl.anyLocalAddress();
	1467	+ }
	1468	+
	1469	+ /*
	1470	+ * Load and instantiate an underlying impl class
	1471	+ */
	1472	+ static InetAddressImpl loadImpl(String implName) {
	1473	+ Object impl = null;
	1474	+
	1475	+ /*
	1476	+ * Property "impl.prefix" will be prepended to the classname
	1477	+ * of the implementation object we instantiate, to which we
	1478	+ * delegate the real work (like native methods). This
	1479	+ * property can vary across implementations of the java.
	1480	+ * classes. The default is an empty String "".
	1481	+ */
	1482	+ String prefix = AccessController.doPrivileged(
	1483	+ new GetPropertyAction("impl.prefix", ""));
	1484	+ try {
	1485	+ impl = Class.forName("java.net." + prefix + implName).newInstance();
	1486	+ } catch (ClassNotFoundException e) {
	1487	+ System.err.println("Class not found: java.net." + prefix +
	1488	+ implName + ":\ncheck impl.prefix property " +
	1489	+ "in your properties file.");
	1490	+ } catch (InstantiationException e) {
	1491	+ System.err.println("Could not instantiate: java.net." + prefix +
	1492	+ implName + ":\ncheck impl.prefix property " +
	1493	+ "in your properties file.");
	1494	+ } catch (IllegalAccessException e) {
	1495	+ System.err.println("Cannot access class: java.net." + prefix +
	1496	+ implName + ":\ncheck impl.prefix property " +
	1497	+ "in your properties file.");
	1498	+ }
	1499	+
	1500	+ if (impl == null) {
	1501	+ try {
	1502	+ impl = Class.forName(implName).newInstance();
	1503	+ } catch (Exception e) {
	1504	+ throw new Error("System property impl.prefix incorrect");
	1505	+ }
	1506	+ }
	1507	+
	1508	+ return (InetAddressImpl) impl;
	1509	+ }
	1510	+
	1511	+ private void readObjectNoData (ObjectInputStream s) throws
	1512	+ IOException, ClassNotFoundException {
	1513	+ if (getClass().getClassLoader() != null) {
	1514	+ throw new SecurityException ("invalid address type");
	1515	+ }
	1516	+ }
	1517	+
	1518	+ private void readObject (ObjectInputStream s) throws
	1519	+ IOException, ClassNotFoundException {
	1520	+ s.defaultReadObject ();
	1521	+ if (getClass().getClassLoader() != null) {
	1522	+ hostName = null;
	1523	+ address = 0;
	1524	+ throw new SecurityException ("invalid address type");
	1525	+ }
	1526	+ }
	1527	+}
	1528	+
	1529	+/*
	1530	+ * Simple factory to create the impl
	1531	+ */
	1532	+class InetAddressImplFactory {
	1533	+
	1534	+ static InetAddressImpl create() {
	1535	+ return InetAddress.loadImpl(isIPv6Supported() ?
	1536	+ "Inet6AddressImpl" : "Inet4AddressImpl");
	1537	+ }
	1538	+
	1539	+ static native boolean isIPv6Supported();
	1540	+}

java/pkg/java/net/InetAddressContainer.class+0−0

Binary file not shown.

java/pkg/java/net/InetAddressImpl.class+0−0

Binary file not shown.

java/pkg/java/net/InetAddressImpl.java+48−0

@@ -0,0 +1,48 @@
	1	+/*
	2	+ * Copyright (c) 2002, 2005, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+import java.io.IOException;
	28	+/*
	29	+ * Package private interface to "implementation" used by
	30	+ * {@link InetAddress}.
	31	+ * <p>
	32	+ * See {@link java.net.Inet4AddressImp} and
	33	+ * {@link java.net.Inet6AddressImp}.
	34	+ *
	35	+ * @since 1.4
	36	+ */
	37	+interface InetAddressImpl {
	38	+
	39	+ String getLocalHostName() throws UnknownHostException;
	40	+ InetAddress[]
	41	+ lookupAllHostAddr(String hostname) throws UnknownHostException;
	42	+ String getHostByAddr(byte[] addr) throws UnknownHostException;
	43	+
	44	+ InetAddress anyLocalAddress();
	45	+ InetAddress loopbackAddress();
	46	+ boolean isReachable(InetAddress addr, int timeout, NetworkInterface netif,
	47	+ int ttl) throws IOException;
	48	+}

java/pkg/java/net/InetAddressImplFactory.class+0−0

Binary file not shown.

java/pkg/java/net/InetSocketAddress.class+0−0

Binary file not shown.

java/pkg/java/net/InetSocketAddress.java+327−0

@@ -0,0 +1,327 @@
	1	+/*
	2	+ * Copyright (c) 2000, 2007, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+package java.net;
	26	+
	27	+import java.io.ObjectInputStream;
	28	+import java.io.IOException;
	29	+import java.io.InvalidObjectException;
	30	+
	31	+/**
	32	+ *
	33	+ * This class implements an IP Socket Address (IP address + port number)
	34	+ * It can also be a pair (hostname + port number), in which case an attempt
	35	+ * will be made to resolve the hostname. If resolution fails then the address
	36	+ * is said to be <I>unresolved</I> but can still be used on some circumstances
	37	+ * like connecting through a proxy.
	38	+ * <p>
	39	+ * It provides an immutable object used by sockets for binding, connecting, or
	40	+ * as returned values.
	41	+ * <p>
	42	+ * The <i>wildcard</i> is a special local IP address. It usually means "any"
	43	+ * and can only be used for <code>bind</code> operations.
	44	+ *
	45	+ * @see java.net.Socket
	46	+ * @see java.net.ServerSocket
	47	+ * @since 1.4
	48	+ */
	49	+public class InetSocketAddress extends SocketAddress {
	50	+ /* The hostname of the Socket Address
	51	+ * @serial
	52	+ */
	53	+ private String hostname = null;
	54	+ /* The IP address of the Socket Address
	55	+ * @serial
	56	+ */
	57	+ private InetAddress addr = null;
	58	+ /* The port number of the Socket Address
	59	+ * @serial
	60	+ */
	61	+ private int port;
	62	+
	63	+ private static final long serialVersionUID = 5076001401234631237L;
	64	+
	65	+ private InetSocketAddress() {
	66	+ }
	67	+
	68	+ /**
	69	+ * Creates a socket address where the IP address is the wildcard address
	70	+ * and the port number a specified value.
	71	+ * <p>
	72	+ * A valid port value is between 0 and 65535.
	73	+ * A port number of <code>zero</code> will let the system pick up an
	74	+ * ephemeral port in a <code>bind</code> operation.
	75	+ * <p>
	76	+ * @param port The port number
	77	+ * @throws IllegalArgumentException if the port parameter is outside the specified
	78	+ * range of valid port values.
	79	+ */
	80	+ public InetSocketAddress(int port) {
	81	+ this(InetAddress.anyLocalAddress(), port);
	82	+ }
	83	+
	84	+ /**
	85	+ *
	86	+ * Creates a socket address from an IP address and a port number.
	87	+ * <p>
	88	+ * A valid port value is between 0 and 65535.
	89	+ * A port number of <code>zero</code> will let the system pick up an
	90	+ * ephemeral port in a <code>bind</code> operation.
	91	+ * <P>
	92	+ * A <code>null</code> address will assign the <i>wildcard</i> address.
	93	+ * <p>
	94	+ * @param addr The IP address
	95	+ * @param port The port number
	96	+ * @throws IllegalArgumentException if the port parameter is outside the specified
	97	+ * range of valid port values.
	98	+ */
	99	+ public InetSocketAddress(InetAddress addr, int port) {
	100	+ if (port < 0 \|\| port > 0xFFFF) {
	101	+ throw new IllegalArgumentException("port out of range:" + port);
	102	+ }
	103	+ this.port = port;
	104	+ if (addr == null)
	105	+ this.addr = InetAddress.anyLocalAddress();
	106	+ else
	107	+ this.addr = addr;
	108	+ }
	109	+
	110	+ /**
	111	+ *
	112	+ * Creates a socket address from a hostname and a port number.
	113	+ * <p>
	114	+ * An attempt will be made to resolve the hostname into an InetAddress.
	115	+ * If that attempt fails, the address will be flagged as <I>unresolved</I>.
	116	+ * <p>
	117	+ * If there is a security manager, its <code>checkConnect</code> method
	118	+ * is called with the host name as its argument to check the permissiom
	119	+ * to resolve it. This could result in a SecurityException.
	120	+ * <P>
	121	+ * A valid port value is between 0 and 65535.
	122	+ * A port number of <code>zero</code> will let the system pick up an
	123	+ * ephemeral port in a <code>bind</code> operation.
	124	+ * <P>
	125	+ * @param hostname the Host name
	126	+ * @param port The port number
	127	+ * @throws IllegalArgumentException if the port parameter is outside the range
	128	+ * of valid port values, or if the hostname parameter is <TT>null</TT>.
	129	+ * @throws SecurityException if a security manager is present and
	130	+ * permission to resolve the host name is
	131	+ * denied.
	132	+ * @see #isUnresolved()
	133	+ */
	134	+ public InetSocketAddress(String hostname, int port) {
	135	+ if (port < 0 \|\| port > 0xFFFF) {
	136	+ throw new IllegalArgumentException("port out of range:" + port);
	137	+ }
	138	+ if (hostname == null) {
	139	+ throw new IllegalArgumentException("hostname can't be null");
	140	+ }
	141	+ try {
	142	+ addr = InetAddress.getByName(hostname);
	143	+ } catch(UnknownHostException e) {
	144	+ this.hostname = hostname;
	145	+ addr = null;
	146	+ }
	147	+ this.port = port;
	148	+ }
	149	+
	150	+ /**
	151	+ *
	152	+ * Creates an unresolved socket address from a hostname and a port number.
	153	+ * <p>
	154	+ * No attempt will be made to resolve the hostname into an InetAddress.
	155	+ * The address will be flagged as <I>unresolved</I>.
	156	+ * <p>
	157	+ * A valid port value is between 0 and 65535.
	158	+ * A port number of <code>zero</code> will let the system pick up an
	159	+ * ephemeral port in a <code>bind</code> operation.
	160	+ * <P>
	161	+ * @param host the Host name
	162	+ * @param port The port number
	163	+ * @throws IllegalArgumentException if the port parameter is outside
	164	+ * the range of valid port values, or if the hostname
	165	+ * parameter is <TT>null</TT>.
	166	+ * @see #isUnresolved()
	167	+ * @return a <code>InetSocketAddress</code> representing the unresolved
	168	+ * socket address
	169	+ * @since 1.5
	170	+ */
	171	+ public static InetSocketAddress createUnresolved(String host, int port) {
	172	+ if (port < 0 \|\| port > 0xFFFF) {
	173	+ throw new IllegalArgumentException("port out of range:" + port);
	174	+ }
	175	+ if (host == null) {
	176	+ throw new IllegalArgumentException("hostname can't be null");
	177	+ }
	178	+ InetSocketAddress s = new InetSocketAddress();
	179	+ s.port = port;
	180	+ s.hostname = host;
	181	+ s.addr = null;
	182	+ return s;
	183	+ }
	184	+
	185	+ private void readObject(ObjectInputStream s)
	186	+ throws IOException, ClassNotFoundException {
	187	+ s.defaultReadObject();
	188	+
	189	+ // Check that our invariants are satisfied
	190	+ if (port < 0 \|\| port > 0xFFFF) {
	191	+ throw new InvalidObjectException("port out of range:" + port);
	192	+ }
	193	+
	194	+ if (hostname == null && addr == null) {
	195	+ throw new InvalidObjectException("hostname and addr " +
	196	+ "can't both be null");
	197	+ }
	198	+ }
	199	+
	200	+ /**
	201	+ * Gets the port number.
	202	+ *
	203	+ * @return the port number.
	204	+ */
	205	+ public final int getPort() {
	206	+ return port;
	207	+ }
	208	+
	209	+ /**
	210	+ *
	211	+ * Gets the <code>InetAddress</code>.
	212	+ *
	213	+ * @return the InetAdress or <code>null</code> if it is unresolved.
	214	+ */
	215	+ public final InetAddress getAddress() {
	216	+ return addr;
	217	+ }
	218	+
	219	+ /**
	220	+ * Gets the <code>hostname</code>.
	221	+ * Note: This method may trigger a name service reverse lookup if the
	222	+ * address was created with a literal IP address.
	223	+ *
	224	+ * @return the hostname part of the address.
	225	+ */
	226	+ public final String getHostName() {
	227	+ if (hostname != null)
	228	+ return hostname;
	229	+ if (addr != null)
	230	+ return addr.getHostName();
	231	+ return null;
	232	+ }
	233	+
	234	+ /**
	235	+ * Returns the hostname, or the String form of the address if it
	236	+ * doesn't have a hostname (it was created using a literal).
	237	+ * This has the benefit of <b>not</b> attemptimg a reverse lookup.
	238	+ *
	239	+ * @return the hostname, or String representation of the address.
	240	+ * @since 1.7
	241	+ */
	242	+ public final String getHostString() {
	243	+ if (hostname != null)
	244	+ return hostname;
	245	+ if (addr != null) {
	246	+ if (addr.hostName != null)
	247	+ return addr.hostName;
	248	+ else
	249	+ return addr.getHostAddress();
	250	+ }
	251	+ return null;
	252	+ }
	253	+
	254	+ /**
	255	+ * Checks whether the address has been resolved or not.
	256	+ *
	257	+ * @return <code>true</code> if the hostname couldn't be resolved into
	258	+ * an <code>InetAddress</code>.
	259	+ */
	260	+ public final boolean isUnresolved() {
	261	+ return addr == null;
	262	+ }
	263	+
	264	+ /**
	265	+ * Constructs a string representation of this InetSocketAddress.
	266	+ * This String is constructed by calling toString() on the InetAddress
	267	+ * and concatenating the port number (with a colon). If the address
	268	+ * is unresolved then the part before the colon will only contain the hostname.
	269	+ *
	270	+ * @return a string representation of this object.
	271	+ */
	272	+ public String toString() {
	273	+ if (isUnresolved()) {
	274	+ return hostname + ":" + port;
	275	+ } else {
	276	+ return addr.toString() + ":" + port;
	277	+ }
	278	+ }
	279	+
	280	+ /**
	281	+ * Compares this object against the specified object.
	282	+ * The result is <code>true</code> if and only if the argument is
	283	+ * not <code>null</code> and it represents the same address as
	284	+ * this object.
	285	+ * <p>
	286	+ * Two instances of <code>InetSocketAddress</code> represent the same
	287	+ * address if both the InetAddresses (or hostnames if it is unresolved) and port
	288	+ * numbers are equal.
	289	+ * If both addresses are unresolved, then the hostname & the port number
	290	+ * are compared.
	291	+ *
	292	+ * Note: Hostnames are case insensitive. e.g. "FooBar" and "foobar" are
	293	+ * considered equal.
	294	+ *
	295	+ * @param obj the object to compare against.
	296	+ * @return <code>true</code> if the objects are the same;
	297	+ * <code>false</code> otherwise.
	298	+ * @see java.net.InetAddress#equals(java.lang.Object)
	299	+ */
	300	+ public final boolean equals(Object obj) {
	301	+ if (obj == null \|\| !(obj instanceof InetSocketAddress))
	302	+ return false;
	303	+ InetSocketAddress sockAddr = (InetSocketAddress) obj;
	304	+ boolean sameIP = false;
	305	+ if (this.addr != null)
	306	+ sameIP = this.addr.equals(sockAddr.addr);
	307	+ else if (this.hostname != null)
	308	+ sameIP = (sockAddr.addr == null) &&
	309	+ this.hostname.equalsIgnoreCase(sockAddr.hostname);
	310	+ else
	311	+ sameIP = (sockAddr.addr == null) && (sockAddr.hostname == null);
	312	+ return sameIP && (this.port == sockAddr.port);
	313	+ }
	314	+
	315	+ /**
	316	+ * Returns a hashcode for this socket address.
	317	+ *
	318	+ * @return a hash code value for this socket address.
	319	+ */
	320	+ public final int hashCode() {
	321	+ if (addr != null)
	322	+ return addr.hashCode() + port;
	323	+ if (hostname != null)
	324	+ return hostname.toLowerCase().hashCode() + port;
	325	+ return port;
	326	+ }
	327	+}

java/pkg/java/net/InterfaceAddress.class+0−0

Binary file not shown.

java/pkg/java/net/InterfaceAddress.java+134−0

@@ -0,0 +1,134 @@
	1	+/*
	2	+ * Copyright (c) 2005, 2008, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+/**
	29	+ * This class represents a Network Interface address. In short it's an
	30	+ * IP address, a subnet mask and a broadcast address when the address is
	31	+ * an IPv4 one. An IP address and a network prefix length in the case
	32	+ * of IPv6 address.
	33	+ *
	34	+ * @see java.net.NetworkInterface
	35	+ * @since 1.6
	36	+ */
	37	+public class InterfaceAddress {
	38	+ private InetAddress address = null;
	39	+ private Inet4Address broadcast = null;
	40	+ private short maskLength = 0;
	41	+
	42	+ /*
	43	+ * Package private constructor. Can't be built directly, instances are
	44	+ * obtained through the NetworkInterface class.
	45	+ */
	46	+ InterfaceAddress() {
	47	+ }
	48	+
	49	+ /**
	50	+ * Returns an <code>InetAddress</code> for this address.
	51	+ *
	52	+ * @return the <code>InetAddress</code> for this address.
	53	+ */
	54	+ public InetAddress getAddress() {
	55	+ return address;
	56	+ }
	57	+
	58	+ /**
	59	+ * Returns an <code>InetAddress</code> for the brodcast address
	60	+ * for this InterfaceAddress.
	61	+ * <p>
	62	+ * Only IPv4 networks have broadcast address therefore, in the case
	63	+ * of an IPv6 network, <code>null</code> will be returned.
	64	+ *
	65	+ * @return the <code>InetAddress</code> representing the broadcast
	66	+ * address or <code>null</code> if there is no broadcast address.
	67	+ */
	68	+ public InetAddress getBroadcast() {
	69	+ return broadcast;
	70	+ }
	71	+
	72	+ /**
	73	+ * Returns the network prefix length for this address. This is also known
	74	+ * as the subnet mask in the context of IPv4 addresses.
	75	+ * Typical IPv4 values would be 8 (255.0.0.0), 16 (255.255.0.0)
	76	+ * or 24 (255.255.255.0). <p>
	77	+ * Typical IPv6 values would be 128 (::1/128) or 10 (fe80::203:baff:fe27:1243/10)
	78	+ *
	79	+ * @return a <code>short</code> representing the prefix length for the
	80	+ * subnet of that address.
	81	+ */
	82	+ public short getNetworkPrefixLength() {
	83	+ return maskLength;
	84	+ }
	85	+
	86	+ /**
	87	+ * Compares this object against the specified object.
	88	+ * The result is <code>true</code> if and only if the argument is
	89	+ * not <code>null</code> and it represents the same interface address as
	90	+ * this object.
	91	+ * <p>
	92	+ * Two instances of <code>InterfaceAddress</code> represent the same
	93	+ * address if the InetAddress, the prefix length and the broadcast are
	94	+ * the same for both.
	95	+ *
	96	+ * @param obj the object to compare against.
	97	+ * @return <code>true</code> if the objects are the same;
	98	+ * <code>false</code> otherwise.
	99	+ * @see java.net.InterfaceAddress#hashCode()
	100	+ */
	101	+ public boolean equals(Object obj) {
	102	+ if (!(obj instanceof InterfaceAddress)) {
	103	+ return false;
	104	+ }
	105	+ InterfaceAddress cmp = (InterfaceAddress) obj;
	106	+ if ( !(address == null ? cmp.address == null : address.equals(cmp.address)) )
	107	+ return false;
	108	+ if ( !(broadcast == null ? cmp.broadcast == null : broadcast.equals(cmp.broadcast)) )
	109	+ return false;
	110	+ if (maskLength != cmp.maskLength)
	111	+ return false;
	112	+ return true;
	113	+ }
	114	+
	115	+ /**
	116	+ * Returns a hashcode for this Interface address.
	117	+ *
	118	+ * @return a hash code value for this Interface address.
	119	+ */
	120	+ public int hashCode() {
	121	+ return address.hashCode() + ((broadcast != null) ? broadcast.hashCode() : 0) + maskLength;
	122	+ }
	123	+
	124	+ /**
	125	+ * Converts this Interface address to a <code>String</code>. The
	126	+ * string returned is of the form: InetAddress / prefix length [ broadcast address ].
	127	+ *
	128	+ * @return a string representation of this Interface address.
	129	+ */
	130	+ public String toString() {
	131	+ return address + "/" + maskLength + " [" + broadcast + "]";
	132	+ }
	133	+
	134	+}

java/pkg/java/net/JarURLConnection.class+0−0

Binary file not shown.

java/pkg/java/net/JarURLConnection.java+313−0

@@ -0,0 +1,313 @@
	1	+/*
	2	+ * Copyright (c) 1997, 2006, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.io.IOException;
	29	+import java.util.jar.JarFile;
	30	+import java.util.jar.JarEntry;
	31	+import java.util.jar.Attributes;
	32	+import java.util.jar.Manifest;
	33	+import java.security.Permission;
	34	+import sun.net.www.ParseUtil;
	35	+
	36	+/**
	37	+ * A URL Connection to a Java ARchive (JAR) file or an entry in a JAR
	38	+ * file.
	39	+ *
	40	+ * <p>The syntax of a JAR URL is:
	41	+ *
	42	+ * <pre>
	43	+ * jar:<url>!/{entry}
	44	+ * </pre>
	45	+ *
	46	+ * <p>for example:
	47	+ *
	48	+ * <p><code>
	49	+ * jar:http://www.foo.com/bar/baz.jar!/COM/foo/Quux.class<br>
	50	+ * </code>
	51	+ *
	52	+ * <p>Jar URLs should be used to refer to a JAR file or entries in
	53	+ * a JAR file. The example above is a JAR URL which refers to a JAR
	54	+ * entry. If the entry name is omitted, the URL refers to the whole
	55	+ * JAR file:
	56	+ *
	57	+ * <code>
	58	+ * jar:http://www.foo.com/bar/baz.jar!/
	59	+ * </code>
	60	+ *
	61	+ * <p>Users should cast the generic URLConnection to a
	62	+ * JarURLConnection when they know that the URL they created is a JAR
	63	+ * URL, and they need JAR-specific functionality. For example:
	64	+ *
	65	+ * <pre>
	66	+ * URL url = new URL("jar:file:/home/duke/duke.jar!/");
	67	+ * JarURLConnection jarConnection = (JarURLConnection)url.openConnection();
	68	+ * Manifest manifest = jarConnection.getManifest();
	69	+ * </pre>
	70	+ *
	71	+ * <p>JarURLConnection instances can only be used to read from JAR files.
	72	+ * It is not possible to get a {@link java.io.OutputStream} to modify or write
	73	+ * to the underlying JAR file using this class.
	74	+ * <p>Examples:
	75	+ *
	76	+ * <dl>
	77	+ *
	78	+ * <dt>A Jar entry
	79	+ * <dd><code>jar:http://www.foo.com/bar/baz.jar!/COM/foo/Quux.class</code>
	80	+ *
	81	+ * <dt>A Jar file
	82	+ * <dd><code>jar:http://www.foo.com/bar/baz.jar!/</code>
	83	+ *
	84	+ * <dt>A Jar directory
	85	+ * <dd><code>jar:http://www.foo.com/bar/baz.jar!/COM/foo/</code>
	86	+ *
	87	+ * </dl>
	88	+ *
	89	+ * <p><code>!/</code> is refered to as the <em>separator</em>.
	90	+ *
	91	+ * <p>When constructing a JAR url via <code>new URL(context, spec)</code>,
	92	+ * the following rules apply:
	93	+ *
	94	+ * <ul>
	95	+ *
	96	+ * <li>if there is no context URL and the specification passed to the
	97	+ * URL constructor doesn't contain a separator, the URL is considered
	98	+ * to refer to a JarFile.
	99	+ *
	100	+ * <li>if there is a context URL, the context URL is assumed to refer
	101	+ * to a JAR file or a Jar directory.
	102	+ *
	103	+ * <li>if the specification begins with a '/', the Jar directory is
	104	+ * ignored, and the spec is considered to be at the root of the Jar
	105	+ * file.
	106	+ *
	107	+ * <p>Examples:
	108	+ *
	109	+ * <dl>
	110	+ *
	111	+ * <dt>context: <b>jar:http://www.foo.com/bar/jar.jar!/</b>,
	112	+ * spec:<b>baz/entry.txt</b>
	113	+ *
	114	+ * <dd>url:<b>jar:http://www.foo.com/bar/jar.jar!/baz/entry.txt</b>
	115	+ *
	116	+ * <dt>context: <b>jar:http://www.foo.com/bar/jar.jar!/baz</b>,
	117	+ * spec:<b>entry.txt</b>
	118	+ *
	119	+ * <dd>url:<b>jar:http://www.foo.com/bar/jar.jar!/baz/entry.txt</b>
	120	+ *
	121	+ * <dt>context: <b>jar:http://www.foo.com/bar/jar.jar!/baz</b>,
	122	+ * spec:<b>/entry.txt</b>
	123	+ *
	124	+ * <dd>url:<b>jar:http://www.foo.com/bar/jar.jar!/entry.txt</b>
	125	+ *
	126	+ * </dl>
	127	+ *
	128	+ * </ul>
	129	+ *
	130	+ * @see java.net.URL
	131	+ * @see java.net.URLConnection
	132	+ *
	133	+ * @see java.util.jar.JarFile
	134	+ * @see java.util.jar.JarInputStream
	135	+ * @see java.util.jar.Manifest
	136	+ * @see java.util.zip.ZipEntry
	137	+ *
	138	+ * @author Benjamin Renaud
	139	+ * @since 1.2
	140	+ */
	141	+public abstract class JarURLConnection extends URLConnection {
	142	+
	143	+ private URL jarFileURL;
	144	+ private String entryName;
	145	+
	146	+ /**
	147	+ * The connection to the JAR file URL, if the connection has been
	148	+ * initiated. This should be set by connect.
	149	+ */
	150	+ protected URLConnection jarFileURLConnection;
	151	+
	152	+ /**
	153	+ * Creates the new JarURLConnection to the specified URL.
	154	+ * @param url the URL
	155	+ * @throws MalformedURLException if no legal protocol
	156	+ * could be found in a specification string or the
	157	+ * string could not be parsed.
	158	+ */
	159	+
	160	+ protected JarURLConnection(URL url) throws MalformedURLException {
	161	+ super(url);
	162	+ parseSpecs(url);
	163	+ }
	164	+
	165	+ /* get the specs for a given url out of the cache, and compute and
	166	+ * cache them if they're not there.
	167	+ */
	168	+ private void parseSpecs(URL url) throws MalformedURLException {
	169	+ String spec = url.getFile();
	170	+
	171	+ int separator = spec.indexOf("!/");
	172	+ /*
	173	+ * REMIND: we don't handle nested JAR URLs
	174	+ */
	175	+ if (separator == -1) {
	176	+ throw new MalformedURLException("no !/ found in url spec:" + spec);
	177	+ }
	178	+
	179	+ jarFileURL = new URL(spec.substring(0, separator++));
	180	+ entryName = null;
	181	+
	182	+ /* if ! is the last letter of the innerURL, entryName is null */
	183	+ if (++separator != spec.length()) {
	184	+ entryName = spec.substring(separator, spec.length());
	185	+ entryName = ParseUtil.decode (entryName);
	186	+ }
	187	+ }
	188	+
	189	+ /**
	190	+ * Returns the URL for the Jar file for this connection.
	191	+ *
	192	+ * @return the URL for the Jar file for this connection.
	193	+ */
	194	+ public URL getJarFileURL() {
	195	+ return jarFileURL;
	196	+ }
	197	+
	198	+ /**
	199	+ * Return the entry name for this connection. This method
	200	+ * returns null if the JAR file URL corresponding to this
	201	+ * connection points to a JAR file and not a JAR file entry.
	202	+ *
	203	+ * @return the entry name for this connection, if any.
	204	+ */
	205	+ public String getEntryName() {
	206	+ return entryName;
	207	+ }
	208	+
	209	+ /**
	210	+ * Return the JAR file for this connection.
	211	+ *
	212	+ * @return the JAR file for this connection. If the connection is
	213	+ * a connection to an entry of a JAR file, the JAR file object is
	214	+ * returned
	215	+ *
	216	+ * @exception IOException if an IOException occurs while trying to
	217	+ * connect to the JAR file for this connection.
	218	+ *
	219	+ * @see #connect
	220	+ */
	221	+ public abstract JarFile getJarFile() throws IOException;
	222	+
	223	+ /**
	224	+ * Returns the Manifest for this connection, or null if none.
	225	+ *
	226	+ * @return the manifest object corresponding to the JAR file object
	227	+ * for this connection.
	228	+ *
	229	+ * @exception IOException if getting the JAR file for this
	230	+ * connection causes an IOException to be trown.
	231	+ *
	232	+ * @see #getJarFile
	233	+ */
	234	+ public Manifest getManifest() throws IOException {
	235	+ return getJarFile().getManifest();
	236	+ }
	237	+
	238	+ /**
	239	+ * Return the JAR entry object for this connection, if any. This
	240	+ * method returns null if the JAR file URL corresponding to this
	241	+ * connection points to a JAR file and not a JAR file entry.
	242	+ *
	243	+ * @return the JAR entry object for this connection, or null if
	244	+ * the JAR URL for this connection points to a JAR file.
	245	+ *
	246	+ * @exception IOException if getting the JAR file for this
	247	+ * connection causes an IOException to be trown.
	248	+ *
	249	+ * @see #getJarFile
	250	+ * @see #getJarEntry
	251	+ */
	252	+ public JarEntry getJarEntry() throws IOException {
	253	+ return getJarFile().getJarEntry(entryName);
	254	+ }
	255	+
	256	+ /**
	257	+ * Return the Attributes object for this connection if the URL
	258	+ * for it points to a JAR file entry, null otherwise.
	259	+ *
	260	+ * @return the Attributes object for this connection if the URL
	261	+ * for it points to a JAR file entry, null otherwise.
	262	+ *
	263	+ * @exception IOException if getting the JAR entry causes an
	264	+ * IOException to be thrown.
	265	+ *
	266	+ * @see #getJarEntry
	267	+ */
	268	+ public Attributes getAttributes() throws IOException {
	269	+ JarEntry e = getJarEntry();
	270	+ return e != null ? e.getAttributes() : null;
	271	+ }
	272	+
	273	+ /**
	274	+ * Returns the main Attributes for the JAR file for this
	275	+ * connection.
	276	+ *
	277	+ * @return the main Attributes for the JAR file for this
	278	+ * connection.
	279	+ *
	280	+ * @exception IOException if getting the manifest causes an
	281	+ * IOException to be thrown.
	282	+ *
	283	+ * @see #getJarFile
	284	+ * @see #getManifest
	285	+ */
	286	+ public Attributes getMainAttributes() throws IOException {
	287	+ Manifest man = getManifest();
	288	+ return man != null ? man.getMainAttributes() : null;
	289	+ }
	290	+
	291	+ /**
	292	+ * Return the Certificate object for this connection if the URL
	293	+ * for it points to a JAR file entry, null otherwise. This method
	294	+ * can only be called once
	295	+ * the connection has been completely verified by reading
	296	+ * from the input stream until the end of the stream has been
	297	+ * reached. Otherwise, this method will return <code>null</code>
	298	+ *
	299	+ * @return the Certificate object for this connection if the URL
	300	+ * for it points to a JAR file entry, null otherwise.
	301	+ *
	302	+ * @exception IOException if getting the JAR entry causes an
	303	+ * IOException to be thrown.
	304	+ *
	305	+ * @see #getJarEntry
	306	+ */
	307	+ public java.security.cert.Certificate[] getCertificates()
	308	+ throws IOException
	309	+ {
	310	+ JarEntry e = getJarEntry();
	311	+ return e != null ? e.getCertificates() : null;
	312	+ }
	313	+}

java/pkg/java/net/MalformedURLException.class+0−0

Binary file not shown.

java/pkg/java/net/MalformedURLException.java+56−0

@@ -0,0 +1,56 @@
	1	+/*
	2	+ * Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.io.IOException;
	29	+
	30	+/**
	31	+ * Thrown to indicate that a malformed URL has occurred. Either no
	32	+ * legal protocol could be found in a specification string or the
	33	+ * string could not be parsed.
	34	+ *
	35	+ * @author Arthur van Hoff
	36	+ * @since JDK1.0
	37	+ */
	38	+public class MalformedURLException extends IOException {
	39	+ private static final long serialVersionUID = -182787522200415866L;
	40	+
	41	+ /**
	42	+ * Constructs a <code>MalformedURLException</code> with no detail message.
	43	+ */
	44	+ public MalformedURLException() {
	45	+ }
	46	+
	47	+ /**
	48	+ * Constructs a <code>MalformedURLException</code> with the
	49	+ * specified detail message.
	50	+ *
	51	+ * @param msg the detail message.
	52	+ */
	53	+ public MalformedURLException(String msg) {
	54	+ super(msg);
	55	+ }
	56	+}

java/pkg/java/net/MulticastSocket.class+0−0

Binary file not shown.

java/pkg/java/net/MulticastSocket.java+686−0

@@ -0,0 +1,686 @@
	1	+/*
	2	+ * Copyright (c) 1995, 2007, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.io.IOException;
	29	+import java.io.InterruptedIOException;
	30	+import java.util.Enumeration;
	31	+
	32	+/**
	33	+ * The multicast datagram socket class is useful for sending
	34	+ * and receiving IP multicast packets. A MulticastSocket is
	35	+ * a (UDP) DatagramSocket, with additional capabilities for
	36	+ * joining "groups" of other multicast hosts on the internet.
	37	+ * <P>
	38	+ * A multicast group is specified by a class D IP address
	39	+ * and by a standard UDP port number. Class D IP addresses
	40	+ * are in the range <CODE>224.0.0.0</CODE> to <CODE>239.255.255.255</CODE>,
	41	+ * inclusive. The address 224.0.0.0 is reserved and should not be used.
	42	+ * <P>
	43	+ * One would join a multicast group by first creating a MulticastSocket
	44	+ * with the desired port, then invoking the
	45	+ * <CODE>joinGroup(InetAddress groupAddr)</CODE>
	46	+ * method:
	47	+ * <PRE>
	48	+ * // join a Multicast group and send the group salutations
	49	+ * ...
	50	+ * String msg = "Hello";
	51	+ * InetAddress group = InetAddress.getByName("228.5.6.7");
	52	+ * MulticastSocket s = new MulticastSocket(6789);
	53	+ * s.joinGroup(group);
	54	+ * DatagramPacket hi = new DatagramPacket(msg.getBytes(), msg.length(),
	55	+ * group, 6789);
	56	+ * s.send(hi);
	57	+ * // get their responses!
	58	+ * byte[] buf = new byte[1000];
	59	+ * DatagramPacket recv = new DatagramPacket(buf, buf.length);
	60	+ * s.receive(recv);
	61	+ * ...
	62	+ * // OK, I'm done talking - leave the group...
	63	+ * s.leaveGroup(group);
	64	+ * </PRE>
	65	+ *
	66	+ * When one sends a message to a multicast group, <B>all</B> subscribing
	67	+ * recipients to that host and port receive the message (within the
	68	+ * time-to-live range of the packet, see below). The socket needn't
	69	+ * be a member of the multicast group to send messages to it.
	70	+ * <P>
	71	+ * When a socket subscribes to a multicast group/port, it receives
	72	+ * datagrams sent by other hosts to the group/port, as do all other
	73	+ * members of the group and port. A socket relinquishes membership
	74	+ * in a group by the leaveGroup(InetAddress addr) method. <B>
	75	+ * Multiple MulticastSocket's</B> may subscribe to a multicast group
	76	+ * and port concurrently, and they will all receive group datagrams.
	77	+ * <P>
	78	+ * Currently applets are not allowed to use multicast sockets.
	79	+ *
	80	+ * @author Pavani Diwanji
	81	+ * @since JDK1.1
	82	+ */
	83	+public
	84	+class MulticastSocket extends DatagramSocket {
	85	+ /**
	86	+ * Create a multicast socket.
	87	+ *
	88	+ * <p>If there is a security manager,
	89	+ * its <code>checkListen</code> method is first called
	90	+ * with 0 as its argument to ensure the operation is allowed.
	91	+ * This could result in a SecurityException.
	92	+ * <p>
	93	+ * When the socket is created the
	94	+ * {@link DatagramSocket#setReuseAddress(boolean)} method is
	95	+ * called to enable the SO_REUSEADDR socket option.
	96	+ *
	97	+ * @exception IOException if an I/O exception occurs
	98	+ * while creating the MulticastSocket
	99	+ * @exception SecurityException if a security manager exists and its
	100	+ * <code>checkListen</code> method doesn't allow the operation.
	101	+ * @see SecurityManager#checkListen
	102	+ * @see java.net.DatagramSocket#setReuseAddress(boolean)
	103	+ */
	104	+ public MulticastSocket() throws IOException {
	105	+ this(new InetSocketAddress(0));
	106	+ }
	107	+
	108	+ /**
	109	+ * Create a multicast socket and bind it to a specific port.
	110	+ *
	111	+ * <p>If there is a security manager,
	112	+ * its <code>checkListen</code> method is first called
	113	+ * with the <code>port</code> argument
	114	+ * as its argument to ensure the operation is allowed.
	115	+ * This could result in a SecurityException.
	116	+ * <p>
	117	+ * When the socket is created the
	118	+ * {@link DatagramSocket#setReuseAddress(boolean)} method is
	119	+ * called to enable the SO_REUSEADDR socket option.
	120	+ *
	121	+ * @param port port to use
	122	+ * @exception IOException if an I/O exception occurs
	123	+ * while creating the MulticastSocket
	124	+ * @exception SecurityException if a security manager exists and its
	125	+ * <code>checkListen</code> method doesn't allow the operation.
	126	+ * @see SecurityManager#checkListen
	127	+ * @see java.net.DatagramSocket#setReuseAddress(boolean)
	128	+ */
	129	+ public MulticastSocket(int port) throws IOException {
	130	+ this(new InetSocketAddress(port));
	131	+ }
	132	+
	133	+ /**
	134	+ * Create a MulticastSocket bound to the specified socket address.
	135	+ * <p>
	136	+ * Or, if the address is <code>null</code>, create an unbound socket.
	137	+ * <p>
	138	+ * <p>If there is a security manager,
	139	+ * its <code>checkListen</code> method is first called
	140	+ * with the SocketAddress port as its argument to ensure the operation is allowed.
	141	+ * This could result in a SecurityException.
	142	+ * <p>
	143	+ * When the socket is created the
	144	+ * {@link DatagramSocket#setReuseAddress(boolean)} method is
	145	+ * called to enable the SO_REUSEADDR socket option.
	146	+ *
	147	+ * @param bindaddr Socket address to bind to, or <code>null</code> for
	148	+ * an unbound socket.
	149	+ * @exception IOException if an I/O exception occurs
	150	+ * while creating the MulticastSocket
	151	+ * @exception SecurityException if a security manager exists and its
	152	+ * <code>checkListen</code> method doesn't allow the operation.
	153	+ * @see SecurityManager#checkListen
	154	+ * @see java.net.DatagramSocket#setReuseAddress(boolean)
	155	+ *
	156	+ * @since 1.4
	157	+ */
	158	+ public MulticastSocket(SocketAddress bindaddr) throws IOException {
	159	+ super((SocketAddress) null);
	160	+
	161	+ // Enable SO_REUSEADDR before binding
	162	+ setReuseAddress(true);
	163	+
	164	+ if (bindaddr != null) {
	165	+ bind(bindaddr);
	166	+ }
	167	+ }
	168	+
	169	+ /**
	170	+ * The lock on the socket's TTL. This is for set/getTTL and
	171	+ * send(packet,ttl).
	172	+ */
	173	+ private Object ttlLock = new Object();
	174	+
	175	+ /**
	176	+ * The lock on the socket's interface - used by setInterface
	177	+ * and getInterface
	178	+ */
	179	+ private Object infLock = new Object();
	180	+
	181	+ /**
	182	+ * The "last" interface set by setInterface on this MulticastSocket
	183	+ */
	184	+ private InetAddress infAddress = null;
	185	+
	186	+
	187	+ /**
	188	+ * Set the default time-to-live for multicast packets sent out
	189	+ * on this <code>MulticastSocket</code> in order to control the
	190	+ * scope of the multicasts.
	191	+ *
	192	+ * <p>The ttl is an <b>unsigned</b> 8-bit quantity, and so <B>must</B> be
	193	+ * in the range <code> 0 <= ttl <= 0xFF </code>.
	194	+ *
	195	+ * @param ttl the time-to-live
	196	+ * @exception IOException if an I/O exception occurs
	197	+ * while setting the default time-to-live value
	198	+ * @deprecated use the setTimeToLive method instead, which uses
	199	+ * <b>int</b> instead of <b>byte</b> as the type for ttl.
	200	+ * @see #getTTL()
	201	+ */
	202	+ @Deprecated
	203	+ public void setTTL(byte ttl) throws IOException {
	204	+ if (isClosed())
	205	+ throw new SocketException("Socket is closed");
	206	+ getImpl().setTTL(ttl);
	207	+ }
	208	+
	209	+ /**
	210	+ * Set the default time-to-live for multicast packets sent out
	211	+ * on this {@code MulticastSocket} in order to control the
	212	+ * scope of the multicasts.
	213	+ *
	214	+ * <P> The ttl <B>must</B> be in the range {@code 0 <= ttl <=
	215	+ * 255} or an {@code IllegalArgumentException} will be thrown.
	216	+ * Multicast packets sent with a TTL of {@code 0} are not transmitted
	217	+ * on the network but may be delivered locally.
	218	+ *
	219	+ * @param ttl
	220	+ * the time-to-live
	221	+ *
	222	+ * @throws IOException
	223	+ * if an I/O exception occurs while setting the
	224	+ * default time-to-live value
	225	+ *
	226	+ * @see #getTimeToLive()
	227	+ */
	228	+ public void setTimeToLive(int ttl) throws IOException {
	229	+ if (ttl < 0 \|\| ttl > 255) {
	230	+ throw new IllegalArgumentException("ttl out of range");
	231	+ }
	232	+ if (isClosed())
	233	+ throw new SocketException("Socket is closed");
	234	+ getImpl().setTimeToLive(ttl);
	235	+ }
	236	+
	237	+ /**
	238	+ * Get the default time-to-live for multicast packets sent out on
	239	+ * the socket.
	240	+ *
	241	+ * @exception IOException if an I/O exception occurs
	242	+ * while getting the default time-to-live value
	243	+ * @return the default time-to-live value
	244	+ * @deprecated use the getTimeToLive method instead, which returns
	245	+ * an <b>int</b> instead of a <b>byte</b>.
	246	+ * @see #setTTL(byte)
	247	+ */
	248	+ @Deprecated
	249	+ public byte getTTL() throws IOException {
	250	+ if (isClosed())
	251	+ throw new SocketException("Socket is closed");
	252	+ return getImpl().getTTL();
	253	+ }
	254	+
	255	+ /**
	256	+ * Get the default time-to-live for multicast packets sent out on
	257	+ * the socket.
	258	+ * @exception IOException if an I/O exception occurs while
	259	+ * getting the default time-to-live value
	260	+ * @return the default time-to-live value
	261	+ * @see #setTimeToLive(int)
	262	+ */
	263	+ public int getTimeToLive() throws IOException {
	264	+ if (isClosed())
	265	+ throw new SocketException("Socket is closed");
	266	+ return getImpl().getTimeToLive();
	267	+ }
	268	+
	269	+ /**
	270	+ * Joins a multicast group. Its behavior may be affected by
	271	+ * <code>setInterface</code> or <code>setNetworkInterface</code>.
	272	+ *
	273	+ * <p>If there is a security manager, this method first
	274	+ * calls its <code>checkMulticast</code> method
	275	+ * with the <code>mcastaddr</code> argument
	276	+ * as its argument.
	277	+ *
	278	+ * @param mcastaddr is the multicast address to join
	279	+ *
	280	+ * @exception IOException if there is an error joining
	281	+ * or when the address is not a multicast address.
	282	+ * @exception SecurityException if a security manager exists and its
	283	+ * <code>checkMulticast</code> method doesn't allow the join.
	284	+ *
	285	+ * @see SecurityManager#checkMulticast(InetAddress)
	286	+ */
	287	+ public void joinGroup(InetAddress mcastaddr) throws IOException {
	288	+ if (isClosed()) {
	289	+ throw new SocketException("Socket is closed");
	290	+ }
	291	+
	292	+ checkAddress(mcastaddr, "joinGroup");
	293	+ SecurityManager security = System.getSecurityManager();
	294	+ if (security != null) {
	295	+ security.checkMulticast(mcastaddr);
	296	+ }
	297	+
	298	+ if (!mcastaddr.isMulticastAddress()) {
	299	+ throw new SocketException("Not a multicast address");
	300	+ }
	301	+
	302	+ getImpl().join(mcastaddr);
	303	+ }
	304	+
	305	+ /**
	306	+ * Leave a multicast group. Its behavior may be affected by
	307	+ * <code>setInterface</code> or <code>setNetworkInterface</code>.
	308	+ *
	309	+ * <p>If there is a security manager, this method first
	310	+ * calls its <code>checkMulticast</code> method
	311	+ * with the <code>mcastaddr</code> argument
	312	+ * as its argument.
	313	+ *
	314	+ * @param mcastaddr is the multicast address to leave
	315	+ * @exception IOException if there is an error leaving
	316	+ * or when the address is not a multicast address.
	317	+ * @exception SecurityException if a security manager exists and its
	318	+ * <code>checkMulticast</code> method doesn't allow the operation.
	319	+ *
	320	+ * @see SecurityManager#checkMulticast(InetAddress)
	321	+ */
	322	+ public void leaveGroup(InetAddress mcastaddr) throws IOException {
	323	+ if (isClosed()) {
	324	+ throw new SocketException("Socket is closed");
	325	+ }
	326	+
	327	+ checkAddress(mcastaddr, "leaveGroup");
	328	+ SecurityManager security = System.getSecurityManager();
	329	+ if (security != null) {
	330	+ security.checkMulticast(mcastaddr);
	331	+ }
	332	+
	333	+ if (!mcastaddr.isMulticastAddress()) {
	334	+ throw new SocketException("Not a multicast address");
	335	+ }
	336	+
	337	+ getImpl().leave(mcastaddr);
	338	+ }
	339	+
	340	+ /**
	341	+ * Joins the specified multicast group at the specified interface.
	342	+ *
	343	+ * <p>If there is a security manager, this method first
	344	+ * calls its <code>checkMulticast</code> method
	345	+ * with the <code>mcastaddr</code> argument
	346	+ * as its argument.
	347	+ *
	348	+ * @param mcastaddr is the multicast address to join
	349	+ * @param netIf specifies the local interface to receive multicast
	350	+ * datagram packets, or <i>null</i> to defer to the interface set by
	351	+ * {@link MulticastSocket#setInterface(InetAddress)} or
	352	+ * {@link MulticastSocket#setNetworkInterface(NetworkInterface)}
	353	+ *
	354	+ * @exception IOException if there is an error joining
	355	+ * or when the address is not a multicast address.
	356	+ * @exception SecurityException if a security manager exists and its
	357	+ * <code>checkMulticast</code> method doesn't allow the join.
	358	+ * @throws IllegalArgumentException if mcastaddr is null or is a
	359	+ * SocketAddress subclass not supported by this socket
	360	+ *
	361	+ * @see SecurityManager#checkMulticast(InetAddress)
	362	+ * @since 1.4
	363	+ */
	364	+ public void joinGroup(SocketAddress mcastaddr, NetworkInterface netIf)
	365	+ throws IOException {
	366	+ if (isClosed())
	367	+ throw new SocketException("Socket is closed");
	368	+
	369	+ if (mcastaddr == null \|\| !(mcastaddr instanceof InetSocketAddress))
	370	+ throw new IllegalArgumentException("Unsupported address type");
	371	+
	372	+ if (oldImpl)
	373	+ throw new UnsupportedOperationException();
	374	+
	375	+ checkAddress(((InetSocketAddress)mcastaddr).getAddress(), "joinGroup");
	376	+ SecurityManager security = System.getSecurityManager();
	377	+ if (security != null) {
	378	+ security.checkMulticast(((InetSocketAddress)mcastaddr).getAddress());
	379	+ }
	380	+
	381	+ if (!((InetSocketAddress)mcastaddr).getAddress().isMulticastAddress()) {
	382	+ throw new SocketException("Not a multicast address");
	383	+ }
	384	+
	385	+ getImpl().joinGroup(mcastaddr, netIf);
	386	+ }
	387	+
	388	+ /**
	389	+ * Leave a multicast group on a specified local interface.
	390	+ *
	391	+ * <p>If there is a security manager, this method first
	392	+ * calls its <code>checkMulticast</code> method
	393	+ * with the <code>mcastaddr</code> argument
	394	+ * as its argument.
	395	+ *
	396	+ * @param mcastaddr is the multicast address to leave
	397	+ * @param netIf specifies the local interface or <i>null</i> to defer
	398	+ * to the interface set by
	399	+ * {@link MulticastSocket#setInterface(InetAddress)} or
	400	+ * {@link MulticastSocket#setNetworkInterface(NetworkInterface)}
	401	+ * @exception IOException if there is an error leaving
	402	+ * or when the address is not a multicast address.
	403	+ * @exception SecurityException if a security manager exists and its
	404	+ * <code>checkMulticast</code> method doesn't allow the operation.
	405	+ * @throws IllegalArgumentException if mcastaddr is null or is a
	406	+ * SocketAddress subclass not supported by this socket
	407	+ *
	408	+ * @see SecurityManager#checkMulticast(InetAddress)
	409	+ * @since 1.4
	410	+ */
	411	+ public void leaveGroup(SocketAddress mcastaddr, NetworkInterface netIf)
	412	+ throws IOException {
	413	+ if (isClosed())
	414	+ throw new SocketException("Socket is closed");
	415	+
	416	+ if (mcastaddr == null \|\| !(mcastaddr instanceof InetSocketAddress))
	417	+ throw new IllegalArgumentException("Unsupported address type");
	418	+
	419	+ if (oldImpl)
	420	+ throw new UnsupportedOperationException();
	421	+
	422	+ checkAddress(((InetSocketAddress)mcastaddr).getAddress(), "leaveGroup");
	423	+ SecurityManager security = System.getSecurityManager();
	424	+ if (security != null) {
	425	+ security.checkMulticast(((InetSocketAddress)mcastaddr).getAddress());
	426	+ }
	427	+
	428	+ if (!((InetSocketAddress)mcastaddr).getAddress().isMulticastAddress()) {
	429	+ throw new SocketException("Not a multicast address");
	430	+ }
	431	+
	432	+ getImpl().leaveGroup(mcastaddr, netIf);
	433	+ }
	434	+
	435	+ /**
	436	+ * Set the multicast network interface used by methods
	437	+ * whose behavior would be affected by the value of the
	438	+ * network interface. Useful for multihomed hosts.
	439	+ * @param inf the InetAddress
	440	+ * @exception SocketException if there is an error in
	441	+ * the underlying protocol, such as a TCP error.
	442	+ * @see #getInterface()
	443	+ */
	444	+ public void setInterface(InetAddress inf) throws SocketException {
	445	+ if (isClosed()) {
	446	+ throw new SocketException("Socket is closed");
	447	+ }
	448	+ checkAddress(inf, "setInterface");
	449	+ synchronized (infLock) {
	450	+ getImpl().setOption(SocketOptions.IP_MULTICAST_IF, inf);
	451	+ infAddress = inf;
	452	+ }
	453	+ }
	454	+
	455	+ /**
	456	+ * Retrieve the address of the network interface used for
	457	+ * multicast packets.
	458	+ *
	459	+ * @return An <code>InetAddress</code> representing
	460	+ * the address of the network interface used for
	461	+ * multicast packets.
	462	+ *
	463	+ * @exception SocketException if there is an error in
	464	+ * the underlying protocol, such as a TCP error.
	465	+ *
	466	+ * @see #setInterface(java.net.InetAddress)
	467	+ */
	468	+ public InetAddress getInterface() throws SocketException {
	469	+ if (isClosed()) {
	470	+ throw new SocketException("Socket is closed");
	471	+ }
	472	+ synchronized (infLock) {
	473	+ InetAddress ia =
	474	+ (InetAddress)getImpl().getOption(SocketOptions.IP_MULTICAST_IF);
	475	+
	476	+ /**
	477	+ * No previous setInterface or interface can be
	478	+ * set using setNetworkInterface
	479	+ */
	480	+ if (infAddress == null) {
	481	+ return ia;
	482	+ }
	483	+
	484	+ /**
	485	+ * Same interface set with setInterface?
	486	+ */
	487	+ if (ia.equals(infAddress)) {
	488	+ return ia;
	489	+ }
	490	+
	491	+ /**
	492	+ * Different InetAddress from what we set with setInterface
	493	+ * so enumerate the current interface to see if the
	494	+ * address set by setInterface is bound to this interface.
	495	+ */
	496	+ try {
	497	+ NetworkInterface ni = NetworkInterface.getByInetAddress(ia);
	498	+ Enumeration addrs = ni.getInetAddresses();
	499	+ while (addrs.hasMoreElements()) {
	500	+ InetAddress addr = (InetAddress)(addrs.nextElement());
	501	+ if (addr.equals(infAddress)) {
	502	+ return infAddress;
	503	+ }
	504	+ }
	505	+
	506	+ /**
	507	+ * No match so reset infAddress to indicate that the
	508	+ * interface has changed via means
	509	+ */
	510	+ infAddress = null;
	511	+ return ia;
	512	+ } catch (Exception e) {
	513	+ return ia;
	514	+ }
	515	+ }
	516	+ }
	517	+
	518	+ /**
	519	+ * Specify the network interface for outgoing multicast datagrams
	520	+ * sent on this socket.
	521	+ *
	522	+ * @param netIf the interface
	523	+ * @exception SocketException if there is an error in
	524	+ * the underlying protocol, such as a TCP error.
	525	+ * @see #getNetworkInterface()
	526	+ * @since 1.4
	527	+ */
	528	+ public void setNetworkInterface(NetworkInterface netIf)
	529	+ throws SocketException {
	530	+
	531	+ synchronized (infLock) {
	532	+ getImpl().setOption(SocketOptions.IP_MULTICAST_IF2, netIf);
	533	+ infAddress = null;
	534	+ }
	535	+ }
	536	+
	537	+ /**
	538	+ * Get the multicast network interface set.
	539	+ *
	540	+ * @exception SocketException if there is an error in
	541	+ * the underlying protocol, such as a TCP error.
	542	+ * @return the multicast <code>NetworkInterface</code> currently set
	543	+ * @see #setNetworkInterface(NetworkInterface)
	544	+ * @since 1.4
	545	+ */
	546	+ public NetworkInterface getNetworkInterface() throws SocketException {
	547	+ NetworkInterface ni
	548	+ = (NetworkInterface)getImpl().getOption(SocketOptions.IP_MULTICAST_IF2);
	549	+ if (ni.getIndex() == 0) {
	550	+ InetAddress[] addrs = new InetAddress[1];
	551	+ addrs[0] = InetAddress.anyLocalAddress();
	552	+ return new NetworkInterface(addrs[0].getHostName(), 0, addrs);
	553	+ } else {
	554	+ return ni;
	555	+ }
	556	+ }
	557	+
	558	+ /**
	559	+ * Disable/Enable local loopback of multicast datagrams
	560	+ * The option is used by the platform's networking code as a hint
	561	+ * for setting whether multicast data will be looped back to
	562	+ * the local socket.
	563	+ *
	564	+ * <p>Because this option is a hint, applications that want to
	565	+ * verify what loopback mode is set to should call
	566	+ * {@link #getLoopbackMode()}
	567	+ * @param disable <code>true</code> to disable the LoopbackMode
	568	+ * @throws SocketException if an error occurs while setting the value
	569	+ * @since 1.4
	570	+ * @see #getLoopbackMode
	571	+ */
	572	+ public void setLoopbackMode(boolean disable) throws SocketException {
	573	+ getImpl().setOption(SocketOptions.IP_MULTICAST_LOOP, Boolean.valueOf(disable));
	574	+ }
	575	+
	576	+ /**
	577	+ * Get the setting for local loopback of multicast datagrams.
	578	+ *
	579	+ * @throws SocketException if an error occurs while getting the value
	580	+ * @return true if the LoopbackMode has been disabled
	581	+ * @since 1.4
	582	+ * @see #setLoopbackMode
	583	+ */
	584	+ public boolean getLoopbackMode() throws SocketException {
	585	+ return ((Boolean)getImpl().getOption(SocketOptions.IP_MULTICAST_LOOP)).booleanValue();
	586	+ }
	587	+
	588	+ /**
	589	+ * Sends a datagram packet to the destination, with a TTL (time-
	590	+ * to-live) other than the default for the socket. This method
	591	+ * need only be used in instances where a particular TTL is desired;
	592	+ * otherwise it is preferable to set a TTL once on the socket, and
	593	+ * use that default TTL for all packets. This method does <B>not
	594	+ * </B> alter the default TTL for the socket. Its behavior may be
	595	+ * affected by <code>setInterface</code>.
	596	+ *
	597	+ * <p>If there is a security manager, this method first performs some
	598	+ * security checks. First, if <code>p.getAddress().isMulticastAddress()</code>
	599	+ * is true, this method calls the
	600	+ * security manager's <code>checkMulticast</code> method
	601	+ * with <code>p.getAddress()</code> and <code>ttl</code> as its arguments.
	602	+ * If the evaluation of that expression is false,
	603	+ * this method instead calls the security manager's
	604	+ * <code>checkConnect</code> method with arguments
	605	+ * <code>p.getAddress().getHostAddress()</code> and
	606	+ * <code>p.getPort()</code>. Each call to a security manager method
	607	+ * could result in a SecurityException if the operation is not allowed.
	608	+ *
	609	+ * @param p is the packet to be sent. The packet should contain
	610	+ * the destination multicast ip address and the data to be sent.
	611	+ * One does not need to be the member of the group to send
	612	+ * packets to a destination multicast address.
	613	+ * @param ttl optional time to live for multicast packet.
	614	+ * default ttl is 1.
	615	+ *
	616	+ * @exception IOException is raised if an error occurs i.e
	617	+ * error while setting ttl.
	618	+ * @exception SecurityException if a security manager exists and its
	619	+ * <code>checkMulticast</code> or <code>checkConnect</code>
	620	+ * method doesn't allow the send.
	621	+ *
	622	+ * @deprecated Use the following code or its equivalent instead:
	623	+ * ......
	624	+ * int ttl = mcastSocket.getTimeToLive();
	625	+ * mcastSocket.setTimeToLive(newttl);
	626	+ * mcastSocket.send(p);
	627	+ * mcastSocket.setTimeToLive(ttl);
	628	+ * ......
	629	+ *
	630	+ * @see DatagramSocket#send
	631	+ * @see DatagramSocket#receive
	632	+ * @see SecurityManager#checkMulticast(java.net.InetAddress, byte)
	633	+ * @see SecurityManager#checkConnect
	634	+ */
	635	+ @Deprecated
	636	+ public void send(DatagramPacket p, byte ttl)
	637	+ throws IOException {
	638	+ if (isClosed())
	639	+ throw new SocketException("Socket is closed");
	640	+ checkAddress(p.getAddress(), "send");
	641	+ synchronized(ttlLock) {
	642	+ synchronized(p) {
	643	+ if (connectState == ST_NOT_CONNECTED) {
	644	+ // Security manager makes sure that the multicast address
	645	+ // is allowed one and that the ttl used is less
	646	+ // than the allowed maxttl.
	647	+ SecurityManager security = System.getSecurityManager();
	648	+ if (security != null) {
	649	+ if (p.getAddress().isMulticastAddress()) {
	650	+ security.checkMulticast(p.getAddress(), ttl);
	651	+ } else {
	652	+ security.checkConnect(p.getAddress().getHostAddress(),
	653	+ p.getPort());
	654	+ }
	655	+ }
	656	+ } else {
	657	+ // we're connected
	658	+ InetAddress packetAddress = null;
	659	+ packetAddress = p.getAddress();
	660	+ if (packetAddress == null) {
	661	+ p.setAddress(connectedAddress);
	662	+ p.setPort(connectedPort);
	663	+ } else if ((!packetAddress.equals(connectedAddress)) \|\|
	664	+ p.getPort() != connectedPort) {
	665	+ throw new SecurityException("connected address and packet address" +
	666	+ " differ");
	667	+ }
	668	+ }
	669	+ byte dttl = getTTL();
	670	+ try {
	671	+ if (ttl != dttl) {
	672	+ // set the ttl
	673	+ getImpl().setTTL(ttl);
	674	+ }
	675	+ // call the datagram method to send
	676	+ getImpl().send(p);
	677	+ } finally {
	678	+ // set it back to default
	679	+ if (ttl != dttl) {
	680	+ getImpl().setTTL(dttl);
	681	+ }
	682	+ }
	683	+ } // synch p
	684	+ } //synch ttl
	685	+ } //method
	686	+}

java/pkg/java/net/NetPermission.class+0−0

Binary file not shown.

java/pkg/java/net/NetPermission.java+205−0

@@ -0,0 +1,205 @@
	1	+/*
	2	+ * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.security.*;
	29	+import java.util.Enumeration;
	30	+import java.util.Hashtable;
	31	+import java.util.StringTokenizer;
	32	+
	33	+/**
	34	+ * This class is for various network permissions.
	35	+ * A NetPermission contains a name (also referred to as a "target name") but
	36	+ * no actions list; you either have the named permission
	37	+ * or you don't.
	38	+ * <P>
	39	+ * The target name is the name of the network permission (see below). The naming
	40	+ * convention follows the hierarchical property naming convention.
	41	+ * Also, an asterisk
	42	+ * may appear at the end of the name, following a ".", or by itself, to
	43	+ * signify a wildcard match. For example: "foo." or "" is valid,
	44	+ * "foo" or "ab" is not valid.
	45	+ * <P>
	46	+ * The following table lists all the possible NetPermission target names,
	47	+ * and for each provides a description of what the permission allows
	48	+ * and a discussion of the risks of granting code the permission.
	49	+ * <P>
	50	+ *
	51	+ * <table border=1 cellpadding=5 summary="Permission target name, what the permission allows, and associated risks">
	52	+ * <tr>
	53	+ * <th>Permission Target Name</th>
	54	+ * <th>What the Permission Allows</th>
	55	+ * <th>Risks of Allowing this Permission</th>
	56	+ * </tr>
	57	+ * <tr>
	58	+ * <td>allowHttpTrace</td>
	59	+ * <td>The ability to use the HTTP TRACE method in HttpURLConnection.</td>
	60	+ * <td>Malicious code using HTTP TRACE could get access to security sensitive
	61	+ * information in the HTTP headers (such as cookies) that it might not
	62	+ * otherwise have access to.</td>
	63	+ * </tr>
	64	+ *
	65	+ * <tr>
	66	+ * <td>getCookieHandler</td>
	67	+ * <td>The ability to get the cookie handler that processes highly
	68	+ * security sensitive cookie information for an Http session.</td>
	69	+ * <td>Malicious code can get a cookie handler to obtain access to
	70	+ * highly security sensitive cookie information. Some web servers
	71	+ * use cookies to save user private information such as access
	72	+ * control information, or to track user browsing habit.</td>
	73	+ * </tr>
	74	+ *
	75	+ * <tr>
	76	+ * <td>getNetworkInformation</td>
	77	+ * <td>The ability to retrieve all information about local network interfaces.</td>
	78	+ * <td>Malicious code can read information about network hardware such as
	79	+ * MAC addresses, which could be used to construct local IPv6 addresses.</td>
	80	+ * </tr>
	81	+ *
	82	+ * <tr>
	83	+ * <td>getProxySelector</td>
	84	+ * <td>The ability to get the proxy selector used to make decisions
	85	+ * on which proxies to use when making network connections.</td>
	86	+ * <td>Malicious code can get a ProxySelector to discover proxy
	87	+ * hosts and ports on internal networks, which could then become
	88	+ * targets for attack.</td>
	89	+ * </tr>
	90	+ *
	91	+ * <tr>
	92	+ * <td>getResponseCache</td>
	93	+ * <td>The ability to get the response cache that provides
	94	+ * access to a local response cache.</td>
	95	+ * <td>Malicious code getting access to the local response cache
	96	+ * could access security sensitive information.</td>
	97	+ * </tr>
	98	+ *
	99	+ * <tr>
	100	+ * <td>requestPasswordAuthentication</td>
	101	+ * <td>The ability
	102	+ * to ask the authenticator registered with the system for
	103	+ * a password</td>
	104	+ * <td>Malicious code may steal this password.</td>
	105	+ * </tr>
	106	+ *
	107	+ * <tr>
	108	+ * <td>setCookieHandler</td>
	109	+ * <td>The ability to set the cookie handler that processes highly
	110	+ * security sensitive cookie information for an Http session.</td>
	111	+ * <td>Malicious code can set a cookie handler to obtain access to
	112	+ * highly security sensitive cookie information. Some web servers
	113	+ * use cookies to save user private information such as access
	114	+ * control information, or to track user browsing habit.</td>
	115	+ * </tr>
	116	+ *
	117	+ * <tr>
	118	+ * <td>setDefaultAuthenticator</td>
	119	+ * <td>The ability to set the
	120	+ * way authentication information is retrieved when
	121	+ * a proxy or HTTP server asks for authentication</td>
	122	+ * <td>Malicious
	123	+ * code can set an authenticator that monitors and steals user
	124	+ * authentication input as it retrieves the input from the user.</td>
	125	+ * </tr>
	126	+ *
	127	+ * <tr>
	128	+ * <td>setProxySelector</td>
	129	+ * <td>The ability to set the proxy selector used to make decisions
	130	+ * on which proxies to use when making network connections.</td>
	131	+ * <td>Malicious code can set a ProxySelector that directs network
	132	+ * traffic to an arbitrary network host.</td>
	133	+ * </tr>
	134	+ *
	135	+ * <tr>
	136	+ * <td>setResponseCache</td>
	137	+ * <td>The ability to set the response cache that provides access to
	138	+ * a local response cache.</td>
	139	+ * <td>Malicious code getting access to the local response cache
	140	+ * could access security sensitive information, or create false
	141	+ * entries in the response cache.</td>
	142	+ * </tr>
	143	+ *
	144	+ * <tr>
	145	+ * <td>specifyStreamHandler</td>
	146	+ * <td>The ability
	147	+ * to specify a stream handler when constructing a URL</td>
	148	+ * <td>Malicious code may create a URL with resources that it would
	149	+normally not have access to (like file:/foo/fum/), specifying a
	150	+stream handler that gets the actual bytes from someplace it does
	151	+have access to. Thus it might be able to trick the system into
	152	+creating a ProtectionDomain/CodeSource for a class even though
	153	+that class really didn't come from that location.</td>
	154	+ * </tr>
	155	+ * </table>
	156	+ *
	157	+ * @see java.security.BasicPermission
	158	+ * @see java.security.Permission
	159	+ * @see java.security.Permissions
	160	+ * @see java.security.PermissionCollection
	161	+ * @see java.lang.SecurityManager
	162	+ *
	163	+ *
	164	+ * @author Marianne Mueller
	165	+ * @author Roland Schemers
	166	+ */
	167	+
	168	+public final class NetPermission extends BasicPermission {
	169	+ private static final long serialVersionUID = -8343910153355041693L;
	170	+
	171	+ /**
	172	+ * Creates a new NetPermission with the specified name.
	173	+ * The name is the symbolic name of the NetPermission, such as
	174	+ * "setDefaultAuthenticator", etc. An asterisk
	175	+ * may appear at the end of the name, following a ".", or by itself, to
	176	+ * signify a wildcard match.
	177	+ *
	178	+ * @param name the name of the NetPermission.
	179	+ *
	180	+ * @throws NullPointerException if <code>name</code> is <code>null</code>.
	181	+ * @throws IllegalArgumentException if <code>name</code> is empty.
	182	+ */
	183	+
	184	+ public NetPermission(String name)
	185	+ {
	186	+ super(name);
	187	+ }
	188	+
	189	+ /**
	190	+ * Creates a new NetPermission object with the specified name.
	191	+ * The name is the symbolic name of the NetPermission, and the
	192	+ * actions String is currently unused and should be null.
	193	+ *
	194	+ * @param name the name of the NetPermission.
	195	+ * @param actions should be null.
	196	+ *
	197	+ * @throws NullPointerException if <code>name</code> is <code>null</code>.
	198	+ * @throws IllegalArgumentException if <code>name</code> is empty.
	199	+ */
	200	+
	201	+ public NetPermission(String name, String actions)
	202	+ {
	203	+ super(name, actions);
	204	+ }
	205	+}

java/pkg/java/net/NetworkInterface$1.class+0−0

Binary file not shown.

java/pkg/java/net/NetworkInterface$1checkedAddresses.class+0−0

Binary file not shown.

java/pkg/java/net/NetworkInterface$1subIFs.class+0−0

Binary file not shown.

java/pkg/java/net/NetworkInterface.class+0−0

Binary file not shown.

java/pkg/java/net/NetworkInterface.java+554−0

@@ -0,0 +1,554 @@
	1	+/*
	2	+ * Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.util.Enumeration;
	29	+import java.util.NoSuchElementException;
	30	+import sun.security.action.*;
	31	+import java.security.AccessController;
	32	+
	33	+/**
	34	+ * This class represents a Network Interface made up of a name,
	35	+ * and a list of IP addresses assigned to this interface.
	36	+ * It is used to identify the local interface on which a multicast group
	37	+ * is joined.
	38	+ *
	39	+ * Interfaces are normally known by names such as "le0".
	40	+ *
	41	+ * @since 1.4
	42	+ */
	43	+public final class NetworkInterface {
	44	+ private String name;
	45	+ private String displayName;
	46	+ private int index;
	47	+ private InetAddress addrs[];
	48	+ private InterfaceAddress bindings[];
	49	+ private NetworkInterface childs[];
	50	+ private NetworkInterface parent = null;
	51	+ private boolean virtual = false;
	52	+
	53	+ static {
	54	+ AccessController.doPrivileged(new LoadLibraryAction("net"));
	55	+ init();
	56	+ }
	57	+
	58	+ /**
	59	+ * Returns an NetworkInterface object with index set to 0 and name to null.
	60	+ * Setting such an interface on a MulticastSocket will cause the
	61	+ * kernel to choose one interface for sending multicast packets.
	62	+ *
	63	+ */
	64	+ NetworkInterface() {
	65	+ }
	66	+
	67	+ NetworkInterface(String name, int index, InetAddress[] addrs) {
	68	+ this.name = name;
	69	+ this.index = index;
	70	+ this.addrs = addrs;
	71	+ }
	72	+
	73	+ /**
	74	+ * Get the name of this network interface.
	75	+ *
	76	+ * @return the name of this network interface
	77	+ */
	78	+ public String getName() {
	79	+ return name;
	80	+ }
	81	+
	82	+ /**
	83	+ * Convenience method to return an Enumeration with all or a
	84	+ * subset of the InetAddresses bound to this network interface.
	85	+ * <p>
	86	+ * If there is a security manager, its <code>checkConnect</code>
	87	+ * method is called for each InetAddress. Only InetAddresses where
	88	+ * the <code>checkConnect</code> doesn't throw a SecurityException
	89	+ * will be returned in the Enumeration. However, if the caller has the
	90	+ * {@link NetPermission}("getNetworkInformation") permission, then all
	91	+ * InetAddresses are returned.
	92	+ * @return an Enumeration object with all or a subset of the InetAddresses
	93	+ * bound to this network interface
	94	+ */
	95	+ public Enumeration<InetAddress> getInetAddresses() {
	96	+
	97	+ class checkedAddresses implements Enumeration<InetAddress> {
	98	+
	99	+ private int i=0, count=0;
	100	+ private InetAddress local_addrs[];
	101	+
	102	+ checkedAddresses() {
	103	+ local_addrs = new InetAddress[addrs.length];
	104	+ boolean trusted = true;
	105	+
	106	+ SecurityManager sec = System.getSecurityManager();
	107	+ if (sec != null) {
	108	+ try {
	109	+ sec.checkPermission(new NetPermission("getNetworkInformation"));
	110	+ } catch (SecurityException e) {
	111	+ trusted = false;
	112	+ }
	113	+ }
	114	+ for (int j=0; j<addrs.length; j++) {
	115	+ try {
	116	+ if (sec != null && !trusted) {
	117	+ sec.checkConnect(addrs[j].getHostAddress(), -1);
	118	+ }
	119	+ local_addrs[count++] = addrs[j];
	120	+ } catch (SecurityException e) { }
	121	+ }
	122	+
	123	+ }
	124	+
	125	+ public InetAddress nextElement() {
	126	+ if (i < count) {
	127	+ return local_addrs[i++];
	128	+ } else {
	129	+ throw new NoSuchElementException();
	130	+ }
	131	+ }
	132	+
	133	+ public boolean hasMoreElements() {
	134	+ return (i < count);
	135	+ }
	136	+ }
	137	+ return new checkedAddresses();
	138	+
	139	+ }
	140	+
	141	+ /**
	142	+ * Get a List of all or a subset of the <code>InterfaceAddresses</code>
	143	+ * of this network interface.
	144	+ * <p>
	145	+ * If there is a security manager, its <code>checkConnect</code>
	146	+ * method is called with the InetAddress for each InterfaceAddress.
	147	+ * Only InterfaceAddresses where the <code>checkConnect</code> doesn't throw
	148	+ * a SecurityException will be returned in the List.
	149	+ *
	150	+ * @return a <code>List</code> object with all or a subset of the
	151	+ * InterfaceAddresss of this network interface
	152	+ * @since 1.6
	153	+ */
	154	+ public java.util.List<InterfaceAddress> getInterfaceAddresses() {
	155	+ java.util.List<InterfaceAddress> lst = new java.util.ArrayList<InterfaceAddress>(1);
	156	+ SecurityManager sec = System.getSecurityManager();
	157	+ for (int j=0; j<bindings.length; j++) {
	158	+ try {
	159	+ if (sec != null) {
	160	+ sec.checkConnect(bindings[j].getAddress().getHostAddress(), -1);
	161	+ }
	162	+ lst.add(bindings[j]);
	163	+ } catch (SecurityException e) { }
	164	+ }
	165	+ return lst;
	166	+ }
	167	+
	168	+ /**
	169	+ * Get an Enumeration with all the subinterfaces (also known as virtual
	170	+ * interfaces) attached to this network interface.
	171	+ * <p>
	172	+ * For instance eth0:1 will be a subinterface to eth0.
	173	+ *
	174	+ * @return an Enumeration object with all of the subinterfaces
	175	+ * of this network interface
	176	+ * @since 1.6
	177	+ */
	178	+ public Enumeration<NetworkInterface> getSubInterfaces() {
	179	+ class subIFs implements Enumeration<NetworkInterface> {
	180	+
	181	+ private int i=0;
	182	+
	183	+ subIFs() {
	184	+ }
	185	+
	186	+ public NetworkInterface nextElement() {
	187	+ if (i < childs.length) {
	188	+ return childs[i++];
	189	+ } else {
	190	+ throw new NoSuchElementException();
	191	+ }
	192	+ }
	193	+
	194	+ public boolean hasMoreElements() {
	195	+ return (i < childs.length);
	196	+ }
	197	+ }
	198	+ return new subIFs();
	199	+
	200	+ }
	201	+
	202	+ /**
	203	+ * Returns the parent NetworkInterface of this interface if this is
	204	+ * a subinterface, or <code>null</code> if it is a physical
	205	+ * (non virtual) interface or has no parent.
	206	+ *
	207	+ * @return The <code>NetworkInterface</code> this interface is attached to.
	208	+ * @since 1.6
	209	+ */
	210	+ public NetworkInterface getParent() {
	211	+ return parent;
	212	+ }
	213	+
	214	+ /**
	215	+ * Returns the index of this network interface. The index is an integer greater
	216	+ * or equal to zero, or {@code -1} for unknown. This is a system specific value
	217	+ * and interfaces with the same name can have different indexes on different
	218	+ * machines.
	219	+ *
	220	+ * @return the index of this network interface or {@code -1} if the index is
	221	+ * unknown
	222	+ * @see #getByIndex(int)
	223	+ * @since 1.7
	224	+ */
	225	+ public int getIndex() {
	226	+ return index;
	227	+ }
	228	+
	229	+ /**
	230	+ * Get the display name of this network interface.
	231	+ * A display name is a human readable String describing the network
	232	+ * device.
	233	+ *
	234	+ * @return a non-empty string representing the display name of this network
	235	+ * interface, or null if no display name is available.
	236	+ */
	237	+ public String getDisplayName() {
	238	+ /* strict TCK conformance */
	239	+ return "".equals(displayName) ? null : displayName;
	240	+ }
	241	+
	242	+ /**
	243	+ * Searches for the network interface with the specified name.
	244	+ *
	245	+ * @param name
	246	+ * The name of the network interface.
	247	+ *
	248	+ * @return A <tt>NetworkInterface</tt> with the specified name,
	249	+ * or <tt>null</tt> if there is no network interface
	250	+ * with the specified name.
	251	+ *
	252	+ * @throws SocketException
	253	+ * If an I/O error occurs.
	254	+ *
	255	+ * @throws NullPointerException
	256	+ * If the specified name is <tt>null</tt>.
	257	+ */
	258	+ public static NetworkInterface getByName(String name) throws SocketException {
	259	+ if (name == null)
	260	+ throw new NullPointerException();
	261	+ return getByName0(name);
	262	+ }
	263	+
	264	+ /**
	265	+ * Get a network interface given its index.
	266	+ *
	267	+ * @param index an integer, the index of the interface
	268	+ * @return the NetworkInterface obtained from its index, or {@code null} if
	269	+ * there is no interface with such an index on the system
	270	+ * @throws SocketException if an I/O error occurs.
	271	+ * @throws IllegalArgumentException if index has a negative value
	272	+ * @see #getIndex()
	273	+ * @since 1.7
	274	+ */
	275	+ public static NetworkInterface getByIndex(int index) throws SocketException {
	276	+ if (index < 0)
	277	+ throw new IllegalArgumentException("Interface index can't be negative");
	278	+ return getByIndex0(index);
	279	+ }
	280	+
	281	+ /**
	282	+ * Convenience method to search for a network interface that
	283	+ * has the specified Internet Protocol (IP) address bound to
	284	+ * it.
	285	+ * <p>
	286	+ * If the specified IP address is bound to multiple network
	287	+ * interfaces it is not defined which network interface is
	288	+ * returned.
	289	+ *
	290	+ * @param addr
	291	+ * The <tt>InetAddress</tt> to search with.
	292	+ *
	293	+ * @return A <tt>NetworkInterface</tt>
	294	+ * or <tt>null</tt> if there is no network interface
	295	+ * with the specified IP address.
	296	+ *
	297	+ * @throws SocketException
	298	+ * If an I/O error occurs.
	299	+ *
	300	+ * @throws NullPointerException
	301	+ * If the specified address is <tt>null</tt>.
	302	+ */
	303	+ public static NetworkInterface getByInetAddress(InetAddress addr) throws SocketException {
	304	+ if (addr == null) {
	305	+ throw new NullPointerException();
	306	+ }
	307	+ if (!(addr instanceof Inet4Address \|\| addr instanceof Inet6Address)) {
	308	+ throw new IllegalArgumentException ("invalid address type");
	309	+ }
	310	+ return getByInetAddress0(addr);
	311	+ }
	312	+
	313	+ /**
	314	+ * Returns all the interfaces on this machine. Returns null if no
	315	+ * network interfaces could be found on this machine.
	316	+ *
	317	+ * NOTE: can use getNetworkInterfaces()+getInetAddresses()
	318	+ * to obtain all IP addresses for this node
	319	+ *
	320	+ * @return an Enumeration of NetworkInterfaces found on this machine
	321	+ * @exception SocketException if an I/O error occurs.
	322	+ */
	323	+
	324	+ public static Enumeration<NetworkInterface> getNetworkInterfaces()
	325	+ throws SocketException {
	326	+ final NetworkInterface[] netifs = getAll();
	327	+
	328	+ // specified to return null if no network interfaces
	329	+ if (netifs == null)
	330	+ return null;
	331	+
	332	+ return new Enumeration<NetworkInterface>() {
	333	+ private int i = 0;
	334	+ public NetworkInterface nextElement() {
	335	+ if (netifs != null && i < netifs.length) {
	336	+ NetworkInterface netif = netifs[i++];
	337	+ return netif;
	338	+ } else {
	339	+ throw new NoSuchElementException();
	340	+ }
	341	+ }
	342	+
	343	+ public boolean hasMoreElements() {
	344	+ return (netifs != null && i < netifs.length);
	345	+ }
	346	+ };
	347	+ }
	348	+
	349	+ private native static NetworkInterface[] getAll()
	350	+ throws SocketException;
	351	+
	352	+ private native static NetworkInterface getByName0(String name)
	353	+ throws SocketException;
	354	+
	355	+ private native static NetworkInterface getByIndex0(int index)
	356	+ throws SocketException;
	357	+
	358	+ private native static NetworkInterface getByInetAddress0(InetAddress addr)
	359	+ throws SocketException;
	360	+
	361	+ /**
	362	+ * Returns whether a network interface is up and running.
	363	+ *
	364	+ * @return <code>true</code> if the interface is up and running.
	365	+ * @exception SocketException if an I/O error occurs.
	366	+ * @since 1.6
	367	+ */
	368	+
	369	+ public boolean isUp() throws SocketException {
	370	+ return isUp0(name, index);
	371	+ }
	372	+
	373	+ /**
	374	+ * Returns whether a network interface is a loopback interface.
	375	+ *
	376	+ * @return <code>true</code> if the interface is a loopback interface.
	377	+ * @exception SocketException if an I/O error occurs.
	378	+ * @since 1.6
	379	+ */
	380	+
	381	+ public boolean isLoopback() throws SocketException {
	382	+ return isLoopback0(name, index);
	383	+ }
	384	+
	385	+ /**
	386	+ * Returns whether a network interface is a point to point interface.
	387	+ * A typical point to point interface would be a PPP connection through
	388	+ * a modem.
	389	+ *
	390	+ * @return <code>true</code> if the interface is a point to point
	391	+ * interface.
	392	+ * @exception SocketException if an I/O error occurs.
	393	+ * @since 1.6
	394	+ */
	395	+
	396	+ public boolean isPointToPoint() throws SocketException {
	397	+ return isP2P0(name, index);
	398	+ }
	399	+
	400	+ /**
	401	+ * Returns whether a network interface supports multicasting or not.
	402	+ *
	403	+ * @return <code>true</code> if the interface supports Multicasting.
	404	+ * @exception SocketException if an I/O error occurs.
	405	+ * @since 1.6
	406	+ */
	407	+
	408	+ public boolean supportsMulticast() throws SocketException {
	409	+ return supportsMulticast0(name, index);
	410	+ }
	411	+
	412	+ /**
	413	+ * Returns the hardware address (usually MAC) of the interface if it
	414	+ * has one and if it can be accessed given the current privileges.
	415	+ * If a security manager is set, then the caller must have
	416	+ * the permission {@link NetPermission}("getNetworkInformation").
	417	+ *
	418	+ * @return a byte array containing the address, or <code>null</code> if
	419	+ * the address doesn't exist, is not accessible or a security
	420	+ * manager is set and the caller does not have the permission
	421	+ * NetPermission("getNetworkInformation")
	422	+ *
	423	+ * @exception SocketException if an I/O error occurs.
	424	+ * @since 1.6
	425	+ */
	426	+ public byte[] getHardwareAddress() throws SocketException {
	427	+ SecurityManager sec = System.getSecurityManager();
	428	+ if (sec != null) {
	429	+ try {
	430	+ sec.checkPermission(new NetPermission("getNetworkInformation"));
	431	+ } catch (SecurityException e) {
	432	+ if (!getInetAddresses().hasMoreElements()) {
	433	+ // don't have connect permission to any local address
	434	+ return null;
	435	+ }
	436	+ }
	437	+ }
	438	+ for (InetAddress addr : addrs) {
	439	+ if (addr instanceof Inet4Address) {
	440	+ return getMacAddr0(((Inet4Address)addr).getAddress(), name, index);
	441	+ }
	442	+ }
	443	+ return getMacAddr0(null, name, index);
	444	+ }
	445	+
	446	+ /**
	447	+ * Returns the Maximum Transmission Unit (MTU) of this interface.
	448	+ *
	449	+ * @return the value of the MTU for that interface.
	450	+ * @exception SocketException if an I/O error occurs.
	451	+ * @since 1.6
	452	+ */
	453	+ public int getMTU() throws SocketException {
	454	+ return getMTU0(name, index);
	455	+ }
	456	+
	457	+ /**
	458	+ * Returns whether this interface is a virtual interface (also called
	459	+ * subinterface).
	460	+ * Virtual interfaces are, on some systems, interfaces created as a child
	461	+ * of a physical interface and given different settings (like address or
	462	+ * MTU). Usually the name of the interface will the name of the parent
	463	+ * followed by a colon (:) and a number identifying the child since there
	464	+ * can be several virtual interfaces attached to a single physical
	465	+ * interface.
	466	+ *
	467	+ * @return <code>true</code> if this interface is a virtual interface.
	468	+ * @since 1.6
	469	+ */
	470	+ public boolean isVirtual() {
	471	+ return virtual;
	472	+ }
	473	+
	474	+ private native static boolean isUp0(String name, int ind) throws SocketException;
	475	+ private native static boolean isLoopback0(String name, int ind) throws SocketException;
	476	+ private native static boolean supportsMulticast0(String name, int ind) throws SocketException;
	477	+ private native static boolean isP2P0(String name, int ind) throws SocketException;
	478	+ private native static byte[] getMacAddr0(byte[] inAddr, String name, int ind) throws SocketException;
	479	+ private native static int getMTU0(String name, int ind) throws SocketException;
	480	+
	481	+ /**
	482	+ * Compares this object against the specified object.
	483	+ * The result is <code>true</code> if and only if the argument is
	484	+ * not <code>null</code> and it represents the same NetworkInterface
	485	+ * as this object.
	486	+ * <p>
	487	+ * Two instances of <code>NetworkInterface</code> represent the same
	488	+ * NetworkInterface if both name and addrs are the same for both.
	489	+ *
	490	+ * @param obj the object to compare against.
	491	+ * @return <code>true</code> if the objects are the same;
	492	+ * <code>false</code> otherwise.
	493	+ * @see java.net.InetAddress#getAddress()
	494	+ */
	495	+ public boolean equals(Object obj) {
	496	+ if (!(obj instanceof NetworkInterface)) {
	497	+ return false;
	498	+ }
	499	+ NetworkInterface that = (NetworkInterface)obj;
	500	+ if (this.name != null ) {
	501	+ if (!this.name.equals(that.name)) {
	502	+ return false;
	503	+ }
	504	+ } else {
	505	+ if (that.name != null) {
	506	+ return false;
	507	+ }
	508	+ }
	509	+
	510	+ if (this.addrs == null) {
	511	+ return that.addrs == null;
	512	+ } else if (that.addrs == null) {
	513	+ return false;
	514	+ }
	515	+
	516	+ /* Both addrs not null. Compare number of addresses */
	517	+
	518	+ if (this.addrs.length != that.addrs.length) {
	519	+ return false;
	520	+ }
	521	+
	522	+ InetAddress[] thatAddrs = that.addrs;
	523	+ int count = thatAddrs.length;
	524	+
	525	+ for (int i=0; i<count; i++) {
	526	+ boolean found = false;
	527	+ for (int j=0; j<count; j++) {
	528	+ if (addrs[i].equals(thatAddrs[j])) {
	529	+ found = true;
	530	+ break;
	531	+ }
	532	+ }
	533	+ if (!found) {
	534	+ return false;
	535	+ }
	536	+ }
	537	+ return true;
	538	+ }
	539	+
	540	+ public int hashCode() {
	541	+ return name == null? 0: name.hashCode();
	542	+ }
	543	+
	544	+ public String toString() {
	545	+ String result = "name:";
	546	+ result += name == null? "null": name;
	547	+ if (displayName != null) {
	548	+ result += " (" + displayName + ")";
	549	+ }
	550	+ return result;
	551	+ }
	552	+
	553	+ private static native void init();
	554	+}

java/pkg/java/net/NoRouteToHostException.class+0−0

Binary file not shown.

java/pkg/java/net/NoRouteToHostException.java+54−0

@@ -0,0 +1,54 @@
	1	+/*
	2	+ * Copyright (c) 1996, 2008, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+/**
	29	+ * Signals that an error occurred while attempting to connect a
	30	+ * socket to a remote address and port. Typically, the remote
	31	+ * host cannot be reached because of an intervening firewall, or
	32	+ * if an intermediate router is down.
	33	+ *
	34	+ * @since JDK1.1
	35	+ */
	36	+public class NoRouteToHostException extends SocketException {
	37	+ private static final long serialVersionUID = -1897550894873493790L;
	38	+
	39	+ /**
	40	+ * Constructs a new NoRouteToHostException with the specified detail
	41	+ * message as to why the remote host cannot be reached.
	42	+ * A detail message is a String that gives a specific
	43	+ * description of this error.
	44	+ * @param msg the detail message
	45	+ */
	46	+ public NoRouteToHostException(String msg) {
	47	+ super(msg);
	48	+ }
	49	+
	50	+ /**
	51	+ * Construct a new NoRouteToHostException with no detailed message.
	52	+ */
	53	+ public NoRouteToHostException() {}
	54	+}

java/pkg/java/net/Parts.class+0−0

Binary file not shown.

java/pkg/java/net/PasswordAuthentication.class+0−0

Binary file not shown.

java/pkg/java/net/PasswordAuthentication.java+81−0

@@ -0,0 +1,81 @@
	1	+/*
	2	+ * Copyright (c) 1997, 2001, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+
	29	+/**
	30	+ * The class PasswordAuthentication is a data holder that is used by
	31	+ * Authenticator. It is simply a repository for a user name and a password.
	32	+ *
	33	+ * @see java.net.Authenticator
	34	+ * @see java.net.Authenticator#getPasswordAuthentication()
	35	+ *
	36	+ * @author Bill Foote
	37	+ * @since 1.2
	38	+ */
	39	+
	40	+public final class PasswordAuthentication {
	41	+
	42	+ private String userName;
	43	+ private char[] password;
	44	+
	45	+ /**
	46	+ * Creates a new <code>PasswordAuthentication</code> object from the given
	47	+ * user name and password.
	48	+ *
	49	+ * <p> Note that the given user password is cloned before it is stored in
	50	+ * the new <code>PasswordAuthentication</code> object.
	51	+ *
	52	+ * @param userName the user name
	53	+ * @param password the user's password
	54	+ */
	55	+ public PasswordAuthentication(String userName, char[] password) {
	56	+ this.userName = userName;
	57	+ this.password = password.clone();
	58	+ }
	59	+
	60	+ /**
	61	+ * Returns the user name.
	62	+ *
	63	+ * @return the user name
	64	+ */
	65	+ public String getUserName() {
	66	+ return userName;
	67	+ }
	68	+
	69	+ /**
	70	+ * Returns the user password.
	71	+ *
	72	+ * <p> Note that this method returns a reference to the password. It is
	73	+ * the caller's responsibility to zero out the password information after
	74	+ * it is no longer needed.
	75	+ *
	76	+ * @return the password
	77	+ */
	78	+ public char[] getPassword() {
	79	+ return password;
	80	+ }
	81	+}

java/pkg/java/net/PortUnreachableException.class+0−0

Binary file not shown.

java/pkg/java/net/PortUnreachableException.java+52−0

@@ -0,0 +1,52 @@
	1	+/*
	2	+ * Copyright (c) 2001, 2008, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+/**
	29	+ * Signals that an ICMP Port Unreachable message has been
	30	+ * received on a connected datagram.
	31	+ *
	32	+ * @since 1.4
	33	+ */
	34	+
	35	+public class PortUnreachableException extends SocketException {
	36	+ private static final long serialVersionUID = 8462541992376507323L;
	37	+
	38	+ /**
	39	+ * Constructs a new <code>PortUnreachableException</code> with a
	40	+ * detail message.
	41	+ * @param msg the detail message
	42	+ */
	43	+ public PortUnreachableException(String msg) {
	44	+ super(msg);
	45	+ }
	46	+
	47	+ /**
	48	+ * Construct a new <code>PortUnreachableException</code> with no
	49	+ * detailed message.
	50	+ */
	51	+ public PortUnreachableException() {}
	52	+}

java/pkg/java/net/ProtocolException.class+0−0

Binary file not shown.

java/pkg/java/net/ProtocolException.java+56−0

@@ -0,0 +1,56 @@
	1	+/*
	2	+ * Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.io.IOException;
	29	+
	30	+/**
	31	+ * Thrown to indicate that there is an error in the underlying
	32	+ * protocol, such as a TCP error.
	33	+ *
	34	+ * @author Chris Warth
	35	+ * @since JDK1.0
	36	+ */
	37	+public
	38	+class ProtocolException extends IOException {
	39	+ private static final long serialVersionUID = -6098449442062388080L;
	40	+
	41	+ /**
	42	+ * Constructs a new <code>ProtocolException</code> with the
	43	+ * specified detail message.
	44	+ *
	45	+ * @param host the detail message.
	46	+ */
	47	+ public ProtocolException(String host) {
	48	+ super(host);
	49	+ }
	50	+
	51	+ /**
	52	+ * Constructs a new <code>ProtocolException</code> with no detail message.
	53	+ */
	54	+ public ProtocolException() {
	55	+ }
	56	+}

java/pkg/java/net/ProtocolFamily.class+0−0

Binary file not shown.

java/pkg/java/net/ProtocolFamily.java+39−0

@@ -0,0 +1,39 @@
	1	+/*
	2	+ * Copyright (c) 2007, 2008, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+/**
	29	+ * Represents a family of communication protocols.
	30	+ *
	31	+ * @since 1.7
	32	+ */
	33	+
	34	+public interface ProtocolFamily {
	35	+ /**
	36	+ * Returns the name of the protocol family.
	37	+ */
	38	+ String name();
	39	+}

java/pkg/java/net/Proxy$Type.class+0−0

Binary file not shown.

java/pkg/java/net/Proxy.class+0−0

Binary file not shown.

java/pkg/java/net/Proxy.java+171−0

@@ -0,0 +1,171 @@
	1	+/*
	2	+ * Copyright (c) 2003, 2005, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+/**
	29	+ * This class represents a proxy setting, typically a type (http, socks) and
	30	+ * a socket address.
	31	+ * A <code>Proxy</code> is an immutable object.
	32	+ *
	33	+ * @see java.net.ProxySelector
	34	+ * @author Yingxian Wang
	35	+ * @author Jean-Christophe Collet
	36	+ * @since 1.5
	37	+ */
	38	+public class Proxy {
	39	+
	40	+ /**
	41	+ * Represents the proxy type.
	42	+ *
	43	+ * @since 1.5
	44	+ */
	45	+ public enum Type {
	46	+ /**
	47	+ * Represents a direct connection, or the absence of a proxy.
	48	+ */
	49	+ DIRECT,
	50	+ /**
	51	+ * Represents proxy for high level protocols such as HTTP or FTP.
	52	+ */
	53	+ HTTP,
	54	+ /**
	55	+ * Represents a SOCKS (V4 or V5) proxy.
	56	+ */
	57	+ SOCKS
	58	+ };
	59	+
	60	+ private Type type;
	61	+ private SocketAddress sa;
	62	+
	63	+ /**
	64	+ * A proxy setting that represents a <code>DIRECT</code> connection,
	65	+ * basically telling the protocol handler not to use any proxying.
	66	+ * Used, for instance, to create sockets bypassing any other global
	67	+ * proxy settings (like SOCKS):
	68	+ * <P>
	69	+ * <code>Socket s = new Socket(Proxy.NO_PROXY);</code><br>
	70	+ * <P>
	71	+ */
	72	+ public final static Proxy NO_PROXY = new Proxy();
	73	+
	74	+ // Creates the proxy that represents a <code>DIRECT</code> connection.
	75	+ private Proxy() {
	76	+ type = type.DIRECT;
	77	+ sa = null;
	78	+ }
	79	+
	80	+ /**
	81	+ * Creates an entry representing a PROXY connection.
	82	+ * Certain combinations are illegal. For instance, for types Http, and
	83	+ * Socks, a SocketAddress <b>must</b> be provided.
	84	+ * <P>
	85	+ * Use the <code>Proxy.NO_PROXY</code> constant
	86	+ * for representing a direct connection.
	87	+ *
	88	+ * @param type the <code>Type</code> of the proxy
	89	+ * @param sa the <code>SocketAddress</code> for that proxy
	90	+ * @throws IllegalArgumentException when the type and the address are
	91	+ * incompatible
	92	+ */
	93	+ public Proxy(Type type, SocketAddress sa) {
	94	+ if ((type == Type.DIRECT) \|\| !(sa instanceof InetSocketAddress))
	95	+ throw new IllegalArgumentException("type " + type + " is not compatible with address " + sa);
	96	+ this.type = type;
	97	+ this.sa = sa;
	98	+ }
	99	+
	100	+ /**
	101	+ * Returns the proxy type.
	102	+ *
	103	+ * @return a Type representing the proxy type
	104	+ */
	105	+ public Type type() {
	106	+ return type;
	107	+ }
	108	+
	109	+ /**
	110	+ * Returns the socket address of the proxy, or
	111	+ * <code>null</code> if its a direct connection.
	112	+ *
	113	+ * @return a <code>SocketAddress</code> representing the socket end
	114	+ * point of the proxy
	115	+ */
	116	+ public SocketAddress address() {
	117	+ return sa;
	118	+ }
	119	+
	120	+ /**
	121	+ * Constructs a string representation of this Proxy.
	122	+ * This String is constructed by calling toString() on its type
	123	+ * and concatenating " @ " and the toString() result from its address
	124	+ * if its type is not <code>DIRECT</code>.
	125	+ *
	126	+ * @return a string representation of this object.
	127	+ */
	128	+ public String toString() {
	129	+ if (type() == Type.DIRECT)
	130	+ return "DIRECT";
	131	+ return type() + " @ " + address();
	132	+ }
	133	+
	134	+ /**
	135	+ * Compares this object against the specified object.
	136	+ * The result is <code>true</code> if and only if the argument is
	137	+ * not <code>null</code> and it represents the same proxy as
	138	+ * this object.
	139	+ * <p>
	140	+ * Two instances of <code>Proxy</code> represent the same
	141	+ * address if both the SocketAddresses and type are equal.
	142	+ *
	143	+ * @param obj the object to compare against.
	144	+ * @return <code>true</code> if the objects are the same;
	145	+ * <code>false</code> otherwise.
	146	+ * @see java.net.InetSocketAddress#equals(java.lang.Object)
	147	+ */
	148	+ public final boolean equals(Object obj) {
	149	+ if (obj == null \|\| !(obj instanceof Proxy))
	150	+ return false;
	151	+ Proxy p = (Proxy) obj;
	152	+ if (p.type() == type()) {
	153	+ if (address() == null) {
	154	+ return (p.address() == null);
	155	+ } else
	156	+ return address().equals(p.address());
	157	+ }
	158	+ return false;
	159	+ }
	160	+
	161	+ /**
	162	+ * Returns a hashcode for this Proxy.
	163	+ *
	164	+ * @return a hash code value for this Proxy.
	165	+ */
	166	+ public final int hashCode() {
	167	+ if (address() == null)
	168	+ return type().hashCode();
	169	+ return type().hashCode() + address().hashCode();
	170	+ }
	171	+}

java/pkg/java/net/ProxySelector.class+0−0

Binary file not shown.

java/pkg/java/net/ProxySelector.java+166−0

@@ -0,0 +1,166 @@
	1	+/*
	2	+ * Copyright (c) 2003, 2006, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.io.IOException;
	29	+import java.util.List;
	30	+import sun.security.util.SecurityConstants;
	31	+
	32	+/**
	33	+ * Selects the proxy server to use, if any, when connecting to the
	34	+ * network resource referenced by a URL. A proxy selector is a
	35	+ * concrete sub-class of this class and is registered by invoking the
	36	+ * {@link java.net.ProxySelector#setDefault setDefault} method. The
	37	+ * currently registered proxy selector can be retrieved by calling
	38	+ * {@link java.net.ProxySelector#getDefault getDefault} method.
	39	+ *
	40	+ * <p> When a proxy selector is registered, for instance, a subclass
	41	+ * of URLConnection class should call the {@link #select select}
	42	+ * method for each URL request so that the proxy selector can decide
	43	+ * if a direct, or proxied connection should be used. The {@link
	44	+ * #select select} method returns an iterator over a collection with
	45	+ * the preferred connection approach.
	46	+ *
	47	+ * <p> If a connection cannot be established to a proxy (PROXY or
	48	+ * SOCKS) servers then the caller should call the proxy selector's
	49	+ * {@link #connectFailed connectFailed} method to notify the proxy
	50	+ * selector that the proxy server is unavailable. </p>
	51	+ *
	52	+ * <P>The default proxy selector does enforce a
	53	+ * <a href="doc-files/net-properties.html#Proxies">set of System Properties</a>
	54	+ * related to proxy settings.</P>
	55	+ *
	56	+ * @author Yingxian Wang
	57	+ * @author Jean-Christophe Collet
	58	+ * @since 1.5
	59	+ */
	60	+public abstract class ProxySelector {
	61	+ /**
	62	+ * The system wide proxy selector that selects the proxy server to
	63	+ * use, if any, when connecting to a remote object referenced by
	64	+ * an URL.
	65	+ *
	66	+ * @see #setDefault(ProxySelector)
	67	+ */
	68	+ private static ProxySelector theProxySelector;
	69	+
	70	+ static {
	71	+ try {
	72	+ Class c = Class.forName("sun.net.spi.DefaultProxySelector");
	73	+ if (c != null && ProxySelector.class.isAssignableFrom(c)) {
	74	+ theProxySelector = (ProxySelector) c.newInstance();
	75	+ }
	76	+ } catch (Exception e) {
	77	+ theProxySelector = null;
	78	+ }
	79	+ }
	80	+
	81	+ /**
	82	+ * Gets the system-wide proxy selector.
	83	+ *
	84	+ * @throws SecurityException
	85	+ * If a security manager has been installed and it denies
	86	+ * {@link NetPermission}<tt>("getProxySelector")</tt>
	87	+ * @see #setDefault(ProxySelector)
	88	+ * @return the system-wide <code>ProxySelector</code>
	89	+ * @since 1.5
	90	+ */
	91	+ public static ProxySelector getDefault() {
	92	+ SecurityManager sm = System.getSecurityManager();
	93	+ if (sm != null) {
	94	+ sm.checkPermission(SecurityConstants.GET_PROXYSELECTOR_PERMISSION);
	95	+ }
	96	+ return theProxySelector;
	97	+ }
	98	+
	99	+ /**
	100	+ * Sets (or unsets) the system-wide proxy selector.
	101	+ *
	102	+ * Note: non-standard protocol handlers may ignore this setting.
	103	+ *
	104	+ * @param ps The HTTP proxy selector, or
	105	+ * <code>null</code> to unset the proxy selector.
	106	+ *
	107	+ * @throws SecurityException
	108	+ * If a security manager has been installed and it denies
	109	+ * {@link NetPermission}<tt>("setProxySelector")</tt>
	110	+ *
	111	+ * @see #getDefault()
	112	+ * @since 1.5
	113	+ */
	114	+ public static void setDefault(ProxySelector ps) {
	115	+ SecurityManager sm = System.getSecurityManager();
	116	+ if (sm != null) {
	117	+ sm.checkPermission(SecurityConstants.SET_PROXYSELECTOR_PERMISSION);
	118	+ }
	119	+ theProxySelector = ps;
	120	+ }
	121	+
	122	+ /**
	123	+ * Selects all the applicable proxies based on the protocol to
	124	+ * access the resource with and a destination address to access
	125	+ * the resource at.
	126	+ * The format of the URI is defined as follow:
	127	+ * <UL>
	128	+ * <LI>http URI for http connections</LI>
	129	+ * <LI>https URI for https connections
	130	+ * <LI>ftp URI for ftp connections</LI>
	131	+ * <LI><code>socket://host:port</code><br>
	132	+ * for tcp client sockets connections</LI>
	133	+ * </UL>
	134	+ *
	135	+ * @param uri
	136	+ * The URI that a connection is required to
	137	+ *
	138	+ * @return a List of Proxies. Each element in the
	139	+ * the List is of type
	140	+ * {@link java.net.Proxy Proxy};
	141	+ * when no proxy is available, the list will
	142	+ * contain one element of type
	143	+ * {@link java.net.Proxy Proxy}
	144	+ * that represents a direct connection.
	145	+ * @throws IllegalArgumentException if the argument is null
	146	+ */
	147	+ public abstract List<Proxy> select(URI uri);
	148	+
	149	+ /**
	150	+ * Called to indicate that a connection could not be established
	151	+ * to a proxy/socks server. An implementation of this method can
	152	+ * temporarily remove the proxies or reorder the sequence of
	153	+ * proxies returned by {@link #select(URI)}, using the address
	154	+ * and the IOException caught when trying to connect.
	155	+ *
	156	+ * @param uri
	157	+ * The URI that the proxy at sa failed to serve.
	158	+ * @param sa
	159	+ * The socket address of the proxy/SOCKS server
	160	+ *
	161	+ * @param ioe
	162	+ * The I/O exception thrown when the connect failed.
	163	+ * @throws IllegalArgumentException if either argument is null
	164	+ */
	165	+ public abstract void connectFailed(URI uri, SocketAddress sa, IOException ioe);
	166	+}

java/pkg/java/net/ResponseCache.class+0−0

Binary file not shown.

java/pkg/java/net/ResponseCache.java+163−0

@@ -0,0 +1,163 @@
	1	+/*
	2	+ * Copyright (c) 2003, 2008, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.io.IOException;
	29	+import java.util.Map;
	30	+import java.util.List;
	31	+import sun.security.util.SecurityConstants;
	32	+
	33	+/**
	34	+ * Represents implementations of URLConnection caches. An instance of
	35	+ * such a class can be registered with the system by doing
	36	+ * ResponseCache.setDefault(ResponseCache), and the system will call
	37	+ * this object in order to:
	38	+ *
	39	+ * <ul><li>store resource data which has been retrieved from an
	40	+ * external source into the cache</li>
	41	+ * <li>try to fetch a requested resource that may have been
	42	+ * stored in the cache</li>
	43	+ * </ul>
	44	+ *
	45	+ * The ResponseCache implementation decides which resources
	46	+ * should be cached, and for how long they should be cached. If a
	47	+ * request resource cannot be retrieved from the cache, then the
	48	+ * protocol handlers will fetch the resource from its original
	49	+ * location.
	50	+ *
	51	+ * The settings for URLConnection#useCaches controls whether the
	52	+ * protocol is allowed to use a cached response.
	53	+ *
	54	+ * For more information on HTTP caching, see <a
	55	+ * href="http://www.ietf.org/rfc/rfc2616.txt"><i>RFC 2616: Hypertext
	56	+ * Transfer Protocol -- HTTP/1.1</i></a>
	57	+ *
	58	+ * @author Yingxian Wang
	59	+ * @since 1.5
	60	+ */
	61	+public abstract class ResponseCache {
	62	+
	63	+ /**
	64	+ * The system wide cache that provides access to a url
	65	+ * caching mechanism.
	66	+ *
	67	+ * @see #setDefault(ResponseCache)
	68	+ * @see #getDefault()
	69	+ */
	70	+ private static ResponseCache theResponseCache;
	71	+
	72	+ /**
	73	+ * Gets the system-wide response cache.
	74	+ *
	75	+ * @throws SecurityException
	76	+ * If a security manager has been installed and it denies
	77	+ * {@link NetPermission}<tt>("getResponseCache")</tt>
	78	+ *
	79	+ * @see #setDefault(ResponseCache)
	80	+ * @return the system-wide <code>ResponseCache</code>
	81	+ * @since 1.5
	82	+ */
	83	+ public synchronized static ResponseCache getDefault() {
	84	+ SecurityManager sm = System.getSecurityManager();
	85	+ if (sm != null) {
	86	+ sm.checkPermission(SecurityConstants.GET_RESPONSECACHE_PERMISSION);
	87	+ }
	88	+ return theResponseCache;
	89	+ }
	90	+
	91	+ /**
	92	+ * Sets (or unsets) the system-wide cache.
	93	+ *
	94	+ * Note: non-standard procotol handlers may ignore this setting.
	95	+ *
	96	+ * @param responseCache The response cache, or
	97	+ * <code>null</code> to unset the cache.
	98	+ *
	99	+ * @throws SecurityException
	100	+ * If a security manager has been installed and it denies
	101	+ * {@link NetPermission}<tt>("setResponseCache")</tt>
	102	+ *
	103	+ * @see #getDefault()
	104	+ * @since 1.5
	105	+ */
	106	+ public synchronized static void setDefault(ResponseCache responseCache) {
	107	+ SecurityManager sm = System.getSecurityManager();
	108	+ if (sm != null) {
	109	+ sm.checkPermission(SecurityConstants.SET_RESPONSECACHE_PERMISSION);
	110	+ }
	111	+ theResponseCache = responseCache;
	112	+ }
	113	+
	114	+ /**
	115	+ * Retrieve the cached response based on the requesting uri,
	116	+ * request method and request headers. Typically this method is
	117	+ * called by the protocol handler before it sends out the request
	118	+ * to get the network resource. If a cached response is returned,
	119	+ * that resource is used instead.
	120	+ *
	121	+ * @param uri a <code>URI</code> used to reference the requested
	122	+ * network resource
	123	+ * @param rqstMethod a <code>String</code> representing the request
	124	+ * method
	125	+ * @param rqstHeaders - a Map from request header
	126	+ * field names to lists of field values representing
	127	+ * the current request headers
	128	+ * @return a <code>CacheResponse</code> instance if available
	129	+ * from cache, or null otherwise
	130	+ * @throws IOException if an I/O error occurs
	131	+ * @throws IllegalArgumentException if any one of the arguments is null
	132	+ *
	133	+ * @see java.net.URLConnection#setUseCaches(boolean)
	134	+ * @see java.net.URLConnection#getUseCaches()
	135	+ * @see java.net.URLConnection#setDefaultUseCaches(boolean)
	136	+ * @see java.net.URLConnection#getDefaultUseCaches()
	137	+ */
	138	+ public abstract CacheResponse
	139	+ get(URI uri, String rqstMethod, Map<String, List<String>> rqstHeaders)
	140	+ throws IOException;
	141	+
	142	+ /**
	143	+ * The protocol handler calls this method after a resource has
	144	+ * been retrieved, and the ResponseCache must decide whether or
	145	+ * not to store the resource in its cache. If the resource is to
	146	+ * be cached, then put() must return a CacheRequest object which
	147	+ * contains an OutputStream that the protocol handler will
	148	+ * use to write the resource into the cache. If the resource is
	149	+ * not to be cached, then put must return null.
	150	+ *
	151	+ * @param uri a <code>URI</code> used to reference the requested
	152	+ * network resource
	153	+ * @param conn - a URLConnection instance that is used to fetch
	154	+ * the response to be cached
	155	+ * @return a <code>CacheRequest</code> for recording the
	156	+ * response to be cached. Null return indicates that
	157	+ * the caller does not intend to cache the response.
	158	+ * @throws IOException if an I/O error occurs
	159	+ * @throws IllegalArgumentException if any one of the arguments is
	160	+ * null
	161	+ */
	162	+ public abstract CacheRequest put(URI uri, URLConnection conn) throws IOException;
	163	+}

java/pkg/java/net/SdpSocketImpl.class+0−0

Binary file not shown.

java/pkg/java/net/SdpSocketImpl.java+49−0

@@ -0,0 +1,49 @@
	1	+/*
	2	+ * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.io.IOException;
	29	+import java.io.FileDescriptor;
	30	+
	31	+import sun.net.sdp.SdpSupport;
	32	+
	33	+/**
	34	+ * SocketImpl that supports the SDP protocol
	35	+ */
	36	+class SdpSocketImpl extends PlainSocketImpl {
	37	+ SdpSocketImpl() { }
	38	+
	39	+ @Override
	40	+ protected void create(boolean stream) throws IOException {
	41	+ if (!stream)
	42	+ throw new UnsupportedOperationException("Must be a stream socket");
	43	+ fd = SdpSupport.createSocket();
	44	+ if (socket != null)
	45	+ socket.setCreated();
	46	+ if (serverSocket != null)
	47	+ serverSocket.setCreated();
	48	+ }
	49	+}

java/pkg/java/net/SecureCacheResponse.class+0−0

Binary file not shown.

java/pkg/java/net/SecureCacheResponse.java+108−0

@@ -0,0 +1,108 @@
	1	+/*
	2	+ * Copyright (c) 2003, 2004, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.security.cert.Certificate;
	29	+import javax.net.ssl.SSLPeerUnverifiedException;
	30	+import java.security.Principal;
	31	+import java.util.List;
	32	+
	33	+/**
	34	+ * Represents a cache response originally retrieved through secure
	35	+ * means, such as TLS.
	36	+ *
	37	+ * @since 1.5
	38	+ */
	39	+public abstract class SecureCacheResponse extends CacheResponse {
	40	+ /**
	41	+ * Returns the cipher suite in use on the original connection that
	42	+ * retrieved the network resource.
	43	+ *
	44	+ * @return a string representing the cipher suite
	45	+ */
	46	+ public abstract String getCipherSuite();
	47	+
	48	+ /**
	49	+ * Returns the certificate chain that were sent to the server during
	50	+ * handshaking of the original connection that retrieved the
	51	+ * network resource. Note: This method is useful only
	52	+ * when using certificate-based cipher suites.
	53	+ *
	54	+ * @return an immutable List of Certificate representing the
	55	+ * certificate chain that was sent to the server. If no
	56	+ * certificate chain was sent, null will be returned.
	57	+ * @see #getLocalPrincipal()
	58	+ */
	59	+ public abstract List<Certificate> getLocalCertificateChain();
	60	+
	61	+ /**
	62	+ * Returns the server's certificate chain, which was established as
	63	+ * part of defining the session in the original connection that
	64	+ * retrieved the network resource, from cache. Note: This method
	65	+ * can be used only when using certificate-based cipher suites;
	66	+ * using it with non-certificate-based cipher suites, such as
	67	+ * Kerberos, will throw an SSLPeerUnverifiedException.
	68	+ *
	69	+ * @return an immutable List of Certificate representing the server's
	70	+ * certificate chain.
	71	+ * @throws SSLPeerUnverifiedException if the peer is not verified.
	72	+ * @see #getPeerPrincipal()
	73	+ */
	74	+ public abstract List<Certificate> getServerCertificateChain()
	75	+ throws SSLPeerUnverifiedException;
	76	+
	77	+ /**
	78	+ * Returns the server's principal which was established as part of
	79	+ * defining the session during the original connection that
	80	+ * retrieved the network resource.
	81	+ *
	82	+ * @return the server's principal. Returns an X500Principal of the
	83	+ * end-entity certiticate for X509-based cipher suites, and
	84	+ * KerberosPrincipal for Kerberos cipher suites.
	85	+ *
	86	+ * @throws SSLPeerUnverifiedException if the peer was not verified.
	87	+ *
	88	+ * @see #getServerCertificateChain()
	89	+ * @see #getLocalPrincipal()
	90	+ */
	91	+ public abstract Principal getPeerPrincipal()
	92	+ throws SSLPeerUnverifiedException;
	93	+
	94	+ /**
	95	+ * Returns the principal that was sent to the server during
	96	+ * handshaking in the original connection that retrieved the
	97	+ * network resource.
	98	+ *
	99	+ * @return the principal sent to the server. Returns an X500Principal
	100	+ * of the end-entity certificate for X509-based cipher suites, and
	101	+ * KerberosPrincipal for Kerberos cipher suites. If no principal was
	102	+ * sent, then null is returned.
	103	+ *
	104	+ * @see #getLocalCertificateChain()
	105	+ * @see #getPeerPrincipal()
	106	+ */
	107	+ public abstract Principal getLocalPrincipal();
	108	+}

java/pkg/java/net/ServerSocket$1.class+0−0

Binary file not shown.

java/pkg/java/net/ServerSocket.class+0−0

Binary file not shown.

java/pkg/java/net/ServerSocket.java+886−0

@@ -0,0 +1,886 @@
	1	+/*
	2	+ * Copyright (c) 1995, 2010, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.io.FileDescriptor;
	29	+import java.io.IOException;
	30	+import java.nio.channels.ServerSocketChannel;
	31	+import java.security.AccessController;
	32	+import java.security.PrivilegedExceptionAction;
	33	+
	34	+/**
	35	+ * This class implements server sockets. A server socket waits for
	36	+ * requests to come in over the network. It performs some operation
	37	+ * based on that request, and then possibly returns a result to the requester.
	38	+ * <p>
	39	+ * The actual work of the server socket is performed by an instance
	40	+ * of the <code>SocketImpl</code> class. An application can
	41	+ * change the socket factory that creates the socket
	42	+ * implementation to configure itself to create sockets
	43	+ * appropriate to the local firewall.
	44	+ *
	45	+ * @author unascribed
	46	+ * @see java.net.SocketImpl
	47	+ * @see java.net.ServerSocket#setSocketFactory(java.net.SocketImplFactory)
	48	+ * @see java.nio.channels.ServerSocketChannel
	49	+ * @since JDK1.0
	50	+ */
	51	+public
	52	+class ServerSocket implements java.io.Closeable {
	53	+ /**
	54	+ * Various states of this socket.
	55	+ */
	56	+ private boolean created = false;
	57	+ private boolean bound = false;
	58	+ private boolean closed = false;
	59	+ private Object closeLock = new Object();
	60	+
	61	+ /**
	62	+ * The implementation of this Socket.
	63	+ */
	64	+ private SocketImpl impl;
	65	+
	66	+ /**
	67	+ * Are we using an older SocketImpl?
	68	+ */
	69	+ private boolean oldImpl = false;
	70	+
	71	+ /**
	72	+ * Package-private constructor to create a ServerSocket associated with
	73	+ * the given SocketImpl.
	74	+ */
	75	+ ServerSocket(SocketImpl impl) {
	76	+ this.impl = impl;
	77	+ impl.setServerSocket(this);
	78	+ }
	79	+
	80	+ /**
	81	+ * Creates an unbound server socket.
	82	+ *
	83	+ * @exception IOException IO error when opening the socket.
	84	+ * @revised 1.4
	85	+ */
	86	+ public ServerSocket() throws IOException {
	87	+ setImpl();
	88	+ }
	89	+
	90	+ /**
	91	+ * Creates a server socket, bound to the specified port. A port number
	92	+ * of <code>0</code> means that the port number is automatically
	93	+ * allocated, typically from an ephemeral port range. This port
	94	+ * number can then be retrieved by calling {@link #getLocalPort getLocalPort}.
	95	+ * <p>
	96	+ * The maximum queue length for incoming connection indications (a
	97	+ * request to connect) is set to <code>50</code>. If a connection
	98	+ * indication arrives when the queue is full, the connection is refused.
	99	+ * <p>
	100	+ * If the application has specified a server socket factory, that
	101	+ * factory's <code>createSocketImpl</code> method is called to create
	102	+ * the actual socket implementation. Otherwise a "plain" socket is created.
	103	+ * <p>
	104	+ * If there is a security manager,
	105	+ * its <code>checkListen</code> method is called
	106	+ * with the <code>port</code> argument
	107	+ * as its argument to ensure the operation is allowed.
	108	+ * This could result in a SecurityException.
	109	+ *
	110	+ *
	111	+ * @param port the port number, or <code>0</code> to use a port
	112	+ * number that is automatically allocated.
	113	+ *
	114	+ * @exception IOException if an I/O error occurs when opening the socket.
	115	+ * @exception SecurityException
	116	+ * if a security manager exists and its <code>checkListen</code>
	117	+ * method doesn't allow the operation.
	118	+ * @exception IllegalArgumentException if the port parameter is outside
	119	+ * the specified range of valid port values, which is between
	120	+ * 0 and 65535, inclusive.
	121	+ *
	122	+ * @see java.net.SocketImpl
	123	+ * @see java.net.SocketImplFactory#createSocketImpl()
	124	+ * @see java.net.ServerSocket#setSocketFactory(java.net.SocketImplFactory)
	125	+ * @see SecurityManager#checkListen
	126	+ */
	127	+ public ServerSocket(int port) throws IOException {
	128	+ this(port, 50, null);
	129	+ }
	130	+
	131	+ /**
	132	+ * Creates a server socket and binds it to the specified local port
	133	+ * number, with the specified backlog.
	134	+ * A port number of <code>0</code> means that the port number is
	135	+ * automatically allocated, typically from an ephemeral port range.
	136	+ * This port number can then be retrieved by calling
	137	+ * {@link #getLocalPort getLocalPort}.
	138	+ * <p>
	139	+ * The maximum queue length for incoming connection indications (a
	140	+ * request to connect) is set to the <code>backlog</code> parameter. If
	141	+ * a connection indication arrives when the queue is full, the
	142	+ * connection is refused.
	143	+ * <p>
	144	+ * If the application has specified a server socket factory, that
	145	+ * factory's <code>createSocketImpl</code> method is called to create
	146	+ * the actual socket implementation. Otherwise a "plain" socket is created.
	147	+ * <p>
	148	+ * If there is a security manager,
	149	+ * its <code>checkListen</code> method is called
	150	+ * with the <code>port</code> argument
	151	+ * as its argument to ensure the operation is allowed.
	152	+ * This could result in a SecurityException.
	153	+ *
	154	+ * The <code>backlog</code> argument is the requested maximum number of
	155	+ * pending connections on the socket. Its exact semantics are implementation
	156	+ * specific. In particular, an implementation may impose a maximum length
	157	+ * or may choose to ignore the parameter altogther. The value provided
	158	+ * should be greater than <code>0</code>. If it is less than or equal to
	159	+ * <code>0</code>, then an implementation specific default will be used.
	160	+ * <P>
	161	+ *
	162	+ * @param port the port number, or <code>0</code> to use a port
	163	+ * number that is automatically allocated.
	164	+ * @param backlog requested maximum length of the queue of incoming
	165	+ * connections.
	166	+ *
	167	+ * @exception IOException if an I/O error occurs when opening the socket.
	168	+ * @exception SecurityException
	169	+ * if a security manager exists and its <code>checkListen</code>
	170	+ * method doesn't allow the operation.
	171	+ * @exception IllegalArgumentException if the port parameter is outside
	172	+ * the specified range of valid port values, which is between
	173	+ * 0 and 65535, inclusive.
	174	+ *
	175	+ * @see java.net.SocketImpl
	176	+ * @see java.net.SocketImplFactory#createSocketImpl()
	177	+ * @see java.net.ServerSocket#setSocketFactory(java.net.SocketImplFactory)
	178	+ * @see SecurityManager#checkListen
	179	+ */
	180	+ public ServerSocket(int port, int backlog) throws IOException {
	181	+ this(port, backlog, null);
	182	+ }
	183	+
	184	+ /**
	185	+ * Create a server with the specified port, listen backlog, and
	186	+ * local IP address to bind to. The <i>bindAddr</i> argument
	187	+ * can be used on a multi-homed host for a ServerSocket that
	188	+ * will only accept connect requests to one of its addresses.
	189	+ * If <i>bindAddr</i> is null, it will default accepting
	190	+ * connections on any/all local addresses.
	191	+ * The port must be between 0 and 65535, inclusive.
	192	+ * A port number of <code>0</code> means that the port number is
	193	+ * automatically allocated, typically from an ephemeral port range.
	194	+ * This port number can then be retrieved by calling
	195	+ * {@link #getLocalPort getLocalPort}.
	196	+ *
	197	+ * <P>If there is a security manager, this method
	198	+ * calls its <code>checkListen</code> method
	199	+ * with the <code>port</code> argument
	200	+ * as its argument to ensure the operation is allowed.
	201	+ * This could result in a SecurityException.
	202	+ *
	203	+ * The <code>backlog</code> argument is the requested maximum number of
	204	+ * pending connections on the socket. Its exact semantics are implementation
	205	+ * specific. In particular, an implementation may impose a maximum length
	206	+ * or may choose to ignore the parameter altogther. The value provided
	207	+ * should be greater than <code>0</code>. If it is less than or equal to
	208	+ * <code>0</code>, then an implementation specific default will be used.
	209	+ * <P>
	210	+ * @param port the port number, or <code>0</code> to use a port
	211	+ * number that is automatically allocated.
	212	+ * @param backlog requested maximum length of the queue of incoming
	213	+ * connections.
	214	+ * @param bindAddr the local InetAddress the server will bind to
	215	+ *
	216	+ * @throws SecurityException if a security manager exists and
	217	+ * its <code>checkListen</code> method doesn't allow the operation.
	218	+ *
	219	+ * @throws IOException if an I/O error occurs when opening the socket.
	220	+ * @exception IllegalArgumentException if the port parameter is outside
	221	+ * the specified range of valid port values, which is between
	222	+ * 0 and 65535, inclusive.
	223	+ *
	224	+ * @see SocketOptions
	225	+ * @see SocketImpl
	226	+ * @see SecurityManager#checkListen
	227	+ * @since JDK1.1
	228	+ */
	229	+ public ServerSocket(int port, int backlog, InetAddress bindAddr) throws IOException {
	230	+ setImpl();
	231	+ if (port < 0 \|\| port > 0xFFFF)
	232	+ throw new IllegalArgumentException(
	233	+ "Port value out of range: " + port);
	234	+ if (backlog < 1)
	235	+ backlog = 50;
	236	+ try {
	237	+ bind(new InetSocketAddress(bindAddr, port), backlog);
	238	+ } catch(SecurityException e) {
	239	+ close();
	240	+ throw e;
	241	+ } catch(IOException e) {
	242	+ close();
	243	+ throw e;
	244	+ }
	245	+ }
	246	+
	247	+ /**
	248	+ * Get the <code>SocketImpl</code> attached to this socket, creating
	249	+ * it if necessary.
	250	+ *
	251	+ * @return the <code>SocketImpl</code> attached to that ServerSocket.
	252	+ * @throws SocketException if creation fails.
	253	+ * @since 1.4
	254	+ */
	255	+ SocketImpl getImpl() throws SocketException {
	256	+ if (!created)
	257	+ createImpl();
	258	+ return impl;
	259	+ }
	260	+
	261	+ private void checkOldImpl() {
	262	+ if (impl == null)
	263	+ return;
	264	+ // SocketImpl.connect() is a protected method, therefore we need to use
	265	+ // getDeclaredMethod, therefore we need permission to access the member
	266	+ try {
	267	+ AccessController.doPrivileged(
	268	+ new PrivilegedExceptionAction<Void>() {
	269	+ public Void run() throws NoSuchMethodException {
	270	+ Class[] cl = new Class[2];
	271	+ cl[0] = SocketAddress.class;
	272	+ cl[1] = Integer.TYPE;
	273	+ impl.getClass().getDeclaredMethod("connect", cl);
	274	+ return null;
	275	+ }
	276	+ });
	277	+ } catch (java.security.PrivilegedActionException e) {
	278	+ oldImpl = true;
	279	+ }
	280	+ }
	281	+
	282	+ private void setImpl() {
	283	+ if (factory != null) {
	284	+ impl = factory.createSocketImpl();
	285	+ checkOldImpl();
	286	+ } else {
	287	+ // No need to do a checkOldImpl() here, we know it's an up to date
	288	+ // SocketImpl!
	289	+ impl = new SocksSocketImpl();
	290	+ }
	291	+ if (impl != null)
	292	+ impl.setServerSocket(this);
	293	+ }
	294	+
	295	+ /**
	296	+ * Creates the socket implementation.
	297	+ *
	298	+ * @throws IOException if creation fails
	299	+ * @since 1.4
	300	+ */
	301	+ void createImpl() throws SocketException {
	302	+ if (impl == null)
	303	+ setImpl();
	304	+ try {
	305	+ impl.create(true);
	306	+ created = true;
	307	+ } catch (IOException e) {
	308	+ throw new SocketException(e.getMessage());
	309	+ }
	310	+ }
	311	+
	312	+ /**
	313	+ *
	314	+ * Binds the <code>ServerSocket</code> to a specific address
	315	+ * (IP address and port number).
	316	+ * <p>
	317	+ * If the address is <code>null</code>, then the system will pick up
	318	+ * an ephemeral port and a valid local address to bind the socket.
	319	+ * <p>
	320	+ * @param endpoint The IP address & port number to bind to.
	321	+ * @throws IOException if the bind operation fails, or if the socket
	322	+ * is already bound.
	323	+ * @throws SecurityException if a <code>SecurityManager</code> is present and
	324	+ * its <code>checkListen</code> method doesn't allow the operation.
	325	+ * @throws IllegalArgumentException if endpoint is a
	326	+ * SocketAddress subclass not supported by this socket
	327	+ * @since 1.4
	328	+ */
	329	+ public void bind(SocketAddress endpoint) throws IOException {
	330	+ bind(endpoint, 50);
	331	+ }
	332	+
	333	+ /**
	334	+ *
	335	+ * Binds the <code>ServerSocket</code> to a specific address
	336	+ * (IP address and port number).
	337	+ * <p>
	338	+ * If the address is <code>null</code>, then the system will pick up
	339	+ * an ephemeral port and a valid local address to bind the socket.
	340	+ * <P>
	341	+ * The <code>backlog</code> argument is the requested maximum number of
	342	+ * pending connections on the socket. Its exact semantics are implementation
	343	+ * specific. In particular, an implementation may impose a maximum length
	344	+ * or may choose to ignore the parameter altogther. The value provided
	345	+ * should be greater than <code>0</code>. If it is less than or equal to
	346	+ * <code>0</code>, then an implementation specific default will be used.
	347	+ * @param endpoint The IP address & port number to bind to.
	348	+ * @param backlog requested maximum length of the queue of
	349	+ * incoming connections.
	350	+ * @throws IOException if the bind operation fails, or if the socket
	351	+ * is already bound.
	352	+ * @throws SecurityException if a <code>SecurityManager</code> is present and
	353	+ * its <code>checkListen</code> method doesn't allow the operation.
	354	+ * @throws IllegalArgumentException if endpoint is a
	355	+ * SocketAddress subclass not supported by this socket
	356	+ * @since 1.4
	357	+ */
	358	+ public void bind(SocketAddress endpoint, int backlog) throws IOException {
	359	+ if (isClosed())
	360	+ throw new SocketException("Socket is closed");
	361	+ if (!oldImpl && isBound())
	362	+ throw new SocketException("Already bound");
	363	+ if (endpoint == null)
	364	+ endpoint = new InetSocketAddress(0);
	365	+ if (!(endpoint instanceof InetSocketAddress))
	366	+ throw new IllegalArgumentException("Unsupported address type");
	367	+ InetSocketAddress epoint = (InetSocketAddress) endpoint;
	368	+ if (epoint.isUnresolved())
	369	+ throw new SocketException("Unresolved address");
	370	+ if (backlog < 1)
	371	+ backlog = 50;
	372	+ try {
	373	+ SecurityManager security = System.getSecurityManager();
	374	+ if (security != null)
	375	+ security.checkListen(epoint.getPort());
	376	+ getImpl().bind(epoint.getAddress(), epoint.getPort());
	377	+ getImpl().listen(backlog);
	378	+ bound = true;
	379	+ } catch(SecurityException e) {
	380	+ bound = false;
	381	+ throw e;
	382	+ } catch(IOException e) {
	383	+ bound = false;
	384	+ throw e;
	385	+ }
	386	+ }
	387	+
	388	+ /**
	389	+ * Returns the local address of this server socket.
	390	+ * <p>
	391	+ * If the socket was bound prior to being {@link #close closed},
	392	+ * then this method will continue to return the local address
	393	+ * after the socket is closed.
	394	+ *
	395	+ * @return the address to which this socket is bound,
	396	+ * or <code>null</code> if the socket is unbound.
	397	+ */
	398	+ public InetAddress getInetAddress() {
	399	+ if (!isBound())
	400	+ return null;
	401	+ try {
	402	+ return getImpl().getInetAddress();
	403	+ } catch (SocketException e) {
	404	+ // nothing
	405	+ // If we're bound, the impl has been created
	406	+ // so we shouldn't get here
	407	+ }
	408	+ return null;
	409	+ }
	410	+
	411	+ /**
	412	+ * Returns the port number on which this socket is listening.
	413	+ * <p>
	414	+ * If the socket was bound prior to being {@link #close closed},
	415	+ * then this method will continue to return the port number
	416	+ * after the socket is closed.
	417	+ *
	418	+ * @return the port number to which this socket is listening or
	419	+ * -1 if the socket is not bound yet.
	420	+ */
	421	+ public int getLocalPort() {
	422	+ if (!isBound())
	423	+ return -1;
	424	+ try {
	425	+ return getImpl().getLocalPort();
	426	+ } catch (SocketException e) {
	427	+ // nothing
	428	+ // If we're bound, the impl has been created
	429	+ // so we shouldn't get here
	430	+ }
	431	+ return -1;
	432	+ }
	433	+
	434	+ /**
	435	+ * Returns the address of the endpoint this socket is bound to, or
	436	+ * <code>null</code> if it is not bound yet.
	437	+ * <p>
	438	+ * If the socket was bound prior to being {@link #close closed},
	439	+ * then this method will continue to return the address of the endpoint
	440	+ * after the socket is closed.
	441	+ *
	442	+ * @return a <code>SocketAddress</code> representing the local endpoint of this
	443	+ * socket, or <code>null</code> if it is not bound yet.
	444	+ * @see #getInetAddress()
	445	+ * @see #getLocalPort()
	446	+ * @see #bind(SocketAddress)
	447	+ * @since 1.4
	448	+ */
	449	+
	450	+ public SocketAddress getLocalSocketAddress() {
	451	+ if (!isBound())
	452	+ return null;
	453	+ return new InetSocketAddress(getInetAddress(), getLocalPort());
	454	+ }
	455	+
	456	+ /**
	457	+ * Listens for a connection to be made to this socket and accepts
	458	+ * it. The method blocks until a connection is made.
	459	+ *
	460	+ * <p>A new Socket <code>s</code> is created and, if there
	461	+ * is a security manager,
	462	+ * the security manager's <code>checkAccept</code> method is called
	463	+ * with <code>s.getInetAddress().getHostAddress()</code> and
	464	+ * <code>s.getPort()</code>
	465	+ * as its arguments to ensure the operation is allowed.
	466	+ * This could result in a SecurityException.
	467	+ *
	468	+ * @exception IOException if an I/O error occurs when waiting for a
	469	+ * connection.
	470	+ * @exception SecurityException if a security manager exists and its
	471	+ * <code>checkAccept</code> method doesn't allow the operation.
	472	+ * @exception SocketTimeoutException if a timeout was previously set with setSoTimeout and
	473	+ * the timeout has been reached.
	474	+ * @exception java.nio.channels.IllegalBlockingModeException
	475	+ * if this socket has an associated channel, the channel is in
	476	+ * non-blocking mode, and there is no connection ready to be
	477	+ * accepted
	478	+ *
	479	+ * @return the new Socket
	480	+ * @see SecurityManager#checkAccept
	481	+ * @revised 1.4
	482	+ * @spec JSR-51
	483	+ */
	484	+ public Socket accept() throws IOException {
	485	+ if (isClosed())
	486	+ throw new SocketException("Socket is closed");
	487	+ if (!isBound())
	488	+ throw new SocketException("Socket is not bound yet");
	489	+ Socket s = new Socket((SocketImpl) null);
	490	+ implAccept(s);
	491	+ return s;
	492	+ }
	493	+
	494	+ /**
	495	+ * Subclasses of ServerSocket use this method to override accept()
	496	+ * to return their own subclass of socket. So a FooServerSocket
	497	+ * will typically hand this method an <i>empty</i> FooSocket. On
	498	+ * return from implAccept the FooSocket will be connected to a client.
	499	+ *
	500	+ * @param s the Socket
	501	+ * @throws java.nio.channels.IllegalBlockingModeException
	502	+ * if this socket has an associated channel,
	503	+ * and the channel is in non-blocking mode
	504	+ * @throws IOException if an I/O error occurs when waiting
	505	+ * for a connection.
	506	+ * @since JDK1.1
	507	+ * @revised 1.4
	508	+ * @spec JSR-51
	509	+ */
	510	+ protected final void implAccept(Socket s) throws IOException {
	511	+ SocketImpl si = null;
	512	+ try {
	513	+ if (s.impl == null)
	514	+ s.setImpl();
	515	+ else {
	516	+ s.impl.reset();
	517	+ }
	518	+ si = s.impl;
	519	+ s.impl = null;
	520	+ si.address = new InetAddress();
	521	+ si.fd = new FileDescriptor();
	522	+ getImpl().accept(si);
	523	+
	524	+ SecurityManager security = System.getSecurityManager();
	525	+ if (security != null) {
	526	+ security.checkAccept(si.getInetAddress().getHostAddress(),
	527	+ si.getPort());
	528	+ }
	529	+ } catch (IOException e) {
	530	+ if (si != null)
	531	+ si.reset();
	532	+ s.impl = si;
	533	+ throw e;
	534	+ } catch (SecurityException e) {
	535	+ if (si != null)
	536	+ si.reset();
	537	+ s.impl = si;
	538	+ throw e;
	539	+ }
	540	+ s.impl = si;
	541	+ s.postAccept();
	542	+ }
	543	+
	544	+ /**
	545	+ * Closes this socket.
	546	+ *
	547	+ * Any thread currently blocked in {@link #accept()} will throw
	548	+ * a {@link SocketException}.
	549	+ *
	550	+ * <p> If this socket has an associated channel then the channel is closed
	551	+ * as well.
	552	+ *
	553	+ * @exception IOException if an I/O error occurs when closing the socket.
	554	+ * @revised 1.4
	555	+ * @spec JSR-51
	556	+ */
	557	+ public void close() throws IOException {
	558	+ synchronized(closeLock) {
	559	+ if (isClosed())
	560	+ return;
	561	+ if (created)
	562	+ impl.close();
	563	+ closed = true;
	564	+ }
	565	+ }
	566	+
	567	+ /**
	568	+ * Returns the unique {@link java.nio.channels.ServerSocketChannel} object
	569	+ * associated with this socket, if any.
	570	+ *
	571	+ * <p> A server socket will have a channel if, and only if, the channel
	572	+ * itself was created via the {@link
	573	+ * java.nio.channels.ServerSocketChannel#open ServerSocketChannel.open}
	574	+ * method.
	575	+ *
	576	+ * @return the server-socket channel associated with this socket,
	577	+ * or <tt>null</tt> if this socket was not created
	578	+ * for a channel
	579	+ *
	580	+ * @since 1.4
	581	+ * @spec JSR-51
	582	+ */
	583	+ public ServerSocketChannel getChannel() {
	584	+ return null;
	585	+ }
	586	+
	587	+ /**
	588	+ * Returns the binding state of the ServerSocket.
	589	+ *
	590	+ * @return true if the ServerSocket succesfuly bound to an address
	591	+ * @since 1.4
	592	+ */
	593	+ public boolean isBound() {
	594	+ // Before 1.3 ServerSockets were always bound during creation
	595	+ return bound \|\| oldImpl;
	596	+ }
	597	+
	598	+ /**
	599	+ * Returns the closed state of the ServerSocket.
	600	+ *
	601	+ * @return true if the socket has been closed
	602	+ * @since 1.4
	603	+ */
	604	+ public boolean isClosed() {
	605	+ synchronized(closeLock) {
	606	+ return closed;
	607	+ }
	608	+ }
	609	+
	610	+ /**
	611	+ * Enable/disable SO_TIMEOUT with the specified timeout, in
	612	+ * milliseconds. With this option set to a non-zero timeout,
	613	+ * a call to accept() for this ServerSocket
	614	+ * will block for only this amount of time. If the timeout expires,
	615	+ * a <B>java.net.SocketTimeoutException</B> is raised, though the
	616	+ * ServerSocket is still valid. The option <B>must</B> be enabled
	617	+ * prior to entering the blocking operation to have effect. The
	618	+ * timeout must be > 0.
	619	+ * A timeout of zero is interpreted as an infinite timeout.
	620	+ * @param timeout the specified timeout, in milliseconds
	621	+ * @exception SocketException if there is an error in
	622	+ * the underlying protocol, such as a TCP error.
	623	+ * @since JDK1.1
	624	+ * @see #getSoTimeout()
	625	+ */
	626	+ public synchronized void setSoTimeout(int timeout) throws SocketException {
	627	+ if (isClosed())
	628	+ throw new SocketException("Socket is closed");
	629	+ getImpl().setOption(SocketOptions.SO_TIMEOUT, new Integer(timeout));
	630	+ }
	631	+
	632	+ /**
	633	+ * Retrieve setting for SO_TIMEOUT. 0 returns implies that the
	634	+ * option is disabled (i.e., timeout of infinity).
	635	+ * @return the SO_TIMEOUT value
	636	+ * @exception IOException if an I/O error occurs
	637	+ * @since JDK1.1
	638	+ * @see #setSoTimeout(int)
	639	+ */
	640	+ public synchronized int getSoTimeout() throws IOException {
	641	+ if (isClosed())
	642	+ throw new SocketException("Socket is closed");
	643	+ Object o = getImpl().getOption(SocketOptions.SO_TIMEOUT);
	644	+ /* extra type safety */
	645	+ if (o instanceof Integer) {
	646	+ return ((Integer) o).intValue();
	647	+ } else {
	648	+ return 0;
	649	+ }
	650	+ }
	651	+
	652	+ /**
	653	+ * Enable/disable the SO_REUSEADDR socket option.
	654	+ * <p>
	655	+ * When a TCP connection is closed the connection may remain
	656	+ * in a timeout state for a period of time after the connection
	657	+ * is closed (typically known as the <tt>TIME_WAIT</tt> state
	658	+ * or <tt>2MSL</tt> wait state).
	659	+ * For applications using a well known socket address or port
	660	+ * it may not be possible to bind a socket to the required
	661	+ * <tt>SocketAddress</tt> if there is a connection in the
	662	+ * timeout state involving the socket address or port.
	663	+ * <p>
	664	+ * Enabling <tt>SO_REUSEADDR</tt> prior to binding the socket
	665	+ * using {@link #bind(SocketAddress)} allows the socket to be
	666	+ * bound even though a previous connection is in a timeout
	667	+ * state.
	668	+ * <p>
	669	+ * When a <tt>ServerSocket</tt> is created the initial setting
	670	+ * of <tt>SO_REUSEADDR</tt> is not defined. Applications can
	671	+ * use {@link #getReuseAddress()} to determine the initial
	672	+ * setting of <tt>SO_REUSEADDR</tt>.
	673	+ * <p>
	674	+ * The behaviour when <tt>SO_REUSEADDR</tt> is enabled or
	675	+ * disabled after a socket is bound (See {@link #isBound()})
	676	+ * is not defined.
	677	+ *
	678	+ * @param on whether to enable or disable the socket option
	679	+ * @exception SocketException if an error occurs enabling or
	680	+ * disabling the <tt>SO_RESUEADDR</tt> socket option,
	681	+ * or the socket is closed.
	682	+ * @since 1.4
	683	+ * @see #getReuseAddress()
	684	+ * @see #bind(SocketAddress)
	685	+ * @see #isBound()
	686	+ * @see #isClosed()
	687	+ */
	688	+ public void setReuseAddress(boolean on) throws SocketException {
	689	+ if (isClosed())
	690	+ throw new SocketException("Socket is closed");
	691	+ getImpl().setOption(SocketOptions.SO_REUSEADDR, Boolean.valueOf(on));
	692	+ }
	693	+
	694	+ /**
	695	+ * Tests if SO_REUSEADDR is enabled.
	696	+ *
	697	+ * @return a <code>boolean</code> indicating whether or not SO_REUSEADDR is enabled.
	698	+ * @exception SocketException if there is an error
	699	+ * in the underlying protocol, such as a TCP error.
	700	+ * @since 1.4
	701	+ * @see #setReuseAddress(boolean)
	702	+ */
	703	+ public boolean getReuseAddress() throws SocketException {
	704	+ if (isClosed())
	705	+ throw new SocketException("Socket is closed");
	706	+ return ((Boolean) (getImpl().getOption(SocketOptions.SO_REUSEADDR))).booleanValue();
	707	+ }
	708	+
	709	+ /**
	710	+ * Returns the implementation address and implementation port of
	711	+ * this socket as a <code>String</code>.
	712	+ *
	713	+ * @return a string representation of this socket.
	714	+ */
	715	+ public String toString() {
	716	+ if (!isBound())
	717	+ return "ServerSocket[unbound]";
	718	+ return "ServerSocket[addr=" + impl.getInetAddress() +
	719	+ ",port=" + impl.getPort() +
	720	+ ",localport=" + impl.getLocalPort() + "]";
	721	+ }
	722	+
	723	+ void setBound() {
	724	+ bound = true;
	725	+ }
	726	+
	727	+ void setCreated() {
	728	+ created = true;
	729	+ }
	730	+
	731	+ /**
	732	+ * The factory for all server sockets.
	733	+ */
	734	+ private static SocketImplFactory factory = null;
	735	+
	736	+ /**
	737	+ * Sets the server socket implementation factory for the
	738	+ * application. The factory can be specified only once.
	739	+ * <p>
	740	+ * When an application creates a new server socket, the socket
	741	+ * implementation factory's <code>createSocketImpl</code> method is
	742	+ * called to create the actual socket implementation.
	743	+ * <p>
	744	+ * Passing <code>null</code> to the method is a no-op unless the factory
	745	+ * was already set.
	746	+ * <p>
	747	+ * If there is a security manager, this method first calls
	748	+ * the security manager's <code>checkSetFactory</code> method
	749	+ * to ensure the operation is allowed.
	750	+ * This could result in a SecurityException.
	751	+ *
	752	+ * @param fac the desired factory.
	753	+ * @exception IOException if an I/O error occurs when setting the
	754	+ * socket factory.
	755	+ * @exception SocketException if the factory has already been defined.
	756	+ * @exception SecurityException if a security manager exists and its
	757	+ * <code>checkSetFactory</code> method doesn't allow the operation.
	758	+ * @see java.net.SocketImplFactory#createSocketImpl()
	759	+ * @see SecurityManager#checkSetFactory
	760	+ */
	761	+ public static synchronized void setSocketFactory(SocketImplFactory fac) throws IOException {
	762	+ if (factory != null) {
	763	+ throw new SocketException("factory already defined");
	764	+ }
	765	+ SecurityManager security = System.getSecurityManager();
	766	+ if (security != null) {
	767	+ security.checkSetFactory();
	768	+ }
	769	+ factory = fac;
	770	+ }
	771	+
	772	+ /**
	773	+ * Sets a default proposed value for the SO_RCVBUF option for sockets
	774	+ * accepted from this <tt>ServerSocket</tt>. The value actually set
	775	+ * in the accepted socket must be determined by calling
	776	+ * {@link Socket#getReceiveBufferSize()} after the socket
	777	+ * is returned by {@link #accept()}.
	778	+ * <p>
	779	+ * The value of SO_RCVBUF is used both to set the size of the internal
	780	+ * socket receive buffer, and to set the size of the TCP receive window
	781	+ * that is advertized to the remote peer.
	782	+ * <p>
	783	+ * It is possible to change the value subsequently, by calling
	784	+ * {@link Socket#setReceiveBufferSize(int)}. However, if the application
	785	+ * wishes to allow a receive window larger than 64K bytes, as defined by RFC1323
	786	+ * then the proposed value must be set in the ServerSocket <B>before</B>
	787	+ * it is bound to a local address. This implies, that the ServerSocket must be
	788	+ * created with the no-argument constructor, then setReceiveBufferSize() must
	789	+ * be called and lastly the ServerSocket is bound to an address by calling bind().
	790	+ * <p>
	791	+ * Failure to do this will not cause an error, and the buffer size may be set to the
	792	+ * requested value but the TCP receive window in sockets accepted from
	793	+ * this ServerSocket will be no larger than 64K bytes.
	794	+ *
	795	+ * @exception SocketException if there is an error
	796	+ * in the underlying protocol, such as a TCP error.
	797	+ *
	798	+ * @param size the size to which to set the receive buffer
	799	+ * size. This value must be greater than 0.
	800	+ *
	801	+ * @exception IllegalArgumentException if the
	802	+ * value is 0 or is negative.
	803	+ *
	804	+ * @since 1.4
	805	+ * @see #getReceiveBufferSize
	806	+ */
	807	+ public synchronized void setReceiveBufferSize (int size) throws SocketException {
	808	+ if (!(size > 0)) {
	809	+ throw new IllegalArgumentException("negative receive size");
	810	+ }
	811	+ if (isClosed())
	812	+ throw new SocketException("Socket is closed");
	813	+ getImpl().setOption(SocketOptions.SO_RCVBUF, new Integer(size));
	814	+ }
	815	+
	816	+ /**
	817	+ * Gets the value of the SO_RCVBUF option for this <tt>ServerSocket</tt>,
	818	+ * that is the proposed buffer size that will be used for Sockets accepted
	819	+ * from this <tt>ServerSocket</tt>.
	820	+ *
	821	+ * <p>Note, the value actually set in the accepted socket is determined by
	822	+ * calling {@link Socket#getReceiveBufferSize()}.
	823	+ * @return the value of the SO_RCVBUF option for this <tt>Socket</tt>.
	824	+ * @exception SocketException if there is an error
	825	+ * in the underlying protocol, such as a TCP error.
	826	+ * @see #setReceiveBufferSize(int)
	827	+ * @since 1.4
	828	+ */
	829	+ public synchronized int getReceiveBufferSize()
	830	+ throws SocketException{
	831	+ if (isClosed())
	832	+ throw new SocketException("Socket is closed");
	833	+ int result = 0;
	834	+ Object o = getImpl().getOption(SocketOptions.SO_RCVBUF);
	835	+ if (o instanceof Integer) {
	836	+ result = ((Integer)o).intValue();
	837	+ }
	838	+ return result;
	839	+ }
	840	+
	841	+ /**
	842	+ * Sets performance preferences for this ServerSocket.
	843	+ *
	844	+ * <p> Sockets use the TCP/IP protocol by default. Some implementations
	845	+ * may offer alternative protocols which have different performance
	846	+ * characteristics than TCP/IP. This method allows the application to
	847	+ * express its own preferences as to how these tradeoffs should be made
	848	+ * when the implementation chooses from the available protocols.
	849	+ *
	850	+ * <p> Performance preferences are described by three integers
	851	+ * whose values indicate the relative importance of short connection time,
	852	+ * low latency, and high bandwidth. The absolute values of the integers
	853	+ * are irrelevant; in order to choose a protocol the values are simply
	854	+ * compared, with larger values indicating stronger preferences. If the
	855	+ * application prefers short connection time over both low latency and high
	856	+ * bandwidth, for example, then it could invoke this method with the values
	857	+ * <tt>(1, 0, 0)</tt>. If the application prefers high bandwidth above low
	858	+ * latency, and low latency above short connection time, then it could
	859	+ * invoke this method with the values <tt>(0, 1, 2)</tt>.
	860	+ *
	861	+ * <p> Invoking this method after this socket has been bound
	862	+ * will have no effect. This implies that in order to use this capability
	863	+ * requires the socket to be created with the no-argument constructor.
	864	+ *
	865	+ * @param connectionTime
	866	+ * An <tt>int</tt> expressing the relative importance of a short
	867	+ * connection time
	868	+ *
	869	+ * @param latency
	870	+ * An <tt>int</tt> expressing the relative importance of low
	871	+ * latency
	872	+ *
	873	+ * @param bandwidth
	874	+ * An <tt>int</tt> expressing the relative importance of high
	875	+ * bandwidth
	876	+ *
	877	+ * @since 1.5
	878	+ */
	879	+ public void setPerformancePreferences(int connectionTime,
	880	+ int latency,
	881	+ int bandwidth)
	882	+ {
	883	+ /* Not implemented yet */
	884	+ }
	885	+
	886	+}

java/pkg/java/net/Socket$1.class+0−0

Binary file not shown.

java/pkg/java/net/Socket$2.class+0−0

Binary file not shown.

java/pkg/java/net/Socket$3.class+0−0

Binary file not shown.

java/pkg/java/net/Socket.class+0−0

Binary file not shown.

java/pkg/java/net/Socket.java+1663−0

@@ -0,0 +1,1663 @@
	1	+/*
	2	+ * Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.io.InputStream;
	29	+import java.io.OutputStream;
	30	+import java.io.IOException;
	31	+import java.io.InterruptedIOException;
	32	+import java.nio.channels.SocketChannel;
	33	+import java.security.AccessController;
	34	+import java.security.PrivilegedExceptionAction;
	35	+import java.security.PrivilegedAction;
	36	+
	37	+/**
	38	+ * This class implements client sockets (also called just
	39	+ * "sockets"). A socket is an endpoint for communication
	40	+ * between two machines.
	41	+ * <p>
	42	+ * The actual work of the socket is performed by an instance of the
	43	+ * <code>SocketImpl</code> class. An application, by changing
	44	+ * the socket factory that creates the socket implementation,
	45	+ * can configure itself to create sockets appropriate to the local
	46	+ * firewall.
	47	+ *
	48	+ * @author unascribed
	49	+ * @see java.net.Socket#setSocketImplFactory(java.net.SocketImplFactory)
	50	+ * @see java.net.SocketImpl
	51	+ * @see java.nio.channels.SocketChannel
	52	+ * @since JDK1.0
	53	+ */
	54	+public
	55	+class Socket implements java.io.Closeable {
	56	+ /**
	57	+ * Various states of this socket.
	58	+ */
	59	+ private boolean created = false;
	60	+ private boolean bound = false;
	61	+ private boolean connected = false;
	62	+ private boolean closed = false;
	63	+ private Object closeLock = new Object();
	64	+ private boolean shutIn = false;
	65	+ private boolean shutOut = false;
	66	+
	67	+ /**
	68	+ * The implementation of this Socket.
	69	+ */
	70	+ SocketImpl impl;
	71	+
	72	+ /**
	73	+ * Are we using an older SocketImpl?
	74	+ */
	75	+ private boolean oldImpl = false;
	76	+
	77	+ /**
	78	+ * Creates an unconnected socket, with the
	79	+ * system-default type of SocketImpl.
	80	+ *
	81	+ * @since JDK1.1
	82	+ * @revised 1.4
	83	+ */
	84	+ public Socket() {
	85	+ setImpl();
	86	+ }
	87	+
	88	+ /**
	89	+ * Creates an unconnected socket, specifying the type of proxy, if any,
	90	+ * that should be used regardless of any other settings.
	91	+ * <P>
	92	+ * If there is a security manager, its <code>checkConnect</code> method
	93	+ * is called with the proxy host address and port number
	94	+ * as its arguments. This could result in a SecurityException.
	95	+ * <P>
	96	+ * Examples:
	97	+ * <UL> <LI><code>Socket s = new Socket(Proxy.NO_PROXY);</code> will create
	98	+ * a plain socket ignoring any other proxy configuration.</LI>
	99	+ * <LI><code>Socket s = new Socket(new Proxy(Proxy.Type.SOCKS, new InetSocketAddress("socks.mydom.com", 1080)));</code>
	100	+ * will create a socket connecting through the specified SOCKS proxy
	101	+ * server.</LI>
	102	+ * </UL>
	103	+ *
	104	+ * @param proxy a {@link java.net.Proxy Proxy} object specifying what kind
	105	+ * of proxying should be used.
	106	+ * @throws IllegalArgumentException if the proxy is of an invalid type
	107	+ * or <code>null</code>.
	108	+ * @throws SecurityException if a security manager is present and
	109	+ * permission to connect to the proxy is
	110	+ * denied.
	111	+ * @see java.net.ProxySelector
	112	+ * @see java.net.Proxy
	113	+ *
	114	+ * @since 1.5
	115	+ */
	116	+ public Socket(Proxy proxy) {
	117	+ // Create a copy of Proxy as a security measure
	118	+ if (proxy == null) {
	119	+ throw new IllegalArgumentException("Invalid Proxy");
	120	+ }
	121	+ Proxy p = proxy == Proxy.NO_PROXY ? Proxy.NO_PROXY : sun.net.ApplicationProxy.create(proxy);
	122	+ if (p.type() == Proxy.Type.SOCKS) {
	123	+ SecurityManager security = System.getSecurityManager();
	124	+ InetSocketAddress epoint = (InetSocketAddress) p.address();
	125	+ if (epoint.getAddress() != null) {
	126	+ checkAddress (epoint.getAddress(), "Socket");
	127	+ }
	128	+ if (security != null) {
	129	+ if (epoint.isUnresolved())
	130	+ epoint = new InetSocketAddress(epoint.getHostName(), epoint.getPort());
	131	+ if (epoint.isUnresolved())
	132	+ security.checkConnect(epoint.getHostName(), epoint.getPort());
	133	+ else
	134	+ security.checkConnect(epoint.getAddress().getHostAddress(),
	135	+ epoint.getPort());
	136	+ }
	137	+ impl = new SocksSocketImpl(p);
	138	+ impl.setSocket(this);
	139	+ } else {
	140	+ if (p == Proxy.NO_PROXY) {
	141	+ if (factory == null) {
	142	+ impl = new PlainSocketImpl();
	143	+ impl.setSocket(this);
	144	+ } else
	145	+ setImpl();
	146	+ } else
	147	+ throw new IllegalArgumentException("Invalid Proxy");
	148	+ }
	149	+ }
	150	+
	151	+ /**
	152	+ * Creates an unconnected Socket with a user-specified
	153	+ * SocketImpl.
	154	+ * <P>
	155	+ * @param impl an instance of a <B>SocketImpl</B>
	156	+ * the subclass wishes to use on the Socket.
	157	+ *
	158	+ * @exception SocketException if there is an error in the underlying protocol,
	159	+ * such as a TCP error.
	160	+ * @since JDK1.1
	161	+ */
	162	+ protected Socket(SocketImpl impl) throws SocketException {
	163	+ this.impl = impl;
	164	+ if (impl != null) {
	165	+ checkOldImpl();
	166	+ this.impl.setSocket(this);
	167	+ }
	168	+ }
	169	+
	170	+ /**
	171	+ * Creates a stream socket and connects it to the specified port
	172	+ * number on the named host.
	173	+ * <p>
	174	+ * If the specified host is <tt>null</tt> it is the equivalent of
	175	+ * specifying the address as <tt>{@link java.net.InetAddress#getByName InetAddress.getByName}(null)</tt>.
	176	+ * In other words, it is equivalent to specifying an address of the
	177	+ * loopback interface. </p>
	178	+ * <p>
	179	+ * If the application has specified a server socket factory, that
	180	+ * factory's <code>createSocketImpl</code> method is called to create
	181	+ * the actual socket implementation. Otherwise a "plain" socket is created.
	182	+ * <p>
	183	+ * If there is a security manager, its
	184	+ * <code>checkConnect</code> method is called
	185	+ * with the host address and <code>port</code>
	186	+ * as its arguments. This could result in a SecurityException.
	187	+ *
	188	+ * @param host the host name, or <code>null</code> for the loopback address.
	189	+ * @param port the port number.
	190	+ *
	191	+ * @exception UnknownHostException if the IP address of
	192	+ * the host could not be determined.
	193	+ *
	194	+ * @exception IOException if an I/O error occurs when creating the socket.
	195	+ * @exception SecurityException if a security manager exists and its
	196	+ * <code>checkConnect</code> method doesn't allow the operation.
	197	+ * @exception IllegalArgumentException if the port parameter is outside
	198	+ * the specified range of valid port values, which is between
	199	+ * 0 and 65535, inclusive.
	200	+ * @see java.net.Socket#setSocketImplFactory(java.net.SocketImplFactory)
	201	+ * @see java.net.SocketImpl
	202	+ * @see java.net.SocketImplFactory#createSocketImpl()
	203	+ * @see SecurityManager#checkConnect
	204	+ */
	205	+ public Socket(String host, int port)
	206	+ throws UnknownHostException, IOException
	207	+ {
	208	+ this(host != null ? new InetSocketAddress(host, port) :
	209	+ new InetSocketAddress(InetAddress.getByName(null), port),
	210	+ (SocketAddress) null, true);
	211	+ }
	212	+
	213	+ /**
	214	+ * Creates a stream socket and connects it to the specified port
	215	+ * number at the specified IP address.
	216	+ * <p>
	217	+ * If the application has specified a socket factory, that factory's
	218	+ * <code>createSocketImpl</code> method is called to create the
	219	+ * actual socket implementation. Otherwise a "plain" socket is created.
	220	+ * <p>
	221	+ * If there is a security manager, its
	222	+ * <code>checkConnect</code> method is called
	223	+ * with the host address and <code>port</code>
	224	+ * as its arguments. This could result in a SecurityException.
	225	+ *
	226	+ * @param address the IP address.
	227	+ * @param port the port number.
	228	+ * @exception IOException if an I/O error occurs when creating the socket.
	229	+ * @exception SecurityException if a security manager exists and its
	230	+ * <code>checkConnect</code> method doesn't allow the operation.
	231	+ * @exception IllegalArgumentException if the port parameter is outside
	232	+ * the specified range of valid port values, which is between
	233	+ * 0 and 65535, inclusive.
	234	+ * @exception NullPointerException if <code>address</code> is null.
	235	+ * @see java.net.Socket#setSocketImplFactory(java.net.SocketImplFactory)
	236	+ * @see java.net.SocketImpl
	237	+ * @see java.net.SocketImplFactory#createSocketImpl()
	238	+ * @see SecurityManager#checkConnect
	239	+ */
	240	+ public Socket(InetAddress address, int port) throws IOException {
	241	+ this(address != null ? new InetSocketAddress(address, port) : null,
	242	+ (SocketAddress) null, true);
	243	+ }
	244	+
	245	+ /**
	246	+ * Creates a socket and connects it to the specified remote host on
	247	+ * the specified remote port. The Socket will also bind() to the local
	248	+ * address and port supplied.
	249	+ * <p>
	250	+ * If the specified host is <tt>null</tt> it is the equivalent of
	251	+ * specifying the address as <tt>{@link java.net.InetAddress#getByName InetAddress.getByName}(null)</tt>.
	252	+ * In other words, it is equivalent to specifying an address of the
	253	+ * loopback interface. </p>
	254	+ * <p>
	255	+ * A local port number of <code>zero</code> will let the system pick up a
	256	+ * free port in the <code>bind</code> operation.</p>
	257	+ * <p>
	258	+ * If there is a security manager, its
	259	+ * <code>checkConnect</code> method is called
	260	+ * with the host address and <code>port</code>
	261	+ * as its arguments. This could result in a SecurityException.
	262	+ *
	263	+ * @param host the name of the remote host, or <code>null</code> for the loopback address.
	264	+ * @param port the remote port
	265	+ * @param localAddr the local address the socket is bound to, or
	266	+ * <code>null</code> for the <code>anyLocal</code> address.
	267	+ * @param localPort the local port the socket is bound to, or
	268	+ * <code>zero</code> for a system selected free port.
	269	+ * @exception IOException if an I/O error occurs when creating the socket.
	270	+ * @exception SecurityException if a security manager exists and its
	271	+ * <code>checkConnect</code> method doesn't allow the operation.
	272	+ * @exception IllegalArgumentException if the port parameter or localPort
	273	+ * parameter is outside the specified range of valid port values,
	274	+ * which is between 0 and 65535, inclusive.
	275	+ * @see SecurityManager#checkConnect
	276	+ * @since JDK1.1
	277	+ */
	278	+ public Socket(String host, int port, InetAddress localAddr,
	279	+ int localPort) throws IOException {
	280	+ this(host != null ? new InetSocketAddress(host, port) :
	281	+ new InetSocketAddress(InetAddress.getByName(null), port),
	282	+ new InetSocketAddress(localAddr, localPort), true);
	283	+ }
	284	+
	285	+ /**
	286	+ * Creates a socket and connects it to the specified remote address on
	287	+ * the specified remote port. The Socket will also bind() to the local
	288	+ * address and port supplied.
	289	+ * <p>
	290	+ * If the specified local address is <tt>null</tt> it is the equivalent of
	291	+ * specifying the address as the AnyLocal address (see <tt>{@link java.net.InetAddress#isAnyLocalAddress InetAddress.isAnyLocalAddress}()</tt>).
	292	+ * <p>
	293	+ * A local port number of <code>zero</code> will let the system pick up a
	294	+ * free port in the <code>bind</code> operation.</p>
	295	+ * <p>
	296	+ * If there is a security manager, its
	297	+ * <code>checkConnect</code> method is called
	298	+ * with the host address and <code>port</code>
	299	+ * as its arguments. This could result in a SecurityException.
	300	+ *
	301	+ * @param address the remote address
	302	+ * @param port the remote port
	303	+ * @param localAddr the local address the socket is bound to, or
	304	+ * <code>null</code> for the <code>anyLocal</code> address.
	305	+ * @param localPort the local port the socket is bound to or
	306	+ * <code>zero</code> for a system selected free port.
	307	+ * @exception IOException if an I/O error occurs when creating the socket.
	308	+ * @exception SecurityException if a security manager exists and its
	309	+ * <code>checkConnect</code> method doesn't allow the operation.
	310	+ * @exception IllegalArgumentException if the port parameter or localPort
	311	+ * parameter is outside the specified range of valid port values,
	312	+ * which is between 0 and 65535, inclusive.
	313	+ * @exception NullPointerException if <code>address</code> is null.
	314	+ * @see SecurityManager#checkConnect
	315	+ * @since JDK1.1
	316	+ */
	317	+ public Socket(InetAddress address, int port, InetAddress localAddr,
	318	+ int localPort) throws IOException {
	319	+ this(address != null ? new InetSocketAddress(address, port) : null,
	320	+ new InetSocketAddress(localAddr, localPort), true);
	321	+ }
	322	+
	323	+ /**
	324	+ * Creates a stream socket and connects it to the specified port
	325	+ * number on the named host.
	326	+ * <p>
	327	+ * If the specified host is <tt>null</tt> it is the equivalent of
	328	+ * specifying the address as <tt>{@link java.net.InetAddress#getByName InetAddress.getByName}(null)</tt>.
	329	+ * In other words, it is equivalent to specifying an address of the
	330	+ * loopback interface. </p>
	331	+ * <p>
	332	+ * If the stream argument is <code>true</code>, this creates a
	333	+ * stream socket. If the stream argument is <code>false</code>, it
	334	+ * creates a datagram socket.
	335	+ * <p>
	336	+ * If the application has specified a server socket factory, that
	337	+ * factory's <code>createSocketImpl</code> method is called to create
	338	+ * the actual socket implementation. Otherwise a "plain" socket is created.
	339	+ * <p>
	340	+ * If there is a security manager, its
	341	+ * <code>checkConnect</code> method is called
	342	+ * with the host address and <code>port</code>
	343	+ * as its arguments. This could result in a SecurityException.
	344	+ * <p>
	345	+ * If a UDP socket is used, TCP/IP related socket options will not apply.
	346	+ *
	347	+ * @param host the host name, or <code>null</code> for the loopback address.
	348	+ * @param port the port number.
	349	+ * @param stream a <code>boolean</code> indicating whether this is
	350	+ * a stream socket or a datagram socket.
	351	+ * @exception IOException if an I/O error occurs when creating the socket.
	352	+ * @exception SecurityException if a security manager exists and its
	353	+ * <code>checkConnect</code> method doesn't allow the operation.
	354	+ * @exception IllegalArgumentException if the port parameter is outside
	355	+ * the specified range of valid port values, which is between
	356	+ * 0 and 65535, inclusive.
	357	+ * @see java.net.Socket#setSocketImplFactory(java.net.SocketImplFactory)
	358	+ * @see java.net.SocketImpl
	359	+ * @see java.net.SocketImplFactory#createSocketImpl()
	360	+ * @see SecurityManager#checkConnect
	361	+ * @deprecated Use DatagramSocket instead for UDP transport.
	362	+ */
	363	+ @Deprecated
	364	+ public Socket(String host, int port, boolean stream) throws IOException {
	365	+ this(host != null ? new InetSocketAddress(host, port) :
	366	+ new InetSocketAddress(InetAddress.getByName(null), port),
	367	+ (SocketAddress) null, stream);
	368	+ }
	369	+
	370	+ /**
	371	+ * Creates a socket and connects it to the specified port number at
	372	+ * the specified IP address.
	373	+ * <p>
	374	+ * If the stream argument is <code>true</code>, this creates a
	375	+ * stream socket. If the stream argument is <code>false</code>, it
	376	+ * creates a datagram socket.
	377	+ * <p>
	378	+ * If the application has specified a server socket factory, that
	379	+ * factory's <code>createSocketImpl</code> method is called to create
	380	+ * the actual socket implementation. Otherwise a "plain" socket is created.
	381	+ *
	382	+ * <p>If there is a security manager, its
	383	+ * <code>checkConnect</code> method is called
	384	+ * with <code>host.getHostAddress()</code> and <code>port</code>
	385	+ * as its arguments. This could result in a SecurityException.
	386	+ * <p>
	387	+ * If UDP socket is used, TCP/IP related socket options will not apply.
	388	+ *
	389	+ * @param host the IP address.
	390	+ * @param port the port number.
	391	+ * @param stream if <code>true</code>, create a stream socket;
	392	+ * otherwise, create a datagram socket.
	393	+ * @exception IOException if an I/O error occurs when creating the socket.
	394	+ * @exception SecurityException if a security manager exists and its
	395	+ * <code>checkConnect</code> method doesn't allow the operation.
	396	+ * @exception IllegalArgumentException if the port parameter is outside
	397	+ * the specified range of valid port values, which is between
	398	+ * 0 and 65535, inclusive.
	399	+ * @exception NullPointerException if <code>host</code> is null.
	400	+ * @see java.net.Socket#setSocketImplFactory(java.net.SocketImplFactory)
	401	+ * @see java.net.SocketImpl
	402	+ * @see java.net.SocketImplFactory#createSocketImpl()
	403	+ * @see SecurityManager#checkConnect
	404	+ * @deprecated Use DatagramSocket instead for UDP transport.
	405	+ */
	406	+ @Deprecated
	407	+ public Socket(InetAddress host, int port, boolean stream) throws IOException {
	408	+ this(host != null ? new InetSocketAddress(host, port) : null,
	409	+ new InetSocketAddress(0), stream);
	410	+ }
	411	+
	412	+ private Socket(SocketAddress address, SocketAddress localAddr,
	413	+ boolean stream) throws IOException {
	414	+ setImpl();
	415	+
	416	+ // backward compatibility
	417	+ if (address == null)
	418	+ throw new NullPointerException();
	419	+
	420	+ try {
	421	+ createImpl(stream);
	422	+ if (localAddr != null)
	423	+ bind(localAddr);
	424	+ if (address != null)
	425	+ connect(address);
	426	+ } catch (IOException e) {
	427	+ close();
	428	+ throw e;
	429	+ }
	430	+ }
	431	+
	432	+ /**
	433	+ * Creates the socket implementation.
	434	+ *
	435	+ * @param stream a <code>boolean</code> value : <code>true</code> for a TCP socket,
	436	+ * <code>false</code> for UDP.
	437	+ * @throws IOException if creation fails
	438	+ * @since 1.4
	439	+ */
	440	+ void createImpl(boolean stream) throws SocketException {
	441	+ if (impl == null)
	442	+ setImpl();
	443	+ try {
	444	+ impl.create(stream);
	445	+ created = true;
	446	+ } catch (IOException e) {
	447	+ throw new SocketException(e.getMessage());
	448	+ }
	449	+ }
	450	+
	451	+ private void checkOldImpl() {
	452	+ if (impl == null)
	453	+ return;
	454	+ // SocketImpl.connect() is a protected method, therefore we need to use
	455	+ // getDeclaredMethod, therefore we need permission to access the member
	456	+
	457	+ oldImpl = AccessController.doPrivileged
	458	+ (new PrivilegedAction<Boolean>() {
	459	+ public Boolean run() {
	460	+ Class[] cl = new Class[2];
	461	+ cl[0] = SocketAddress.class;
	462	+ cl[1] = Integer.TYPE;
	463	+ Class clazz = impl.getClass();
	464	+ while (true) {
	465	+ try {
	466	+ clazz.getDeclaredMethod("connect", cl);
	467	+ return Boolean.FALSE;
	468	+ } catch (NoSuchMethodException e) {
	469	+ clazz = clazz.getSuperclass();
	470	+ // java.net.SocketImpl class will always have this abstract method.
	471	+ // If we have not found it by now in the hierarchy then it does not
	472	+ // exist, we are an old style impl.
	473	+ if (clazz.equals(java.net.SocketImpl.class)) {
	474	+ return Boolean.TRUE;
	475	+ }
	476	+ }
	477	+ }
	478	+ }
	479	+ });
	480	+ }
	481	+
	482	+ /**
	483	+ * Sets impl to the system-default type of SocketImpl.
	484	+ * @since 1.4
	485	+ */
	486	+ void setImpl() {
	487	+ if (factory != null) {
	488	+ impl = factory.createSocketImpl();
	489	+ checkOldImpl();
	490	+ } else {
	491	+ // No need to do a checkOldImpl() here, we know it's an up to date
	492	+ // SocketImpl!
	493	+ impl = new SocksSocketImpl();
	494	+ }
	495	+ if (impl != null)
	496	+ impl.setSocket(this);
	497	+ }
	498	+
	499	+
	500	+ /**
	501	+ * Get the <code>SocketImpl</code> attached to this socket, creating
	502	+ * it if necessary.
	503	+ *
	504	+ * @return the <code>SocketImpl</code> attached to that ServerSocket.
	505	+ * @throws SocketException if creation fails
	506	+ * @since 1.4
	507	+ */
	508	+ SocketImpl getImpl() throws SocketException {
	509	+ if (!created)
	510	+ createImpl(true);
	511	+ return impl;
	512	+ }
	513	+
	514	+ /**
	515	+ * Connects this socket to the server.
	516	+ *
	517	+ * @param endpoint the <code>SocketAddress</code>
	518	+ * @throws IOException if an error occurs during the connection
	519	+ * @throws java.nio.channels.IllegalBlockingModeException
	520	+ * if this socket has an associated channel,
	521	+ * and the channel is in non-blocking mode
	522	+ * @throws IllegalArgumentException if endpoint is null or is a
	523	+ * SocketAddress subclass not supported by this socket
	524	+ * @since 1.4
	525	+ * @spec JSR-51
	526	+ */
	527	+ public void connect(SocketAddress endpoint) throws IOException {
	528	+ connect(endpoint, 0);
	529	+ }
	530	+
	531	+ /**
	532	+ * Connects this socket to the server with a specified timeout value.
	533	+ * A timeout of zero is interpreted as an infinite timeout. The connection
	534	+ * will then block until established or an error occurs.
	535	+ *
	536	+ * @param endpoint the <code>SocketAddress</code>
	537	+ * @param timeout the timeout value to be used in milliseconds.
	538	+ * @throws IOException if an error occurs during the connection
	539	+ * @throws SocketTimeoutException if timeout expires before connecting
	540	+ * @throws java.nio.channels.IllegalBlockingModeException
	541	+ * if this socket has an associated channel,
	542	+ * and the channel is in non-blocking mode
	543	+ * @throws IllegalArgumentException if endpoint is null or is a
	544	+ * SocketAddress subclass not supported by this socket
	545	+ * @since 1.4
	546	+ * @spec JSR-51
	547	+ */
	548	+ public void connect(SocketAddress endpoint, int timeout) throws IOException {
	549	+ if (endpoint == null)
	550	+ throw new IllegalArgumentException("connect: The address can't be null");
	551	+
	552	+ if (timeout < 0)
	553	+ throw new IllegalArgumentException("connect: timeout can't be negative");
	554	+
	555	+ if (isClosed())
	556	+ throw new SocketException("Socket is closed");
	557	+
	558	+ if (!oldImpl && isConnected())
	559	+ throw new SocketException("already connected");
	560	+
	561	+ if (!(endpoint instanceof InetSocketAddress))
	562	+ throw new IllegalArgumentException("Unsupported address type");
	563	+
	564	+ InetSocketAddress epoint = (InetSocketAddress) endpoint;
	565	+ InetAddress addr = epoint.getAddress ();
	566	+ int port = epoint.getPort();
	567	+ checkAddress(addr, "connect");
	568	+
	569	+ SecurityManager security = System.getSecurityManager();
	570	+ if (security != null) {
	571	+ if (epoint.isUnresolved())
	572	+ security.checkConnect(epoint.getHostName(), port);
	573	+ else
	574	+ security.checkConnect(addr.getHostAddress(), port);
	575	+ }
	576	+ if (!created)
	577	+ createImpl(true);
	578	+ if (!oldImpl)
	579	+ impl.connect(epoint, timeout);
	580	+ else if (timeout == 0) {
	581	+ if (epoint.isUnresolved())
	582	+ impl.connect(addr.getHostName(), port);
	583	+ else
	584	+ impl.connect(addr, port);
	585	+ } else
	586	+ throw new UnsupportedOperationException("SocketImpl.connect(addr, timeout)");
	587	+ connected = true;
	588	+ /*
	589	+ * If the socket was not bound before the connect, it is now because
	590	+ * the kernel will have picked an ephemeral port & a local address
	591	+ */
	592	+ bound = true;
	593	+ }
	594	+
	595	+ /**
	596	+ * Binds the socket to a local address.
	597	+ * <P>
	598	+ * If the address is <code>null</code>, then the system will pick up
	599	+ * an ephemeral port and a valid local address to bind the socket.
	600	+ *
	601	+ * @param bindpoint the <code>SocketAddress</code> to bind to
	602	+ * @throws IOException if the bind operation fails, or if the socket
	603	+ * is already bound.
	604	+ * @throws IllegalArgumentException if bindpoint is a
	605	+ * SocketAddress subclass not supported by this socket
	606	+ *
	607	+ * @since 1.4
	608	+ * @see #isBound
	609	+ */
	610	+ public void bind(SocketAddress bindpoint) throws IOException {
	611	+ if (isClosed())
	612	+ throw new SocketException("Socket is closed");
	613	+ if (!oldImpl && isBound())
	614	+ throw new SocketException("Already bound");
	615	+
	616	+ if (bindpoint != null && (!(bindpoint instanceof InetSocketAddress)))
	617	+ throw new IllegalArgumentException("Unsupported address type");
	618	+ InetSocketAddress epoint = (InetSocketAddress) bindpoint;
	619	+ if (epoint != null && epoint.isUnresolved())
	620	+ throw new SocketException("Unresolved address");
	621	+ if (epoint == null) {
	622	+ epoint = new InetSocketAddress(0);
	623	+ }
	624	+ InetAddress addr = epoint.getAddress();
	625	+ int port = epoint.getPort();
	626	+ checkAddress (addr, "bind");
	627	+ getImpl().bind (addr, port);
	628	+ bound = true;
	629	+ }
	630	+
	631	+ private void checkAddress (InetAddress addr, String op) {
	632	+ if (addr == null) {
	633	+ return;
	634	+ }
	635	+ if (!(addr instanceof Inet4Address \|\| addr instanceof Inet6Address)) {
	636	+ throw new IllegalArgumentException(op + ": invalid address type");
	637	+ }
	638	+ }
	639	+
	640	+ /**
	641	+ * set the flags after an accept() call.
	642	+ */
	643	+ final void postAccept() {
	644	+ connected = true;
	645	+ created = true;
	646	+ bound = true;
	647	+ }
	648	+
	649	+ void setCreated() {
	650	+ created = true;
	651	+ }
	652	+
	653	+ void setBound() {
	654	+ bound = true;
	655	+ }
	656	+
	657	+ void setConnected() {
	658	+ connected = true;
	659	+ }
	660	+
	661	+ /**
	662	+ * Returns the address to which the socket is connected.
	663	+ * <p>
	664	+ * If the socket was connected prior to being {@link #close closed},
	665	+ * then this method will continue to return the connected address
	666	+ * after the socket is closed.
	667	+ *
	668	+ * @return the remote IP address to which this socket is connected,
	669	+ * or <code>null</code> if the socket is not connected.
	670	+ */
	671	+ public InetAddress getInetAddress() {
	672	+ if (!isConnected())
	673	+ return null;
	674	+ try {
	675	+ return getImpl().getInetAddress();
	676	+ } catch (SocketException e) {
	677	+ }
	678	+ return null;
	679	+ }
	680	+
	681	+ /**
	682	+ * Gets the local address to which the socket is bound.
	683	+ *
	684	+ * @return the local address to which the socket is bound, or
	685	+ * the {@link InetAddress#isAnyLocalAddress wildcard} address
	686	+ * if the socket is closed or not bound yet.
	687	+ * @since JDK1.1
	688	+ */
	689	+ public InetAddress getLocalAddress() {
	690	+ // This is for backward compatibility
	691	+ if (!isBound())
	692	+ return InetAddress.anyLocalAddress();
	693	+ InetAddress in = null;
	694	+ try {
	695	+ in = (InetAddress) getImpl().getOption(SocketOptions.SO_BINDADDR);
	696	+ if (in.isAnyLocalAddress()) {
	697	+ in = InetAddress.anyLocalAddress();
	698	+ }
	699	+ } catch (Exception e) {
	700	+ in = InetAddress.anyLocalAddress(); // "0.0.0.0"
	701	+ }
	702	+ return in;
	703	+ }
	704	+
	705	+ /**
	706	+ * Returns the remote port number to which this socket is connected.
	707	+ * <p>
	708	+ * If the socket was connected prior to being {@link #close closed},
	709	+ * then this method will continue to return the connected port number
	710	+ * after the socket is closed.
	711	+ *
	712	+ * @return the remote port number to which this socket is connected, or
	713	+ * 0 if the socket is not connected yet.
	714	+ */
	715	+ public int getPort() {
	716	+ if (!isConnected())
	717	+ return 0;
	718	+ try {
	719	+ return getImpl().getPort();
	720	+ } catch (SocketException e) {
	721	+ // Shouldn't happen as we're connected
	722	+ }
	723	+ return -1;
	724	+ }
	725	+
	726	+ /**
	727	+ * Returns the local port number to which this socket is bound.
	728	+ * <p>
	729	+ * If the socket was bound prior to being {@link #close closed},
	730	+ * then this method will continue to return the local port number
	731	+ * after the socket is closed.
	732	+ *
	733	+ * @return the local port number to which this socket is bound or -1
	734	+ * if the socket is not bound yet.
	735	+ */
	736	+ public int getLocalPort() {
	737	+ if (!isBound())
	738	+ return -1;
	739	+ try {
	740	+ return getImpl().getLocalPort();
	741	+ } catch(SocketException e) {
	742	+ // shouldn't happen as we're bound
	743	+ }
	744	+ return -1;
	745	+ }
	746	+
	747	+ /**
	748	+ * Returns the address of the endpoint this socket is connected to, or
	749	+ * <code>null</code> if it is unconnected.
	750	+ * <p>
	751	+ * If the socket was connected prior to being {@link #close closed},
	752	+ * then this method will continue to return the connected address
	753	+ * after the socket is closed.
	754	+ *
	755	+
	756	+ * @return a <code>SocketAddress</code> representing the remote endpoint of this
	757	+ * socket, or <code>null</code> if it is not connected yet.
	758	+ * @see #getInetAddress()
	759	+ * @see #getPort()
	760	+ * @see #connect(SocketAddress, int)
	761	+ * @see #connect(SocketAddress)
	762	+ * @since 1.4
	763	+ */
	764	+ public SocketAddress getRemoteSocketAddress() {
	765	+ if (!isConnected())
	766	+ return null;
	767	+ return new InetSocketAddress(getInetAddress(), getPort());
	768	+ }
	769	+
	770	+ /**
	771	+ * Returns the address of the endpoint this socket is bound to, or
	772	+ * <code>null</code> if it is not bound yet.
	773	+ * <p>
	774	+ * If a socket bound to an endpoint represented by an
	775	+ * <code>InetSocketAddress </code> is {@link #close closed},
	776	+ * then this method will continue to return an <code>InetSocketAddress</code>
	777	+ * after the socket is closed. In that case the returned
	778	+ * <code>InetSocketAddress</code>'s address is the
	779	+ * {@link InetAddress#isAnyLocalAddress wildcard} address
	780	+ * and its port is the local port that it was bound to.
	781	+ *
	782	+ * @return a <code>SocketAddress</code> representing the local endpoint of this
	783	+ * socket, or <code>null</code> if it is not bound yet.
	784	+ * @see #getLocalAddress()
	785	+ * @see #getLocalPort()
	786	+ * @see #bind(SocketAddress)
	787	+ * @since 1.4
	788	+ */
	789	+
	790	+ public SocketAddress getLocalSocketAddress() {
	791	+ if (!isBound())
	792	+ return null;
	793	+ return new InetSocketAddress(getLocalAddress(), getLocalPort());
	794	+ }
	795	+
	796	+ /**
	797	+ * Returns the unique {@link java.nio.channels.SocketChannel SocketChannel}
	798	+ * object associated with this socket, if any.
	799	+ *
	800	+ * <p> A socket will have a channel if, and only if, the channel itself was
	801	+ * created via the {@link java.nio.channels.SocketChannel#open
	802	+ * SocketChannel.open} or {@link
	803	+ * java.nio.channels.ServerSocketChannel#accept ServerSocketChannel.accept}
	804	+ * methods.
	805	+ *
	806	+ * @return the socket channel associated with this socket,
	807	+ * or <tt>null</tt> if this socket was not created
	808	+ * for a channel
	809	+ *
	810	+ * @since 1.4
	811	+ * @spec JSR-51
	812	+ */
	813	+ public SocketChannel getChannel() {
	814	+ return null;
	815	+ }
	816	+
	817	+ /**
	818	+ * Returns an input stream for this socket.
	819	+ *
	820	+ * <p> If this socket has an associated channel then the resulting input
	821	+ * stream delegates all of its operations to the channel. If the channel
	822	+ * is in non-blocking mode then the input stream's <tt>read</tt> operations
	823	+ * will throw an {@link java.nio.channels.IllegalBlockingModeException}.
	824	+ *
	825	+ * <p>Under abnormal conditions the underlying connection may be
	826	+ * broken by the remote host or the network software (for example
	827	+ * a connection reset in the case of TCP connections). When a
	828	+ * broken connection is detected by the network software the
	829	+ * following applies to the returned input stream :-
	830	+ *
	831	+ * <ul>
	832	+ *
	833	+ * <li><p>The network software may discard bytes that are buffered
	834	+ * by the socket. Bytes that aren't discarded by the network
	835	+ * software can be read using {@link java.io.InputStream#read read}.
	836	+ *
	837	+ * <li><p>If there are no bytes buffered on the socket, or all
	838	+ * buffered bytes have been consumed by
	839	+ * {@link java.io.InputStream#read read}, then all subsequent
	840	+ * calls to {@link java.io.InputStream#read read} will throw an
	841	+ * {@link java.io.IOException IOException}.
	842	+ *
	843	+ * <li><p>If there are no bytes buffered on the socket, and the
	844	+ * socket has not been closed using {@link #close close}, then
	845	+ * {@link java.io.InputStream#available available} will
	846	+ * return <code>0</code>.
	847	+ *
	848	+ * </ul>
	849	+ *
	850	+ * <p> Closing the returned {@link java.io.InputStream InputStream}
	851	+ * will close the associated socket.
	852	+ *
	853	+ * @return an input stream for reading bytes from this socket.
	854	+ * @exception IOException if an I/O error occurs when creating the
	855	+ * input stream, the socket is closed, the socket is
	856	+ * not connected, or the socket input has been shutdown
	857	+ * using {@link #shutdownInput()}
	858	+ *
	859	+ * @revised 1.4
	860	+ * @spec JSR-51
	861	+ */
	862	+ public InputStream getInputStream() throws IOException {
	863	+ if (isClosed())
	864	+ throw new SocketException("Socket is closed");
	865	+ if (!isConnected())
	866	+ throw new SocketException("Socket is not connected");
	867	+ if (isInputShutdown())
	868	+ throw new SocketException("Socket input is shutdown");
	869	+ final Socket s = this;
	870	+ InputStream is = null;
	871	+ try {
	872	+ is = AccessController.doPrivileged(
	873	+ new PrivilegedExceptionAction<InputStream>() {
	874	+ public InputStream run() throws IOException {
	875	+ return impl.getInputStream();
	876	+ }
	877	+ });
	878	+ } catch (java.security.PrivilegedActionException e) {
	879	+ throw (IOException) e.getException();
	880	+ }
	881	+ return is;
	882	+ }
	883	+
	884	+ /**
	885	+ * Returns an output stream for this socket.
	886	+ *
	887	+ * <p> If this socket has an associated channel then the resulting output
	888	+ * stream delegates all of its operations to the channel. If the channel
	889	+ * is in non-blocking mode then the output stream's <tt>write</tt>
	890	+ * operations will throw an {@link
	891	+ * java.nio.channels.IllegalBlockingModeException}.
	892	+ *
	893	+ * <p> Closing the returned {@link java.io.OutputStream OutputStream}
	894	+ * will close the associated socket.
	895	+ *
	896	+ * @return an output stream for writing bytes to this socket.
	897	+ * @exception IOException if an I/O error occurs when creating the
	898	+ * output stream or if the socket is not connected.
	899	+ * @revised 1.4
	900	+ * @spec JSR-51
	901	+ */
	902	+ public OutputStream getOutputStream() throws IOException {
	903	+ if (isClosed())
	904	+ throw new SocketException("Socket is closed");
	905	+ if (!isConnected())
	906	+ throw new SocketException("Socket is not connected");
	907	+ if (isOutputShutdown())
	908	+ throw new SocketException("Socket output is shutdown");
	909	+ final Socket s = this;
	910	+ OutputStream os = null;
	911	+ try {
	912	+ os = AccessController.doPrivileged(
	913	+ new PrivilegedExceptionAction<OutputStream>() {
	914	+ public OutputStream run() throws IOException {
	915	+ return impl.getOutputStream();
	916	+ }
	917	+ });
	918	+ } catch (java.security.PrivilegedActionException e) {
	919	+ throw (IOException) e.getException();
	920	+ }
	921	+ return os;
	922	+ }
	923	+
	924	+ /**
	925	+ * Enable/disable TCP_NODELAY (disable/enable Nagle's algorithm).
	926	+ *
	927	+ * @param on <code>true</code> to enable TCP_NODELAY,
	928	+ * <code>false</code> to disable.
	929	+ *
	930	+ * @exception SocketException if there is an error
	931	+ * in the underlying protocol, such as a TCP error.
	932	+ *
	933	+ * @since JDK1.1
	934	+ *
	935	+ * @see #getTcpNoDelay()
	936	+ */
	937	+ public void setTcpNoDelay(boolean on) throws SocketException {
	938	+ if (isClosed())
	939	+ throw new SocketException("Socket is closed");
	940	+ getImpl().setOption(SocketOptions.TCP_NODELAY, Boolean.valueOf(on));
	941	+ }
	942	+
	943	+ /**
	944	+ * Tests if TCP_NODELAY is enabled.
	945	+ *
	946	+ * @return a <code>boolean</code> indicating whether or not TCP_NODELAY is enabled.
	947	+ * @exception SocketException if there is an error
	948	+ * in the underlying protocol, such as a TCP error.
	949	+ * @since JDK1.1
	950	+ * @see #setTcpNoDelay(boolean)
	951	+ */
	952	+ public boolean getTcpNoDelay() throws SocketException {
	953	+ if (isClosed())
	954	+ throw new SocketException("Socket is closed");
	955	+ return ((Boolean) getImpl().getOption(SocketOptions.TCP_NODELAY)).booleanValue();
	956	+ }
	957	+
	958	+ /**
	959	+ * Enable/disable SO_LINGER with the specified linger time in seconds.
	960	+ * The maximum timeout value is platform specific.
	961	+ *
	962	+ * The setting only affects socket close.
	963	+ *
	964	+ * @param on whether or not to linger on.
	965	+ * @param linger how long to linger for, if on is true.
	966	+ * @exception SocketException if there is an error
	967	+ * in the underlying protocol, such as a TCP error.
	968	+ * @exception IllegalArgumentException if the linger value is negative.
	969	+ * @since JDK1.1
	970	+ * @see #getSoLinger()
	971	+ */
	972	+ public void setSoLinger(boolean on, int linger) throws SocketException {
	973	+ if (isClosed())
	974	+ throw new SocketException("Socket is closed");
	975	+ if (!on) {
	976	+ getImpl().setOption(SocketOptions.SO_LINGER, new Boolean(on));
	977	+ } else {
	978	+ if (linger < 0) {
	979	+ throw new IllegalArgumentException("invalid value for SO_LINGER");
	980	+ }
	981	+ if (linger > 65535)
	982	+ linger = 65535;
	983	+ getImpl().setOption(SocketOptions.SO_LINGER, new Integer(linger));
	984	+ }
	985	+ }
	986	+
	987	+ /**
	988	+ * Returns setting for SO_LINGER. -1 returns implies that the
	989	+ * option is disabled.
	990	+ *
	991	+ * The setting only affects socket close.
	992	+ *
	993	+ * @return the setting for SO_LINGER.
	994	+ * @exception SocketException if there is an error
	995	+ * in the underlying protocol, such as a TCP error.
	996	+ * @since JDK1.1
	997	+ * @see #setSoLinger(boolean, int)
	998	+ */
	999	+ public int getSoLinger() throws SocketException {
	1000	+ if (isClosed())
	1001	+ throw new SocketException("Socket is closed");
	1002	+ Object o = getImpl().getOption(SocketOptions.SO_LINGER);
	1003	+ if (o instanceof Integer) {
	1004	+ return ((Integer) o).intValue();
	1005	+ } else {
	1006	+ return -1;
	1007	+ }
	1008	+ }
	1009	+
	1010	+ /**
	1011	+ * Send one byte of urgent data on the socket. The byte to be sent is the lowest eight
	1012	+ * bits of the data parameter. The urgent byte is
	1013	+ * sent after any preceding writes to the socket OutputStream
	1014	+ * and before any future writes to the OutputStream.
	1015	+ * @param data The byte of data to send
	1016	+ * @exception IOException if there is an error
	1017	+ * sending the data.
	1018	+ * @since 1.4
	1019	+ */
	1020	+ public void sendUrgentData (int data) throws IOException {
	1021	+ if (!getImpl().supportsUrgentData ()) {
	1022	+ throw new SocketException ("Urgent data not supported");
	1023	+ }
	1024	+ getImpl().sendUrgentData (data);
	1025	+ }
	1026	+
	1027	+ /**
	1028	+ * Enable/disable OOBINLINE (receipt of TCP urgent data)
	1029	+ *
	1030	+ * By default, this option is disabled and TCP urgent data received on a
	1031	+ * socket is silently discarded. If the user wishes to receive urgent data, then
	1032	+ * this option must be enabled. When enabled, urgent data is received
	1033	+ * inline with normal data.
	1034	+ * <p>
	1035	+ * Note, only limited support is provided for handling incoming urgent
	1036	+ * data. In particular, no notification of incoming urgent data is provided
	1037	+ * and there is no capability to distinguish between normal data and urgent
	1038	+ * data unless provided by a higher level protocol.
	1039	+ *
	1040	+ * @param on <code>true</code> to enable OOBINLINE,
	1041	+ * <code>false</code> to disable.
	1042	+ *
	1043	+ * @exception SocketException if there is an error
	1044	+ * in the underlying protocol, such as a TCP error.
	1045	+ *
	1046	+ * @since 1.4
	1047	+ *
	1048	+ * @see #getOOBInline()
	1049	+ */
	1050	+ public void setOOBInline(boolean on) throws SocketException {
	1051	+ if (isClosed())
	1052	+ throw new SocketException("Socket is closed");
	1053	+ getImpl().setOption(SocketOptions.SO_OOBINLINE, Boolean.valueOf(on));
	1054	+ }
	1055	+
	1056	+ /**
	1057	+ * Tests if OOBINLINE is enabled.
	1058	+ *
	1059	+ * @return a <code>boolean</code> indicating whether or not OOBINLINE is enabled.
	1060	+ * @exception SocketException if there is an error
	1061	+ * in the underlying protocol, such as a TCP error.
	1062	+ * @since 1.4
	1063	+ * @see #setOOBInline(boolean)
	1064	+ */
	1065	+ public boolean getOOBInline() throws SocketException {
	1066	+ if (isClosed())
	1067	+ throw new SocketException("Socket is closed");
	1068	+ return ((Boolean) getImpl().getOption(SocketOptions.SO_OOBINLINE)).booleanValue();
	1069	+ }
	1070	+
	1071	+ /**
	1072	+ * Enable/disable SO_TIMEOUT with the specified timeout, in
	1073	+ * milliseconds. With this option set to a non-zero timeout,
	1074	+ * a read() call on the InputStream associated with this Socket
	1075	+ * will block for only this amount of time. If the timeout expires,
	1076	+ * a <B>java.net.SocketTimeoutException</B> is raised, though the
	1077	+ * Socket is still valid. The option <B>must</B> be enabled
	1078	+ * prior to entering the blocking operation to have effect. The
	1079	+ * timeout must be > 0.
	1080	+ * A timeout of zero is interpreted as an infinite timeout.
	1081	+ * @param timeout the specified timeout, in milliseconds.
	1082	+ * @exception SocketException if there is an error
	1083	+ * in the underlying protocol, such as a TCP error.
	1084	+ * @since JDK 1.1
	1085	+ * @see #getSoTimeout()
	1086	+ */
	1087	+ public synchronized void setSoTimeout(int timeout) throws SocketException {
	1088	+ if (isClosed())
	1089	+ throw new SocketException("Socket is closed");
	1090	+ if (timeout < 0)
	1091	+ throw new IllegalArgumentException("timeout can't be negative");
	1092	+
	1093	+ getImpl().setOption(SocketOptions.SO_TIMEOUT, new Integer(timeout));
	1094	+ }
	1095	+
	1096	+ /**
	1097	+ * Returns setting for SO_TIMEOUT. 0 returns implies that the
	1098	+ * option is disabled (i.e., timeout of infinity).
	1099	+ * @return the setting for SO_TIMEOUT
	1100	+ * @exception SocketException if there is an error
	1101	+ * in the underlying protocol, such as a TCP error.
	1102	+ * @since JDK1.1
	1103	+ * @see #setSoTimeout(int)
	1104	+ */
	1105	+ public synchronized int getSoTimeout() throws SocketException {
	1106	+ if (isClosed())
	1107	+ throw new SocketException("Socket is closed");
	1108	+ Object o = getImpl().getOption(SocketOptions.SO_TIMEOUT);
	1109	+ /* extra type safety */
	1110	+ if (o instanceof Integer) {
	1111	+ return ((Integer) o).intValue();
	1112	+ } else {
	1113	+ return 0;
	1114	+ }
	1115	+ }
	1116	+
	1117	+ /**
	1118	+ * Sets the SO_SNDBUF option to the specified value for this
	1119	+ * <tt>Socket</tt>. The SO_SNDBUF option is used by the platform's
	1120	+ * networking code as a hint for the size to set
	1121	+ * the underlying network I/O buffers.
	1122	+ *
	1123	+ * <p>Because SO_SNDBUF is a hint, applications that want to
	1124	+ * verify what size the buffers were set to should call
	1125	+ * {@link #getSendBufferSize()}.
	1126	+ *
	1127	+ * @exception SocketException if there is an error
	1128	+ * in the underlying protocol, such as a TCP error.
	1129	+ *
	1130	+ * @param size the size to which to set the send buffer
	1131	+ * size. This value must be greater than 0.
	1132	+ *
	1133	+ * @exception IllegalArgumentException if the
	1134	+ * value is 0 or is negative.
	1135	+ *
	1136	+ * @see #getSendBufferSize()
	1137	+ * @since 1.2
	1138	+ */
	1139	+ public synchronized void setSendBufferSize(int size)
	1140	+ throws SocketException{
	1141	+ if (!(size > 0)) {
	1142	+ throw new IllegalArgumentException("negative send size");
	1143	+ }
	1144	+ if (isClosed())
	1145	+ throw new SocketException("Socket is closed");
	1146	+ getImpl().setOption(SocketOptions.SO_SNDBUF, new Integer(size));
	1147	+ }
	1148	+
	1149	+ /**
	1150	+ * Get value of the SO_SNDBUF option for this <tt>Socket</tt>,
	1151	+ * that is the buffer size used by the platform
	1152	+ * for output on this <tt>Socket</tt>.
	1153	+ * @return the value of the SO_SNDBUF option for this <tt>Socket</tt>.
	1154	+ *
	1155	+ * @exception SocketException if there is an error
	1156	+ * in the underlying protocol, such as a TCP error.
	1157	+ *
	1158	+ * @see #setSendBufferSize(int)
	1159	+ * @since 1.2
	1160	+ */
	1161	+ public synchronized int getSendBufferSize() throws SocketException {
	1162	+ if (isClosed())
	1163	+ throw new SocketException("Socket is closed");
	1164	+ int result = 0;
	1165	+ Object o = getImpl().getOption(SocketOptions.SO_SNDBUF);
	1166	+ if (o instanceof Integer) {
	1167	+ result = ((Integer)o).intValue();
	1168	+ }
	1169	+ return result;
	1170	+ }
	1171	+
	1172	+ /**
	1173	+ * Sets the SO_RCVBUF option to the specified value for this
	1174	+ * <tt>Socket</tt>. The SO_RCVBUF option is used by the platform's
	1175	+ * networking code as a hint for the size to set
	1176	+ * the underlying network I/O buffers.
	1177	+ *
	1178	+ * <p>Increasing the receive buffer size can increase the performance of
	1179	+ * network I/O for high-volume connection, while decreasing it can
	1180	+ * help reduce the backlog of incoming data.
	1181	+ *
	1182	+ * <p>Because SO_RCVBUF is a hint, applications that want to
	1183	+ * verify what size the buffers were set to should call
	1184	+ * {@link #getReceiveBufferSize()}.
	1185	+ *
	1186	+ * <p>The value of SO_RCVBUF is also used to set the TCP receive window
	1187	+ * that is advertized to the remote peer. Generally, the window size
	1188	+ * can be modified at any time when a socket is connected. However, if
	1189	+ * a receive window larger than 64K is required then this must be requested
	1190	+ * <B>before</B> the socket is connected to the remote peer. There are two
	1191	+ * cases to be aware of:<p>
	1192	+ * <ol>
	1193	+ * <li>For sockets accepted from a ServerSocket, this must be done by calling
	1194	+ * {@link ServerSocket#setReceiveBufferSize(int)} before the ServerSocket
	1195	+ * is bound to a local address.<p></li>
	1196	+ * <li>For client sockets, setReceiveBufferSize() must be called before
	1197	+ * connecting the socket to its remote peer.<p></li></ol>
	1198	+ * @param size the size to which to set the receive buffer
	1199	+ * size. This value must be greater than 0.
	1200	+ *
	1201	+ * @exception IllegalArgumentException if the value is 0 or is
	1202	+ * negative.
	1203	+ *
	1204	+ * @exception SocketException if there is an error
	1205	+ * in the underlying protocol, such as a TCP error.
	1206	+ *
	1207	+ * @see #getReceiveBufferSize()
	1208	+ * @see ServerSocket#setReceiveBufferSize(int)
	1209	+ * @since 1.2
	1210	+ */
	1211	+ public synchronized void setReceiveBufferSize(int size)
	1212	+ throws SocketException{
	1213	+ if (size <= 0) {
	1214	+ throw new IllegalArgumentException("invalid receive size");
	1215	+ }
	1216	+ if (isClosed())
	1217	+ throw new SocketException("Socket is closed");
	1218	+ getImpl().setOption(SocketOptions.SO_RCVBUF, new Integer(size));
	1219	+ }
	1220	+
	1221	+ /**
	1222	+ * Gets the value of the SO_RCVBUF option for this <tt>Socket</tt>,
	1223	+ * that is the buffer size used by the platform for
	1224	+ * input on this <tt>Socket</tt>.
	1225	+ *
	1226	+ * @return the value of the SO_RCVBUF option for this <tt>Socket</tt>.
	1227	+ * @exception SocketException if there is an error
	1228	+ * in the underlying protocol, such as a TCP error.
	1229	+ * @see #setReceiveBufferSize(int)
	1230	+ * @since 1.2
	1231	+ */
	1232	+ public synchronized int getReceiveBufferSize()
	1233	+ throws SocketException{
	1234	+ if (isClosed())
	1235	+ throw new SocketException("Socket is closed");
	1236	+ int result = 0;
	1237	+ Object o = getImpl().getOption(SocketOptions.SO_RCVBUF);
	1238	+ if (o instanceof Integer) {
	1239	+ result = ((Integer)o).intValue();
	1240	+ }
	1241	+ return result;
	1242	+ }
	1243	+
	1244	+ /**
	1245	+ * Enable/disable SO_KEEPALIVE.
	1246	+ *
	1247	+ * @param on whether or not to have socket keep alive turned on.
	1248	+ * @exception SocketException if there is an error
	1249	+ * in the underlying protocol, such as a TCP error.
	1250	+ * @since 1.3
	1251	+ * @see #getKeepAlive()
	1252	+ */
	1253	+ public void setKeepAlive(boolean on) throws SocketException {
	1254	+ if (isClosed())
	1255	+ throw new SocketException("Socket is closed");
	1256	+ getImpl().setOption(SocketOptions.SO_KEEPALIVE, Boolean.valueOf(on));
	1257	+ }
	1258	+
	1259	+ /**
	1260	+ * Tests if SO_KEEPALIVE is enabled.
	1261	+ *
	1262	+ * @return a <code>boolean</code> indicating whether or not SO_KEEPALIVE is enabled.
	1263	+ * @exception SocketException if there is an error
	1264	+ * in the underlying protocol, such as a TCP error.
	1265	+ * @since 1.3
	1266	+ * @see #setKeepAlive(boolean)
	1267	+ */
	1268	+ public boolean getKeepAlive() throws SocketException {
	1269	+ if (isClosed())
	1270	+ throw new SocketException("Socket is closed");
	1271	+ return ((Boolean) getImpl().getOption(SocketOptions.SO_KEEPALIVE)).booleanValue();
	1272	+ }
	1273	+
	1274	+ /**
	1275	+ * Sets traffic class or type-of-service octet in the IP
	1276	+ * header for packets sent from this Socket.
	1277	+ * As the underlying network implementation may ignore this
	1278	+ * value applications should consider it a hint.
	1279	+ *
	1280	+ * <P> The tc <B>must</B> be in the range <code> 0 <= tc <=
	1281	+ * 255</code> or an IllegalArgumentException will be thrown.
	1282	+ * <p>Notes:
	1283	+ * <p>For Internet Protocol v4 the value consists of an
	1284	+ * <code>integer</code>, the least significant 8 bits of which
	1285	+ * represent the value of the TOS octet in IP packets sent by
	1286	+ * the socket.
	1287	+ * RFC 1349 defines the TOS values as follows:
	1288	+ * <p>
	1289	+ * <UL>
	1290	+ * <LI><CODE>IPTOS_LOWCOST (0x02)</CODE></LI>
	1291	+ * <LI><CODE>IPTOS_RELIABILITY (0x04)</CODE></LI>
	1292	+ * <LI><CODE>IPTOS_THROUGHPUT (0x08)</CODE></LI>
	1293	+ * <LI><CODE>IPTOS_LOWDELAY (0x10)</CODE></LI>
	1294	+ * </UL>
	1295	+ * The last low order bit is always ignored as this
	1296	+ * corresponds to the MBZ (must be zero) bit.
	1297	+ * <p>
	1298	+ * Setting bits in the precedence field may result in a
	1299	+ * SocketException indicating that the operation is not
	1300	+ * permitted.
	1301	+ * <p>
	1302	+ * As RFC 1122 section 4.2.4.2 indicates, a compliant TCP
	1303	+ * implementation should, but is not required to, let application
	1304	+ * change the TOS field during the lifetime of a connection.
	1305	+ * So whether the type-of-service field can be changed after the
	1306	+ * TCP connection has been established depends on the implementation
	1307	+ * in the underlying platform. Applications should not assume that
	1308	+ * they can change the TOS field after the connection.
	1309	+ * <p>
	1310	+ * For Internet Protocol v6 <code>tc</code> is the value that
	1311	+ * would be placed into the sin6_flowinfo field of the IP header.
	1312	+ *
	1313	+ * @param tc an <code>int</code> value for the bitset.
	1314	+ * @throws SocketException if there is an error setting the
	1315	+ * traffic class or type-of-service
	1316	+ * @since 1.4
	1317	+ * @see #getTrafficClass
	1318	+ */
	1319	+ public void setTrafficClass(int tc) throws SocketException {
	1320	+ if (tc < 0 \|\| tc > 255)
	1321	+ throw new IllegalArgumentException("tc is not in range 0 -- 255");
	1322	+
	1323	+ if (isClosed())
	1324	+ throw new SocketException("Socket is closed");
	1325	+ getImpl().setOption(SocketOptions.IP_TOS, new Integer(tc));
	1326	+ }
	1327	+
	1328	+ /**
	1329	+ * Gets traffic class or type-of-service in the IP header
	1330	+ * for packets sent from this Socket
	1331	+ * <p>
	1332	+ * As the underlying network implementation may ignore the
	1333	+ * traffic class or type-of-service set using {@link #setTrafficClass(int)}
	1334	+ * this method may return a different value than was previously
	1335	+ * set using the {@link #setTrafficClass(int)} method on this Socket.
	1336	+ *
	1337	+ * @return the traffic class or type-of-service already set
	1338	+ * @throws SocketException if there is an error obtaining the
	1339	+ * traffic class or type-of-service value.
	1340	+ * @since 1.4
	1341	+ * @see #setTrafficClass(int)
	1342	+ */
	1343	+ public int getTrafficClass() throws SocketException {
	1344	+ return ((Integer) (getImpl().getOption(SocketOptions.IP_TOS))).intValue();
	1345	+ }
	1346	+
	1347	+ /**
	1348	+ * Enable/disable the SO_REUSEADDR socket option.
	1349	+ * <p>
	1350	+ * When a TCP connection is closed the connection may remain
	1351	+ * in a timeout state for a period of time after the connection
	1352	+ * is closed (typically known as the <tt>TIME_WAIT</tt> state
	1353	+ * or <tt>2MSL</tt> wait state).
	1354	+ * For applications using a well known socket address or port
	1355	+ * it may not be possible to bind a socket to the required
	1356	+ * <tt>SocketAddress</tt> if there is a connection in the
	1357	+ * timeout state involving the socket address or port.
	1358	+ * <p>
	1359	+ * Enabling <tt>SO_REUSEADDR</tt> prior to binding the socket
	1360	+ * using {@link #bind(SocketAddress)} allows the socket to be
	1361	+ * bound even though a previous connection is in a timeout
	1362	+ * state.
	1363	+ * <p>
	1364	+ * When a <tt>Socket</tt> is created the initial setting
	1365	+ * of <tt>SO_REUSEADDR</tt> is disabled.
	1366	+ * <p>
	1367	+ * The behaviour when <tt>SO_REUSEADDR</tt> is enabled or
	1368	+ * disabled after a socket is bound (See {@link #isBound()})
	1369	+ * is not defined.
	1370	+ *
	1371	+ * @param on whether to enable or disable the socket option
	1372	+ * @exception SocketException if an error occurs enabling or
	1373	+ * disabling the <tt>SO_RESUEADDR</tt> socket option,
	1374	+ * or the socket is closed.
	1375	+ * @since 1.4
	1376	+ * @see #getReuseAddress()
	1377	+ * @see #bind(SocketAddress)
	1378	+ * @see #isClosed()
	1379	+ * @see #isBound()
	1380	+ */
	1381	+ public void setReuseAddress(boolean on) throws SocketException {
	1382	+ if (isClosed())
	1383	+ throw new SocketException("Socket is closed");
	1384	+ getImpl().setOption(SocketOptions.SO_REUSEADDR, Boolean.valueOf(on));
	1385	+ }
	1386	+
	1387	+ /**
	1388	+ * Tests if SO_REUSEADDR is enabled.
	1389	+ *
	1390	+ * @return a <code>boolean</code> indicating whether or not SO_REUSEADDR is enabled.
	1391	+ * @exception SocketException if there is an error
	1392	+ * in the underlying protocol, such as a TCP error.
	1393	+ * @since 1.4
	1394	+ * @see #setReuseAddress(boolean)
	1395	+ */
	1396	+ public boolean getReuseAddress() throws SocketException {
	1397	+ if (isClosed())
	1398	+ throw new SocketException("Socket is closed");
	1399	+ return ((Boolean) (getImpl().getOption(SocketOptions.SO_REUSEADDR))).booleanValue();
	1400	+ }
	1401	+
	1402	+ /**
	1403	+ * Closes this socket.
	1404	+ * <p>
	1405	+ * Any thread currently blocked in an I/O operation upon this socket
	1406	+ * will throw a {@link SocketException}.
	1407	+ * <p>
	1408	+ * Once a socket has been closed, it is not available for further networking
	1409	+ * use (i.e. can't be reconnected or rebound). A new socket needs to be
	1410	+ * created.
	1411	+ *
	1412	+ * <p> Closing this socket will also close the socket's
	1413	+ * {@link java.io.InputStream InputStream} and
	1414	+ * {@link java.io.OutputStream OutputStream}.
	1415	+ *
	1416	+ * <p> If this socket has an associated channel then the channel is closed
	1417	+ * as well.
	1418	+ *
	1419	+ * @exception IOException if an I/O error occurs when closing this socket.
	1420	+ * @revised 1.4
	1421	+ * @spec JSR-51
	1422	+ * @see #isClosed
	1423	+ */
	1424	+ public synchronized void close() throws IOException {
	1425	+ synchronized(closeLock) {
	1426	+ if (isClosed())
	1427	+ return;
	1428	+ if (created)
	1429	+ impl.close();
	1430	+ closed = true;
	1431	+ }
	1432	+ }
	1433	+
	1434	+ /**
	1435	+ * Places the input stream for this socket at "end of stream".
	1436	+ * Any data sent to the input stream side of the socket is acknowledged
	1437	+ * and then silently discarded.
	1438	+ * <p>
	1439	+ * If you read from a socket input stream after invoking
	1440	+ * shutdownInput() on the socket, the stream will return EOF.
	1441	+ *
	1442	+ * @exception IOException if an I/O error occurs when shutting down this
	1443	+ * socket.
	1444	+ *
	1445	+ * @since 1.3
	1446	+ * @see java.net.Socket#shutdownOutput()
	1447	+ * @see java.net.Socket#close()
	1448	+ * @see java.net.Socket#setSoLinger(boolean, int)
	1449	+ * @see #isInputShutdown
	1450	+ */
	1451	+ public void shutdownInput() throws IOException
	1452	+ {
	1453	+ if (isClosed())
	1454	+ throw new SocketException("Socket is closed");
	1455	+ if (!isConnected())
	1456	+ throw new SocketException("Socket is not connected");
	1457	+ if (isInputShutdown())
	1458	+ throw new SocketException("Socket input is already shutdown");
	1459	+ getImpl().shutdownInput();
	1460	+ shutIn = true;
	1461	+ }
	1462	+
	1463	+ /**
	1464	+ * Disables the output stream for this socket.
	1465	+ * For a TCP socket, any previously written data will be sent
	1466	+ * followed by TCP's normal connection termination sequence.
	1467	+ *
	1468	+ * If you write to a socket output stream after invoking
	1469	+ * shutdownOutput() on the socket, the stream will throw
	1470	+ * an IOException.
	1471	+ *
	1472	+ * @exception IOException if an I/O error occurs when shutting down this
	1473	+ * socket.
	1474	+ *
	1475	+ * @since 1.3
	1476	+ * @see java.net.Socket#shutdownInput()
	1477	+ * @see java.net.Socket#close()
	1478	+ * @see java.net.Socket#setSoLinger(boolean, int)
	1479	+ * @see #isOutputShutdown
	1480	+ */
	1481	+ public void shutdownOutput() throws IOException
	1482	+ {
	1483	+ if (isClosed())
	1484	+ throw new SocketException("Socket is closed");
	1485	+ if (!isConnected())
	1486	+ throw new SocketException("Socket is not connected");
	1487	+ if (isOutputShutdown())
	1488	+ throw new SocketException("Socket output is already shutdown");
	1489	+ getImpl().shutdownOutput();
	1490	+ shutOut = true;
	1491	+ }
	1492	+
	1493	+ /**
	1494	+ * Converts this socket to a <code>String</code>.
	1495	+ *
	1496	+ * @return a string representation of this socket.
	1497	+ */
	1498	+ public String toString() {
	1499	+ try {
	1500	+ if (isConnected())
	1501	+ return "Socket[addr=" + getImpl().getInetAddress() +
	1502	+ ",port=" + getImpl().getPort() +
	1503	+ ",localport=" + getImpl().getLocalPort() + "]";
	1504	+ } catch (SocketException e) {
	1505	+ }
	1506	+ return "Socket[unconnected]";
	1507	+ }
	1508	+
	1509	+ /**
	1510	+ * Returns the connection state of the socket.
	1511	+ * <p>
	1512	+ * Note: Closing a socket doesn't clear its connection state, which means
	1513	+ * this method will return <code>true</code> for a closed socket
	1514	+ * (see {@link #isClosed()}) if it was successfuly connected prior
	1515	+ * to being closed.
	1516	+ *
	1517	+ * @return true if the socket was successfuly connected to a server
	1518	+ * @since 1.4
	1519	+ */
	1520	+ public boolean isConnected() {
	1521	+ // Before 1.3 Sockets were always connected during creation
	1522	+ return connected \|\| oldImpl;
	1523	+ }
	1524	+
	1525	+ /**
	1526	+ * Returns the binding state of the socket.
	1527	+ * <p>
	1528	+ * Note: Closing a socket doesn't clear its binding state, which means
	1529	+ * this method will return <code>true</code> for a closed socket
	1530	+ * (see {@link #isClosed()}) if it was successfuly bound prior
	1531	+ * to being closed.
	1532	+ *
	1533	+ * @return true if the socket was successfuly bound to an address
	1534	+ * @since 1.4
	1535	+ * @see #bind
	1536	+ */
	1537	+ public boolean isBound() {
	1538	+ // Before 1.3 Sockets were always bound during creation
	1539	+ return bound \|\| oldImpl;
	1540	+ }
	1541	+
	1542	+ /**
	1543	+ * Returns the closed state of the socket.
	1544	+ *
	1545	+ * @return true if the socket has been closed
	1546	+ * @since 1.4
	1547	+ * @see #close
	1548	+ */
	1549	+ public boolean isClosed() {
	1550	+ synchronized(closeLock) {
	1551	+ return closed;
	1552	+ }
	1553	+ }
	1554	+
	1555	+ /**
	1556	+ * Returns whether the read-half of the socket connection is closed.
	1557	+ *
	1558	+ * @return true if the input of the socket has been shutdown
	1559	+ * @since 1.4
	1560	+ * @see #shutdownInput
	1561	+ */
	1562	+ public boolean isInputShutdown() {
	1563	+ return shutIn;
	1564	+ }
	1565	+
	1566	+ /**
	1567	+ * Returns whether the write-half of the socket connection is closed.
	1568	+ *
	1569	+ * @return true if the output of the socket has been shutdown
	1570	+ * @since 1.4
	1571	+ * @see #shutdownOutput
	1572	+ */
	1573	+ public boolean isOutputShutdown() {
	1574	+ return shutOut;
	1575	+ }
	1576	+
	1577	+ /**
	1578	+ * The factory for all client sockets.
	1579	+ */
	1580	+ private static SocketImplFactory factory = null;
	1581	+
	1582	+ /**
	1583	+ * Sets the client socket implementation factory for the
	1584	+ * application. The factory can be specified only once.
	1585	+ * <p>
	1586	+ * When an application creates a new client socket, the socket
	1587	+ * implementation factory's <code>createSocketImpl</code> method is
	1588	+ * called to create the actual socket implementation.
	1589	+ * <p>
	1590	+ * Passing <code>null</code> to the method is a no-op unless the factory
	1591	+ * was already set.
	1592	+ * <p>If there is a security manager, this method first calls
	1593	+ * the security manager's <code>checkSetFactory</code> method
	1594	+ * to ensure the operation is allowed.
	1595	+ * This could result in a SecurityException.
	1596	+ *
	1597	+ * @param fac the desired factory.
	1598	+ * @exception IOException if an I/O error occurs when setting the
	1599	+ * socket factory.
	1600	+ * @exception SocketException if the factory is already defined.
	1601	+ * @exception SecurityException if a security manager exists and its
	1602	+ * <code>checkSetFactory</code> method doesn't allow the operation.
	1603	+ * @see java.net.SocketImplFactory#createSocketImpl()
	1604	+ * @see SecurityManager#checkSetFactory
	1605	+ */
	1606	+ public static synchronized void setSocketImplFactory(SocketImplFactory fac)
	1607	+ throws IOException
	1608	+ {
	1609	+ if (factory != null) {
	1610	+ throw new SocketException("factory already defined");
	1611	+ }
	1612	+ SecurityManager security = System.getSecurityManager();
	1613	+ if (security != null) {
	1614	+ security.checkSetFactory();
	1615	+ }
	1616	+ factory = fac;
	1617	+ }
	1618	+
	1619	+ /**
	1620	+ * Sets performance preferences for this socket.
	1621	+ *
	1622	+ * <p> Sockets use the TCP/IP protocol by default. Some implementations
	1623	+ * may offer alternative protocols which have different performance
	1624	+ * characteristics than TCP/IP. This method allows the application to
	1625	+ * express its own preferences as to how these tradeoffs should be made
	1626	+ * when the implementation chooses from the available protocols.
	1627	+ *
	1628	+ * <p> Performance preferences are described by three integers
	1629	+ * whose values indicate the relative importance of short connection time,
	1630	+ * low latency, and high bandwidth. The absolute values of the integers
	1631	+ * are irrelevant; in order to choose a protocol the values are simply
	1632	+ * compared, with larger values indicating stronger preferences. Negative
	1633	+ * values represent a lower priority than positive values. If the
	1634	+ * application prefers short connection time over both low latency and high
	1635	+ * bandwidth, for example, then it could invoke this method with the values
	1636	+ * <tt>(1, 0, 0)</tt>. If the application prefers high bandwidth above low
	1637	+ * latency, and low latency above short connection time, then it could
	1638	+ * invoke this method with the values <tt>(0, 1, 2)</tt>.
	1639	+ *
	1640	+ * <p> Invoking this method after this socket has been connected
	1641	+ * will have no effect.
	1642	+ *
	1643	+ * @param connectionTime
	1644	+ * An <tt>int</tt> expressing the relative importance of a short
	1645	+ * connection time
	1646	+ *
	1647	+ * @param latency
	1648	+ * An <tt>int</tt> expressing the relative importance of low
	1649	+ * latency
	1650	+ *
	1651	+ * @param bandwidth
	1652	+ * An <tt>int</tt> expressing the relative importance of high
	1653	+ * bandwidth
	1654	+ *
	1655	+ * @since 1.5
	1656	+ */
	1657	+ public void setPerformancePreferences(int connectionTime,
	1658	+ int latency,
	1659	+ int bandwidth)
	1660	+ {
	1661	+ /* Not implemented yet */
	1662	+ }
	1663	+}

java/pkg/java/net/SocketAddress.class+0−0

Binary file not shown.

java/pkg/java/net/SocketAddress.java+42−0

@@ -0,0 +1,42 @@
	1	+/*
	2	+ * Copyright (c) 2000, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+package java.net;
	26	+
	27	+
	28	+/**
	29	+ *
	30	+ * This class represents a Socket Address with no protocol attachment.
	31	+ * As an abstract class, it is meant to be subclassed with a specific,
	32	+ * protocol dependent, implementation.
	33	+ * <p>
	34	+ * It provides an immutable object used by sockets for binding, connecting, or
	35	+ * as returned values.
	36	+ *
	37	+ * @see java.net.Socket
	38	+ * @see java.net.ServerSocket
	39	+ * @since 1.4
	40	+ */
	41	+public abstract class SocketAddress implements java.io.Serializable {
	42	+}

java/pkg/java/net/SocketException.class+0−0

Binary file not shown.

java/pkg/java/net/SocketException.java+55−0

@@ -0,0 +1,55 @@
	1	+/*
	2	+ * Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.io.IOException;
	29	+
	30	+/**
	31	+ * Thrown to indicate that there is an error creating or accessing a Socket.
	32	+ *
	33	+ * @author Jonathan Payne
	34	+ * @since JDK1.0
	35	+ */
	36	+public
	37	+class SocketException extends IOException {
	38	+ private static final long serialVersionUID = -5935874303556886934L;
	39	+
	40	+ /**
	41	+ * Constructs a new <code>SocketException</code> with the
	42	+ * specified detail message.
	43	+ *
	44	+ * @param msg the detail message.
	45	+ */
	46	+ public SocketException(String msg) {
	47	+ super(msg);
	48	+ }
	49	+
	50	+ /**
	51	+ * Constructs a new <code>SocketException</code> with no detail message.
	52	+ */
	53	+ public SocketException() {
	54	+ }
	55	+}

java/pkg/java/net/SocketImpl.class+0−0

Binary file not shown.

java/pkg/java/net/SocketImpl.java+357−0

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

java/pkg/java/net/SocketImplFactory.class+0−0

Binary file not shown.

java/pkg/java/net/SocketImplFactory.java+48−0

@@ -0,0 +1,48 @@
	1	+/*
	2	+ * Copyright (c) 1995, 1999, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+/**
	29	+ * This interface defines a factory for socket implementations. It
	30	+ * is used by the classes <code>Socket</code> and
	31	+ * <code>ServerSocket</code> to create actual socket
	32	+ * implementations.
	33	+ *
	34	+ * @author Arthur van Hoff
	35	+ * @see java.net.Socket
	36	+ * @see java.net.ServerSocket
	37	+ * @since JDK1.0
	38	+ */
	39	+public
	40	+interface SocketImplFactory {
	41	+ /**
	42	+ * Creates a new <code>SocketImpl</code> instance.
	43	+ *
	44	+ * @return a new instance of <code>SocketImpl</code>.
	45	+ * @see java.net.SocketImpl
	46	+ */
	47	+ SocketImpl createSocketImpl();
	48	+}

java/pkg/java/net/SocketInputStream.class+0−0

Binary file not shown.

java/pkg/java/net/SocketInputStream.java+271−0

@@ -0,0 +1,271 @@
	1	+/*
	2	+ * Copyright (c) 1995, 2010, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.io.FileDescriptor;
	29	+import java.io.FileInputStream;
	30	+import java.io.IOException;
	31	+import java.nio.channels.FileChannel;
	32	+
	33	+import sun.net.ConnectionResetException;
	34	+
	35	+/**
	36	+ * This stream extends FileInputStream to implement a
	37	+ * SocketInputStream. Note that this class should <b>NOT</b> be
	38	+ * public.
	39	+ *
	40	+ * @author Jonathan Payne
	41	+ * @author Arthur van Hoff
	42	+ */
	43	+class SocketInputStream extends FileInputStream
	44	+{
	45	+ static {
	46	+ init();
	47	+ }
	48	+
	49	+ private boolean eof;
	50	+ private AbstractPlainSocketImpl impl = null;
	51	+ private byte temp[];
	52	+ private Socket socket = null;
	53	+
	54	+ /**
	55	+ * Creates a new SocketInputStream. Can only be called
	56	+ * by a Socket. This method needs to hang on to the owner Socket so
	57	+ * that the fd will not be closed.
	58	+ * @param impl the implemented socket input stream
	59	+ */
	60	+ SocketInputStream(AbstractPlainSocketImpl impl) throws IOException {
	61	+ super(impl.getFileDescriptor());
	62	+ this.impl = impl;
	63	+ socket = impl.getSocket();
	64	+ }
	65	+
	66	+ /**
	67	+ * Returns the unique {@link java.nio.channels.FileChannel FileChannel}
	68	+ * object associated with this file input stream.</p>
	69	+ *
	70	+ * The <code>getChannel</code> method of <code>SocketInputStream</code>
	71	+ * returns <code>null</code> since it is a socket based stream.</p>
	72	+ *
	73	+ * @return the file channel associated with this file input stream
	74	+ *
	75	+ * @since 1.4
	76	+ * @spec JSR-51
	77	+ */
	78	+ public final FileChannel getChannel() {
	79	+ return null;
	80	+ }
	81	+
	82	+ /**
	83	+ * Reads into an array of bytes at the specified offset using
	84	+ * the received socket primitive.
	85	+ * @param fd the FileDescriptor
	86	+ * @param b the buffer into which the data is read
	87	+ * @param off the start offset of the data
	88	+ * @param len the maximum number of bytes read
	89	+ * @param timeout the read timeout in ms
	90	+ * @return the actual number of bytes read, -1 is
	91	+ * returned when the end of the stream is reached.
	92	+ * @exception IOException If an I/O error has occurred.
	93	+ */
	94	+ private native int socketRead0(FileDescriptor fd,
	95	+ byte b[], int off, int len,
	96	+ int timeout)
	97	+ throws IOException;
	98	+
	99	+ /**
	100	+ * Reads into a byte array data from the socket.
	101	+ * @param b the buffer into which the data is read
	102	+ * @return the actual number of bytes read, -1 is
	103	+ * returned when the end of the stream is reached.
	104	+ * @exception IOException If an I/O error has occurred.
	105	+ */
	106	+ public int read(byte b[]) throws IOException {
	107	+ return read(b, 0, b.length);
	108	+ }
	109	+
	110	+ /**
	111	+ * Reads into a byte array <i>b</i> at offset <i>off</i>,
	112	+ * <i>length</i> bytes of data.
	113	+ * @param b the buffer into which the data is read
	114	+ * @param off the start offset of the data
	115	+ * @param len the maximum number of bytes read
	116	+ * @return the actual number of bytes read, -1 is
	117	+ * returned when the end of the stream is reached.
	118	+ * @exception IOException If an I/O error has occurred.
	119	+ */
	120	+ public int read(byte b[], int off, int length) throws IOException {
	121	+ return read(b, off, length, impl.getTimeout());
	122	+ }
	123	+
	124	+ int read(byte b[], int off, int length, int timeout) throws IOException {
	125	+ int n;
	126	+
	127	+ // EOF already encountered
	128	+ if (eof) {
	129	+ return -1;
	130	+ }
	131	+
	132	+ // connection reset
	133	+ if (impl.isConnectionReset()) {
	134	+ throw new SocketException("Connection reset");
	135	+ }
	136	+
	137	+ // bounds check
	138	+ if (length <= 0 \|\| off < 0 \|\| off + length > b.length) {
	139	+ if (length == 0) {
	140	+ return 0;
	141	+ }
	142	+ throw new ArrayIndexOutOfBoundsException();
	143	+ }
	144	+
	145	+ boolean gotReset = false;
	146	+
	147	+ // acquire file descriptor and do the read
	148	+ FileDescriptor fd = impl.acquireFD();
	149	+ try {
	150	+ n = socketRead0(fd, b, off, length, timeout);
	151	+ if (n > 0) {
	152	+ return n;
	153	+ }
	154	+ } catch (ConnectionResetException rstExc) {
	155	+ gotReset = true;
	156	+ } finally {
	157	+ impl.releaseFD();
	158	+ }
	159	+
	160	+ /*
	161	+ * We receive a "connection reset" but there may be bytes still
	162	+ * buffered on the socket
	163	+ */
	164	+ if (gotReset) {
	165	+ impl.setConnectionResetPending();
	166	+ impl.acquireFD();
	167	+ try {
	168	+ n = socketRead0(fd, b, off, length, timeout);
	169	+ if (n > 0) {
	170	+ return n;
	171	+ }
	172	+ } catch (ConnectionResetException rstExc) {
	173	+ } finally {
	174	+ impl.releaseFD();
	175	+ }
	176	+ }
	177	+
	178	+ /*
	179	+ * If we get here we are at EOF, the socket has been closed,
	180	+ * or the connection has been reset.
	181	+ */
	182	+ if (impl.isClosedOrPending()) {
	183	+ throw new SocketException("Socket closed");
	184	+ }
	185	+ if (impl.isConnectionResetPending()) {
	186	+ impl.setConnectionReset();
	187	+ }
	188	+ if (impl.isConnectionReset()) {
	189	+ throw new SocketException("Connection reset");
	190	+ }
	191	+ eof = true;
	192	+ return -1;
	193	+ }
	194	+
	195	+ /**
	196	+ * Reads a single byte from the socket.
	197	+ */
	198	+ public int read() throws IOException {
	199	+ if (eof) {
	200	+ return -1;
	201	+ }
	202	+ temp = new byte[1];
	203	+ int n = read(temp, 0, 1);
	204	+ if (n <= 0) {
	205	+ return -1;
	206	+ }
	207	+ return temp[0] & 0xff;
	208	+ }
	209	+
	210	+ /**
	211	+ * Skips n bytes of input.
	212	+ * @param n the number of bytes to skip
	213	+ * @return the actual number of bytes skipped.
	214	+ * @exception IOException If an I/O error has occurred.
	215	+ */
	216	+ public long skip(long numbytes) throws IOException {
	217	+ if (numbytes <= 0) {
	218	+ return 0;
	219	+ }
	220	+ long n = numbytes;
	221	+ int buflen = (int) Math.min(1024, n);
	222	+ byte data[] = new byte[buflen];
	223	+ while (n > 0) {
	224	+ int r = read(data, 0, (int) Math.min((long) buflen, n));
	225	+ if (r < 0) {
	226	+ break;
	227	+ }
	228	+ n -= r;
	229	+ }
	230	+ return numbytes - n;
	231	+ }
	232	+
	233	+ /**
	234	+ * Returns the number of bytes that can be read without blocking.
	235	+ * @return the number of immediately available bytes
	236	+ */
	237	+ public int available() throws IOException {
	238	+ return impl.available();
	239	+ }
	240	+
	241	+ /**
	242	+ * Closes the stream.
	243	+ */
	244	+ private boolean closing = false;
	245	+ public void close() throws IOException {
	246	+ // Prevent recursion. See BugId 4484411
	247	+ if (closing)
	248	+ return;
	249	+ closing = true;
	250	+ if (socket != null) {
	251	+ if (!socket.isClosed())
	252	+ socket.close();
	253	+ } else
	254	+ impl.close();
	255	+ closing = false;
	256	+ }
	257	+
	258	+ void setEOF(boolean eof) {
	259	+ this.eof = eof;
	260	+ }
	261	+
	262	+ /**
	263	+ * Overrides finalize, the fd is closed by the Socket.
	264	+ */
	265	+ protected void finalize() {}
	266	+
	267	+ /**
	268	+ * Perform class load-time initializations.
	269	+ */
	270	+ private native static void init();
	271	+}

java/pkg/java/net/SocketOption.class+0−0

Binary file not shown.

java/pkg/java/net/SocketOption.java+55−0

@@ -0,0 +1,55 @@
	1	+/*
	2	+ * Copyright (c) 2007, 2008, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+/**
	29	+ * A socket option associated with a socket.
	30	+ *
	31	+ * <p> In the {@link java.nio.channels channels} package, the {@link
	32	+ * java.nio.channels.NetworkChannel} interface defines the {@link
	33	+ * java.nio.channels.NetworkChannel#setOption(SocketOption,Object) setOption}
	34	+ * and {@link java.nio.channels.NetworkChannel#getOption(SocketOption) getOption}
	35	+ * methods to set and query the channel's socket options.
	36	+ *
	37	+ * @param <T> The type of the socket option value.
	38	+ *
	39	+ * @since 1.7
	40	+ *
	41	+ * @see StandardSocketOptions
	42	+ */
	43	+
	44	+public interface SocketOption<T> {
	45	+
	46	+ /**
	47	+ * Returns the name of the socket option.
	48	+ */
	49	+ String name();
	50	+
	51	+ /**
	52	+ * Returns the type of the socket option value.
	53	+ */
	54	+ Class<T> type();
	55	+}

java/pkg/java/net/SocketOptions.class+0−0

Binary file not shown.

java/pkg/java/net/SocketOptions.java+329−0

@@ -0,0 +1,329 @@
	1	+/*
	2	+ * Copyright (c) 1996, 2006, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+/**
	29	+ * Interface of methods to get/set socket options. This interface is
	30	+ * implemented by: <B>SocketImpl</B> and <B>DatagramSocketImpl</B>.
	31	+ * Subclasses of these should override the methods
	32	+ * of this interface in order to support their own options.
	33	+ * <P>
	34	+ * The methods and constants which specify options in this interface are
	35	+ * for implementation only. If you're not subclassing SocketImpl or
	36	+ * DatagramSocketImpl, <B>you won't use these directly.</B> There are
	37	+ * type-safe methods to get/set each of these options in Socket, ServerSocket,
	38	+ * DatagramSocket and MulticastSocket.
	39	+ * <P>
	40	+ * @author David Brown
	41	+ */
	42	+
	43	+
	44	+public interface SocketOptions {
	45	+
	46	+ /**
	47	+ * Enable/disable the option specified by <I>optID</I>. If the option
	48	+ * is to be enabled, and it takes an option-specific "value", this is
	49	+ * passed in <I>value</I>. The actual type of value is option-specific,
	50	+ * and it is an error to pass something that isn't of the expected type:
	51	+ * <BR><PRE>
	52	+ * SocketImpl s;
	53	+ * ...
	54	+ * s.setOption(SO_LINGER, new Integer(10));
	55	+ * // OK - set SO_LINGER w/ timeout of 10 sec.
	56	+ * s.setOption(SO_LINGER, new Double(10));
	57	+ * // ERROR - expects java.lang.Integer
	58	+ *</PRE>
	59	+ * If the requested option is binary, it can be set using this method by
	60	+ * a java.lang.Boolean:
	61	+ * <BR><PRE>
	62	+ * s.setOption(TCP_NODELAY, new Boolean(true));
	63	+ * // OK - enables TCP_NODELAY, a binary option
	64	+ * </PRE>
	65	+ * <BR>
	66	+ * Any option can be disabled using this method with a Boolean(false):
	67	+ * <BR><PRE>
	68	+ * s.setOption(TCP_NODELAY, new Boolean(false));
	69	+ * // OK - disables TCP_NODELAY
	70	+ * s.setOption(SO_LINGER, new Boolean(false));
	71	+ * // OK - disables SO_LINGER
	72	+ * </PRE>
	73	+ * <BR>
	74	+ * For an option that has a notion of on and off, and requires
	75	+ * a non-boolean parameter, setting its value to anything other than
	76	+ * <I>Boolean(false)</I> implicitly enables it.
	77	+ * <BR>
	78	+ * Throws SocketException if the option is unrecognized,
	79	+ * the socket is closed, or some low-level error occurred
	80	+ * <BR>
	81	+ * @param optID identifies the option
	82	+ * @param value the parameter of the socket option
	83	+ * @throws SocketException if the option is unrecognized,
	84	+ * the socket is closed, or some low-level error occurred
	85	+ * @see #getOption(int)
	86	+ */
	87	+ public void
	88	+ setOption(int optID, Object value) throws SocketException;
	89	+
	90	+ /**
	91	+ * Fetch the value of an option.
	92	+ * Binary options will return java.lang.Boolean(true)
	93	+ * if enabled, java.lang.Boolean(false) if disabled, e.g.:
	94	+ * <BR><PRE>
	95	+ * SocketImpl s;
	96	+ * ...
	97	+ * Boolean noDelay = (Boolean)(s.getOption(TCP_NODELAY));
	98	+ * if (noDelay.booleanValue()) {
	99	+ * // true if TCP_NODELAY is enabled...
	100	+ * ...
	101	+ * }
	102	+ * </PRE>
	103	+ * <P>
	104	+ * For options that take a particular type as a parameter,
	105	+ * getOption(int) will return the parameter's value, else
	106	+ * it will return java.lang.Boolean(false):
	107	+ * <PRE>
	108	+ * Object o = s.getOption(SO_LINGER);
	109	+ * if (o instanceof Integer) {
	110	+ * System.out.print("Linger time is " + ((Integer)o).intValue());
	111	+ * } else {
	112	+ * // the true type of o is java.lang.Boolean(false);
	113	+ * }
	114	+ * </PRE>
	115	+ *
	116	+ * @param optID an <code>int</code> identifying the option to fetch
	117	+ * @return the value of the option
	118	+ * @throws SocketException if the socket is closed
	119	+ * @throws SocketException if <I>optID</I> is unknown along the
	120	+ * protocol stack (including the SocketImpl)
	121	+ * @see #setOption(int, java.lang.Object)
	122	+ */
	123	+ public Object getOption(int optID) throws SocketException;
	124	+
	125	+ /**
	126	+ * The java-supported BSD-style options.
	127	+ */
	128	+
	129	+ /**
	130	+ * Disable Nagle's algorithm for this connection. Written data
	131	+ * to the network is not buffered pending acknowledgement of
	132	+ * previously written data.
	133	+ *<P>
	134	+ * Valid for TCP only: SocketImpl.
	135	+ * <P>
	136	+ * @see Socket#setTcpNoDelay
	137	+ * @see Socket#getTcpNoDelay
	138	+ */
	139	+
	140	+ public final static int TCP_NODELAY = 0x0001;
	141	+
	142	+ /**
	143	+ * Fetch the local address binding of a socket (this option cannot
	144	+ * be "set" only "gotten", since sockets are bound at creation time,
	145	+ * and so the locally bound address cannot be changed). The default local
	146	+ * address of a socket is INADDR_ANY, meaning any local address on a
	147	+ * multi-homed host. A multi-homed host can use this option to accept
	148	+ * connections to only one of its addresses (in the case of a
	149	+ * ServerSocket or DatagramSocket), or to specify its return address
	150	+ * to the peer (for a Socket or DatagramSocket). The parameter of
	151	+ * this option is an InetAddress.
	152	+ * <P>
	153	+ * This option <B>must</B> be specified in the constructor.
	154	+ * <P>
	155	+ * Valid for: SocketImpl, DatagramSocketImpl
	156	+ * <P>
	157	+ * @see Socket#getLocalAddress
	158	+ * @see DatagramSocket#getLocalAddress
	159	+ */
	160	+
	161	+ public final static int SO_BINDADDR = 0x000F;
	162	+
	163	+ /** Sets SO_REUSEADDR for a socket. This is used only for MulticastSockets
	164	+ * in java, and it is set by default for MulticastSockets.
	165	+ * <P>
	166	+ * Valid for: DatagramSocketImpl
	167	+ */
	168	+
	169	+ public final static int SO_REUSEADDR = 0x04;
	170	+
	171	+ /**
	172	+ * Sets SO_BROADCAST for a socket. This option enables and disables
	173	+ * the ability of the process to send broadcast messages. It is supported
	174	+ * for only datagram sockets and only on networks that support
	175	+ * the concept of a broadcast message (e.g. Ethernet, token ring, etc.),
	176	+ * and it is set by default for DatagramSockets.
	177	+ * @since 1.4
	178	+ */
	179	+
	180	+ public final static int SO_BROADCAST = 0x0020;
	181	+
	182	+ /** Set which outgoing interface on which to send multicast packets.
	183	+ * Useful on hosts with multiple network interfaces, where applications
	184	+ * want to use other than the system default. Takes/returns an InetAddress.
	185	+ * <P>
	186	+ * Valid for Multicast: DatagramSocketImpl
	187	+ * <P>
	188	+ * @see MulticastSocket#setInterface(InetAddress)
	189	+ * @see MulticastSocket#getInterface()
	190	+ */
	191	+
	192	+ public final static int IP_MULTICAST_IF = 0x10;
	193	+
	194	+ /** Same as above. This option is introduced so that the behaviour
	195	+ * with IP_MULTICAST_IF will be kept the same as before, while
	196	+ * this new option can support setting outgoing interfaces with either
	197	+ * IPv4 and IPv6 addresses.
	198	+ *
	199	+ * NOTE: make sure there is no conflict with this
	200	+ * @see MulticastSocket#setNetworkInterface(NetworkInterface)
	201	+ * @see MulticastSocket#getNetworkInterface()
	202	+ * @since 1.4
	203	+ */
	204	+ public final static int IP_MULTICAST_IF2 = 0x1f;
	205	+
	206	+ /**
	207	+ * This option enables or disables local loopback of multicast datagrams.
	208	+ * This option is enabled by default for Multicast Sockets.
	209	+ * @since 1.4
	210	+ */
	211	+
	212	+ public final static int IP_MULTICAST_LOOP = 0x12;
	213	+
	214	+ /**
	215	+ * This option sets the type-of-service or traffic class field
	216	+ * in the IP header for a TCP or UDP socket.
	217	+ * @since 1.4
	218	+ */
	219	+
	220	+ public final static int IP_TOS = 0x3;
	221	+
	222	+ /**
	223	+ * Specify a linger-on-close timeout. This option disables/enables
	224	+ * immediate return from a <B>close()</B> of a TCP Socket. Enabling
	225	+ * this option with a non-zero Integer <I>timeout</I> means that a
	226	+ * <B>close()</B> will block pending the transmission and acknowledgement
	227	+ * of all data written to the peer, at which point the socket is closed
	228	+ * <I>gracefully</I>. Upon reaching the linger timeout, the socket is
	229	+ * closed <I>forcefully</I>, with a TCP RST. Enabling the option with a
	230	+ * timeout of zero does a forceful close immediately. If the specified
	231	+ * timeout value exceeds 65,535 it will be reduced to 65,535.
	232	+ * <P>
	233	+ * Valid only for TCP: SocketImpl
	234	+ *
	235	+ * @see Socket#setSoLinger
	236	+ * @see Socket#getSoLinger
	237	+ */
	238	+ public final static int SO_LINGER = 0x0080;
	239	+
	240	+ /** Set a timeout on blocking Socket operations:
	241	+ * <PRE>
	242	+ * ServerSocket.accept();
	243	+ * SocketInputStream.read();
	244	+ * DatagramSocket.receive();
	245	+ * </PRE>
	246	+ *
	247	+ * <P> The option must be set prior to entering a blocking
	248	+ * operation to take effect. If the timeout expires and the
	249	+ * operation would continue to block,
	250	+ * <B>java.io.InterruptedIOException</B> is raised. The Socket is
	251	+ * not closed in this case.
	252	+ *
	253	+ * <P> Valid for all sockets: SocketImpl, DatagramSocketImpl
	254	+ *
	255	+ * @see Socket#setSoTimeout
	256	+ * @see ServerSocket#setSoTimeout
	257	+ * @see DatagramSocket#setSoTimeout
	258	+ */
	259	+ public final static int SO_TIMEOUT = 0x1006;
	260	+
	261	+ /**
	262	+ * Set a hint the size of the underlying buffers used by the
	263	+ * platform for outgoing network I/O. When used in set, this is a
	264	+ * suggestion to the kernel from the application about the size of
	265	+ * buffers to use for the data to be sent over the socket. When
	266	+ * used in get, this must return the size of the buffer actually
	267	+ * used by the platform when sending out data on this socket.
	268	+ *
	269	+ * Valid for all sockets: SocketImpl, DatagramSocketImpl
	270	+ *
	271	+ * @see Socket#setSendBufferSize
	272	+ * @see Socket#getSendBufferSize
	273	+ * @see DatagramSocket#setSendBufferSize
	274	+ * @see DatagramSocket#getSendBufferSize
	275	+ */
	276	+ public final static int SO_SNDBUF = 0x1001;
	277	+
	278	+ /**
	279	+ * Set a hint the size of the underlying buffers used by the
	280	+ * platform for incoming network I/O. When used in set, this is a
	281	+ * suggestion to the kernel from the application about the size of
	282	+ * buffers to use for the data to be received over the
	283	+ * socket. When used in get, this must return the size of the
	284	+ * buffer actually used by the platform when receiving in data on
	285	+ * this socket.
	286	+ *
	287	+ * Valid for all sockets: SocketImpl, DatagramSocketImpl
	288	+ *
	289	+ * @see Socket#setReceiveBufferSize
	290	+ * @see Socket#getReceiveBufferSize
	291	+ * @see DatagramSocket#setReceiveBufferSize
	292	+ * @see DatagramSocket#getReceiveBufferSize
	293	+ */
	294	+ public final static int SO_RCVBUF = 0x1002;
	295	+
	296	+ /**
	297	+ * When the keepalive option is set for a TCP socket and no data
	298	+ * has been exchanged across the socket in either direction for
	299	+ * 2 hours (NOTE: the actual value is implementation dependent),
	300	+ * TCP automatically sends a keepalive probe to the peer. This probe is a
	301	+ * TCP segment to which the peer must respond.
	302	+ * One of three responses is expected:
	303	+ * 1. The peer responds with the expected ACK. The application is not
	304	+ * notified (since everything is OK). TCP will send another probe
	305	+ * following another 2 hours of inactivity.
	306	+ * 2. The peer responds with an RST, which tells the local TCP that
	307	+ * the peer host has crashed and rebooted. The socket is closed.
	308	+ * 3. There is no response from the peer. The socket is closed.
	309	+ *
	310	+ * The purpose of this option is to detect if the peer host crashes.
	311	+ *
	312	+ * Valid only for TCP socket: SocketImpl
	313	+ *
	314	+ * @see Socket#setKeepAlive
	315	+ * @see Socket#getKeepAlive
	316	+ */
	317	+ public final static int SO_KEEPALIVE = 0x0008;
	318	+
	319	+ /**
	320	+ * When the OOBINLINE option is set, any TCP urgent data received on
	321	+ * the socket will be received through the socket input stream.
	322	+ * When the option is disabled (which is the default) urgent data
	323	+ * is silently discarded.
	324	+ *
	325	+ * @see Socket#setOOBInline
	326	+ * @see Socket#getOOBInline
	327	+ */
	328	+ public final static int SO_OOBINLINE = 0x1003;
	329	+}

java/pkg/java/net/SocketOutputStream.class+0−0

Binary file not shown.

java/pkg/java/net/SocketOutputStream.java+183−0

@@ -0,0 +1,183 @@
	1	+/*
	2	+ * Copyright (c) 1995, 2007, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.io.FileDescriptor;
	29	+import java.io.FileOutputStream;
	30	+import java.io.IOException;
	31	+import java.nio.channels.FileChannel;
	32	+
	33	+/**
	34	+ * This stream extends FileOutputStream to implement a
	35	+ * SocketOutputStream. Note that this class should <b>NOT</b> be
	36	+ * public.
	37	+ *
	38	+ * @author Jonathan Payne
	39	+ * @author Arthur van Hoff
	40	+ */
	41	+class SocketOutputStream extends FileOutputStream
	42	+{
	43	+ static {
	44	+ init();
	45	+ }
	46	+
	47	+ private AbstractPlainSocketImpl impl = null;
	48	+ private byte temp[] = new byte[1];
	49	+ private Socket socket = null;
	50	+
	51	+ /**
	52	+ * Creates a new SocketOutputStream. Can only be called
	53	+ * by a Socket. This method needs to hang on to the owner Socket so
	54	+ * that the fd will not be closed.
	55	+ * @param impl the socket output stream inplemented
	56	+ */
	57	+ SocketOutputStream(AbstractPlainSocketImpl impl) throws IOException {
	58	+ super(impl.getFileDescriptor());
	59	+ this.impl = impl;
	60	+ socket = impl.getSocket();
	61	+ }
	62	+
	63	+ /**
	64	+ * Returns the unique {@link java.nio.channels.FileChannel FileChannel}
	65	+ * object associated with this file output stream. </p>
	66	+ *
	67	+ * The <code>getChannel</code> method of <code>SocketOutputStream</code>
	68	+ * returns <code>null</code> since it is a socket based stream.</p>
	69	+ *
	70	+ * @return the file channel associated with this file output stream
	71	+ *
	72	+ * @since 1.4
	73	+ * @spec JSR-51
	74	+ */
	75	+ public final FileChannel getChannel() {
	76	+ return null;
	77	+ }
	78	+
	79	+ /**
	80	+ * Writes to the socket.
	81	+ * @param fd the FileDescriptor
	82	+ * @param b the data to be written
	83	+ * @param off the start offset in the data
	84	+ * @param len the number of bytes that are written
	85	+ * @exception IOException If an I/O error has occurred.
	86	+ */
	87	+ private native void socketWrite0(FileDescriptor fd, byte[] b, int off,
	88	+ int len) throws IOException;
	89	+
	90	+ /**
	91	+ * Writes to the socket with appropriate locking of the
	92	+ * FileDescriptor.
	93	+ * @param b the data to be written
	94	+ * @param off the start offset in the data
	95	+ * @param len the number of bytes that are written
	96	+ * @exception IOException If an I/O error has occurred.
	97	+ */
	98	+ private void socketWrite(byte b[], int off, int len) throws IOException {
	99	+
	100	+ if (len <= 0 \|\| off < 0 \|\| off + len > b.length) {
	101	+ if (len == 0) {
	102	+ return;
	103	+ }
	104	+ throw new ArrayIndexOutOfBoundsException();
	105	+ }
	106	+
	107	+ FileDescriptor fd = impl.acquireFD();
	108	+ try {
	109	+ socketWrite0(fd, b, off, len);
	110	+ } catch (SocketException se) {
	111	+ if (se instanceof sun.net.ConnectionResetException) {
	112	+ impl.setConnectionResetPending();
	113	+ se = new SocketException("Connection reset");
	114	+ }
	115	+ if (impl.isClosedOrPending()) {
	116	+ throw new SocketException("Socket closed");
	117	+ } else {
	118	+ throw se;
	119	+ }
	120	+ } finally {
	121	+ impl.releaseFD();
	122	+ }
	123	+ }
	124	+
	125	+ /**
	126	+ * Writes a byte to the socket.
	127	+ * @param b the data to be written
	128	+ * @exception IOException If an I/O error has occurred.
	129	+ */
	130	+ public void write(int b) throws IOException {
	131	+ temp[0] = (byte)b;
	132	+ socketWrite(temp, 0, 1);
	133	+ }
	134	+
	135	+ /**
	136	+ * Writes the contents of the buffer <i>b</i> to the socket.
	137	+ * @param b the data to be written
	138	+ * @exception SocketException If an I/O error has occurred.
	139	+ */
	140	+ public void write(byte b[]) throws IOException {
	141	+ socketWrite(b, 0, b.length);
	142	+ }
	143	+
	144	+ /**
	145	+ * Writes <i>length</i> bytes from buffer <i>b</i> starting at
	146	+ * offset <i>len</i>.
	147	+ * @param b the data to be written
	148	+ * @param off the start offset in the data
	149	+ * @param len the number of bytes that are written
	150	+ * @exception SocketException If an I/O error has occurred.
	151	+ */
	152	+ public void write(byte b[], int off, int len) throws IOException {
	153	+ socketWrite(b, off, len);
	154	+ }
	155	+
	156	+ /**
	157	+ * Closes the stream.
	158	+ */
	159	+ private boolean closing = false;
	160	+ public void close() throws IOException {
	161	+ // Prevent recursion. See BugId 4484411
	162	+ if (closing)
	163	+ return;
	164	+ closing = true;
	165	+ if (socket != null) {
	166	+ if (!socket.isClosed())
	167	+ socket.close();
	168	+ } else
	169	+ impl.close();
	170	+ closing = false;
	171	+ }
	172	+
	173	+ /**
	174	+ * Overrides finalize, the fd is closed by the Socket.
	175	+ */
	176	+ protected void finalize() {}
	177	+
	178	+ /**
	179	+ * Perform class load-time initializations.
	180	+ */
	181	+ private native static void init();
	182	+
	183	+}

java/pkg/java/net/SocketPermission.class+0−0

Binary file not shown.

java/pkg/java/net/SocketPermission.java+1376−0

@@ -0,0 +1,1376 @@
	1	+/*
	2	+ * Copyright (c) 1997, 2006, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+import java.util.Enumeration;
	29	+import java.util.Vector;
	30	+import java.util.List;
	31	+import java.util.ArrayList;
	32	+import java.util.Collections;
	33	+import java.util.StringTokenizer;
	34	+import java.net.InetAddress;
	35	+import java.security.Permission;
	36	+import java.security.PermissionCollection;
	37	+import java.io.Serializable;
	38	+import java.io.ObjectStreamField;
	39	+import java.io.ObjectOutputStream;
	40	+import java.io.ObjectInputStream;
	41	+import java.io.IOException;
	42	+import sun.net.util.IPAddressUtil;
	43	+import sun.net.RegisteredDomain;
	44	+import sun.security.util.SecurityConstants;
	45	+import sun.security.util.Debug;
	46	+
	47	+
	48	+/**
	49	+ * This class represents access to a network via sockets.
	50	+ * A SocketPermission consists of a
	51	+ * host specification and a set of "actions" specifying ways to
	52	+ * connect to that host. The host is specified as
	53	+ * <pre>
	54	+ * host = (hostname \| IPv4address \| iPv6reference) [:portrange]
	55	+ * portrange = portnumber \| -portnumber \| portnumber-[portnumber]
	56	+ * </pre>
	57	+ * The host is expressed as a DNS name, as a numerical IP address,
	58	+ * or as "localhost" (for the local machine).
	59	+ * The wildcard "*" may be included once in a DNS name host
	60	+ * specification. If it is included, it must be in the leftmost
	61	+ * position, as in "*.sun.com".
	62	+ * <p>
	63	+ * The format of the IPv6reference should follow that specified in <a
	64	+ * href="http://www.ietf.org/rfc/rfc2732.txt"><i>RFC 2732: Format
	65	+ * for Literal IPv6 Addresses in URLs</i></a>:
	66	+ * <pre>
	67	+ * ipv6reference = "[" IPv6address "]"
	68	+ *</pre>
	69	+ * For example, you can construct a SocketPermission instance
	70	+ * as the following:
	71	+ * <pre>
	72	+ * String hostAddress = inetaddress.getHostAddress();
	73	+ * if (inetaddress instanceof Inet6Address) {
	74	+ * sp = new SocketPermission("[" + hostAddress + "]:" + port, action);
	75	+ * } else {
	76	+ * sp = new SocketPermission(hostAddress + ":" + port, action);
	77	+ * }
	78	+ * </pre>
	79	+ * or
	80	+ * <pre>
	81	+ * String host = url.getHost();
	82	+ * sp = new SocketPermission(host + ":" + port, action);
	83	+ * </pre>
	84	+ * <p>
	85	+ * The <A HREF="Inet6Address.html#lform">full uncompressed form</A> of
	86	+ * an IPv6 literal address is also valid.
	87	+ * <p>
	88	+ * The port or portrange is optional. A port specification of the
	89	+ * form "N-", where <i>N</i> is a port number, signifies all ports
	90	+ * numbered <i>N</i> and above, while a specification of the
	91	+ * form "-N" indicates all ports numbered <i>N</i> and below.
	92	+ * <p>
	93	+ * The possible ways to connect to the host are
	94	+ * <pre>
	95	+ * accept
	96	+ * connect
	97	+ * listen
	98	+ * resolve
	99	+ * </pre>
	100	+ * The "listen" action is only meaningful when used with "localhost".
	101	+ * The "resolve" action is implied when any of the other actions are present.
	102	+ * The action "resolve" refers to host/ip name service lookups.
	103	+ * <P>
	104	+ * The actions string is converted to lowercase before processing.
	105	+ * <p>As an example of the creation and meaning of SocketPermissions,
	106	+ * note that if the following permission:
	107	+ *
	108	+ * <pre>
	109	+ * p1 = new SocketPermission("puffin.eng.sun.com:7777", "connect,accept");
	110	+ * </pre>
	111	+ *
	112	+ * is granted to some code, it allows that code to connect to port 7777 on
	113	+ * <code>puffin.eng.sun.com</code>, and to accept connections on that port.
	114	+ *
	115	+ * <p>Similarly, if the following permission:
	116	+ *
	117	+ * <pre>
	118	+ * p2 = new SocketPermission("localhost:1024-", "accept,connect,listen");
	119	+ * </pre>
	120	+ *
	121	+ * is granted to some code, it allows that code to
	122	+ * accept connections on, connect to, or listen on any port between
	123	+ * 1024 and 65535 on the local host.
	124	+ *
	125	+ * <p>Note: Granting code permission to accept or make connections to remote
	126	+ * hosts may be dangerous because malevolent code can then more easily
	127	+ * transfer and share confidential data among parties who may not
	128	+ * otherwise have access to the data.
	129	+ *
	130	+ * @see java.security.Permissions
	131	+ * @see SocketPermission
	132	+ *
	133	+ *
	134	+ * @author Marianne Mueller
	135	+ * @author Roland Schemers
	136	+ *
	137	+ * @serial exclude
	138	+ */
	139	+
	140	+public final class SocketPermission extends Permission
	141	+implements java.io.Serializable
	142	+{
	143	+ private static final long serialVersionUID = -7204263841984476862L;
	144	+
	145	+ /**
	146	+ * Connect to host:port
	147	+ */
	148	+ private final static int CONNECT = 0x1;
	149	+
	150	+ /**
	151	+ * Listen on host:port
	152	+ */
	153	+ private final static int LISTEN = 0x2;
	154	+
	155	+ /**
	156	+ * Accept a connection from host:port
	157	+ */
	158	+ private final static int ACCEPT = 0x4;
	159	+
	160	+ /**
	161	+ * Resolve DNS queries
	162	+ */
	163	+ private final static int RESOLVE = 0x8;
	164	+
	165	+ /**
	166	+ * No actions
	167	+ */
	168	+ private final static int NONE = 0x0;
	169	+
	170	+ /**
	171	+ * All actions
	172	+ */
	173	+ private final static int ALL = CONNECT\|LISTEN\|ACCEPT\|RESOLVE;
	174	+
	175	+ // various port constants
	176	+ private static final int PORT_MIN = 0;
	177	+ private static final int PORT_MAX = 65535;
	178	+ private static final int PRIV_PORT_MAX = 1023;
	179	+
	180	+ // the actions mask
	181	+ private transient int mask;
	182	+
	183	+ /**
	184	+ * the actions string.
	185	+ *
	186	+ * @serial
	187	+ */
	188	+
	189	+ private String actions; // Left null as long as possible, then
	190	+ // created and re-used in the getAction function.
	191	+
	192	+ // hostname part as it is passed
	193	+ private transient String hostname;
	194	+
	195	+ // the canonical name of the host
	196	+ // in the case of "*.foo.com", cname is ".foo.com".
	197	+
	198	+ private transient String cname;
	199	+
	200	+ // all the IP addresses of the host
	201	+ private transient InetAddress[] addresses;
	202	+
	203	+ // true if the hostname is a wildcard (e.g. "*.sun.com")
	204	+ private transient boolean wildcard;
	205	+
	206	+ // true if we were initialized with a single numeric IP address
	207	+ private transient boolean init_with_ip;
	208	+
	209	+ // true if this SocketPermission represents an invalid/unknown host
	210	+ // used for implies when the delayed lookup has already failed
	211	+ private transient boolean invalid;
	212	+
	213	+ // port range on host
	214	+ private transient int[] portrange;
	215	+
	216	+ private transient boolean defaultDeny = false;
	217	+
	218	+ // true if this SocketPermission represents a hostname
	219	+ // that failed our reverse mapping heuristic test
	220	+ private transient boolean untrusted;
	221	+ private transient boolean trusted;
	222	+
	223	+ // true if the sun.net.trustNameService system property is set
	224	+ private static boolean trustNameService;
	225	+
	226	+ private static Debug debug = null;
	227	+ private static boolean debugInit = false;
	228	+
	229	+ static {
	230	+ Boolean tmp = java.security.AccessController.doPrivileged(
	231	+ new sun.security.action.GetBooleanAction("sun.net.trustNameService"));
	232	+ trustNameService = tmp.booleanValue();
	233	+ }
	234	+
	235	+ private static synchronized Debug getDebug()
	236	+ {
	237	+ if (!debugInit) {
	238	+ debug = Debug.getInstance("access");
	239	+ debugInit = true;
	240	+ }
	241	+ return debug;
	242	+ }
	243	+
	244	+ /**
	245	+ * Creates a new SocketPermission object with the specified actions.
	246	+ * The host is expressed as a DNS name, or as a numerical IP address.
	247	+ * Optionally, a port or a portrange may be supplied (separated
	248	+ * from the DNS name or IP address by a colon).
	249	+ * <p>
	250	+ * To specify the local machine, use "localhost" as the <i>host</i>.
	251	+ * Also note: An empty <i>host</i> String ("") is equivalent to "localhost".
	252	+ * <p>
	253	+ * The <i>actions</i> parameter contains a comma-separated list of the
	254	+ * actions granted for the specified host (and port(s)). Possible actions are
	255	+ * "connect", "listen", "accept", "resolve", or
	256	+ * any combination of those. "resolve" is automatically added
	257	+ * when any of the other three are specified.
	258	+ * <p>
	259	+ * Examples of SocketPermission instantiation are the following:
	260	+ * <pre>
	261	+ * nr = new SocketPermission("www.catalog.com", "connect");
	262	+ * nr = new SocketPermission("www.sun.com:80", "connect");
	263	+ * nr = new SocketPermission("*.sun.com", "connect");
	264	+ * nr = new SocketPermission("*.edu", "resolve");
	265	+ * nr = new SocketPermission("204.160.241.0", "connect");
	266	+ * nr = new SocketPermission("localhost:1024-65535", "listen");
	267	+ * nr = new SocketPermission("204.160.241.0:1024-65535", "connect");
	268	+ * </pre>
	269	+ *
	270	+ * @param host the hostname or IPaddress of the computer, optionally
	271	+ * including a colon followed by a port or port range.
	272	+ * @param action the action string.
	273	+ */
	274	+ public SocketPermission(String host, String action) {
	275	+ super(getHost(host));
	276	+ // name initialized to getHost(host); NPE detected in getHost()
	277	+ init(getName(), getMask(action));
	278	+ }
	279	+
	280	+
	281	+ SocketPermission(String host, int mask) {
	282	+ super(getHost(host));
	283	+ // name initialized to getHost(host); NPE detected in getHost()
	284	+ init(getName(), mask);
	285	+ }
	286	+
	287	+ private void setDeny() {
	288	+ defaultDeny = true;
	289	+ }
	290	+
	291	+ private static String getHost(String host)
	292	+ {
	293	+ if (host.equals("")) {
	294	+ return "localhost";
	295	+ } else {
	296	+ /* IPv6 literal address used in this context should follow
	297	+ * the format specified in RFC 2732;
	298	+ * if not, we try to solve the unambiguous case
	299	+ */
	300	+ int ind;
	301	+ if (host.charAt(0) != '[') {
	302	+ if ((ind = host.indexOf(':')) != host.lastIndexOf(':')) {
	303	+ /* More than one ":", meaning IPv6 address is not
	304	+ * in RFC 2732 format;
	305	+ * We will rectify user errors for all unambiguious cases
	306	+ */
	307	+ StringTokenizer st = new StringTokenizer(host, ":");
	308	+ int tokens = st.countTokens();
	309	+ if (tokens == 9) {
	310	+ // IPv6 address followed by port
	311	+ ind = host.lastIndexOf(':');
	312	+ host = "[" + host.substring(0, ind) + "]" +
	313	+ host.substring(ind);
	314	+ } else if (tokens == 8 && host.indexOf("::") == -1) {
	315	+ // IPv6 address only, not followed by port
	316	+ host = "[" + host + "]";
	317	+ } else {
	318	+ // could be ambiguous
	319	+ throw new IllegalArgumentException("Ambiguous"+
	320	+ " hostport part");
	321	+ }
	322	+ }
	323	+ }
	324	+ return host;
	325	+ }
	326	+ }
	327	+
	328	+ private int[] parsePort(String port)
	329	+ throws Exception
	330	+ {
	331	+
	332	+ if (port == null \|\| port.equals("") \|\| port.equals("*")) {
	333	+ return new int[] {PORT_MIN, PORT_MAX};
	334	+ }
	335	+
	336	+ int dash = port.indexOf('-');
	337	+
	338	+ if (dash == -1) {
	339	+ int p = Integer.parseInt(port);
	340	+ return new int[] {p, p};
	341	+ } else {
	342	+ String low = port.substring(0, dash);
	343	+ String high = port.substring(dash+1);
	344	+ int l,h;
	345	+
	346	+ if (low.equals("")) {
	347	+ l = PORT_MIN;
	348	+ } else {
	349	+ l = Integer.parseInt(low);
	350	+ }
	351	+
	352	+ if (high.equals("")) {
	353	+ h = PORT_MAX;
	354	+ } else {
	355	+ h = Integer.parseInt(high);
	356	+ }
	357	+ if (l < 0 \|\| h < 0 \|\| h<l)
	358	+ throw new IllegalArgumentException("invalid port range");
	359	+
	360	+ return new int[] {l, h};
	361	+ }
	362	+ }
	363	+
	364	+ /**
	365	+ * Initialize the SocketPermission object. We don't do any DNS lookups
	366	+ * as this point, instead we hold off until the implies method is
	367	+ * called.
	368	+ */
	369	+ private void init(String host, int mask) {
	370	+ // Set the integer mask that represents the actions
	371	+
	372	+ if ((mask & ALL) != mask)
	373	+ throw new IllegalArgumentException("invalid actions mask");
	374	+
	375	+ // always OR in RESOLVE if we allow any of the others
	376	+ this.mask = mask \| RESOLVE;
	377	+
	378	+ // Parse the host name. A name has up to three components, the
	379	+ // hostname, a port number, or two numbers representing a port
	380	+ // range. "www.sun.com:8080-9090" is a valid host name.
	381	+
	382	+ // With IPv6 an address can be 2010:836B:4179::836B:4179
	383	+ // An IPv6 address needs to be enclose in []
	384	+ // For ex: [2010:836B:4179::836B:4179]:8080-9090
	385	+ // Refer to RFC 2732 for more information.
	386	+
	387	+ int rb = 0 ;
	388	+ int start = 0, end = 0;
	389	+ int sep = -1;
	390	+ String hostport = host;
	391	+ if (host.charAt(0) == '[') {
	392	+ start = 1;
	393	+ rb = host.indexOf(']');
	394	+ if (rb != -1) {
	395	+ host = host.substring(start, rb);
	396	+ } else {
	397	+ throw new
	398	+ IllegalArgumentException("invalid host/port: "+host);
	399	+ }
	400	+ sep = hostport.indexOf(':', rb+1);
	401	+ } else {
	402	+ start = 0;
	403	+ sep = host.indexOf(':', rb);
	404	+ end = sep;
	405	+ if (sep != -1) {
	406	+ host = host.substring(start, end);
	407	+ }
	408	+ }
	409	+
	410	+ if (sep != -1) {
	411	+ String port = hostport.substring(sep+1);
	412	+ try {
	413	+ portrange = parsePort(port);
	414	+ } catch (Exception e) {
	415	+ throw new
	416	+ IllegalArgumentException("invalid port range: "+port);
	417	+ }
	418	+ } else {
	419	+ portrange = new int[] { PORT_MIN, PORT_MAX };
	420	+ }
	421	+
	422	+ hostname = host;
	423	+
	424	+ // is this a domain wildcard specification
	425	+ if (host.lastIndexOf('*') > 0) {
	426	+ throw new
	427	+ IllegalArgumentException("invalid host wildcard specification");
	428	+ } else if (host.startsWith("*")) {
	429	+ wildcard = true;
	430	+ if (host.equals("*")) {
	431	+ cname = "";
	432	+ } else if (host.startsWith("*.")) {
	433	+ cname = host.substring(1).toLowerCase();
	434	+ } else {
	435	+ throw new
	436	+ IllegalArgumentException("invalid host wildcard specification");
	437	+ }
	438	+ return;
	439	+ } else {
	440	+ if (host.length() > 0) {
	441	+ // see if we are being initialized with an IP address.
	442	+ char ch = host.charAt(0);
	443	+ if (ch == ':' \|\| Character.digit(ch, 16) != -1) {
	444	+ byte ip[] = IPAddressUtil.textToNumericFormatV4(host);
	445	+ if (ip == null) {
	446	+ ip = IPAddressUtil.textToNumericFormatV6(host);
	447	+ }
	448	+ if (ip != null) {
	449	+ try {
	450	+ addresses =
	451	+ new InetAddress[]
	452	+ {InetAddress.getByAddress(ip) };
	453	+ init_with_ip = true;
	454	+ } catch (UnknownHostException uhe) {
	455	+ // this shouldn't happen
	456	+ invalid = true;
	457	+ }
	458	+ }
	459	+ }
	460	+ }
	461	+ }
	462	+ }
	463	+
	464	+ /**
	465	+ * Convert an action string to an integer actions mask.
	466	+ *
	467	+ * @param action the action string
	468	+ * @return the action mask
	469	+ */
	470	+ private static int getMask(String action) {
	471	+
	472	+ if (action == null) {
	473	+ throw new NullPointerException("action can't be null");
	474	+ }
	475	+
	476	+ if (action.equals("")) {
	477	+ throw new IllegalArgumentException("action can't be empty");
	478	+ }
	479	+
	480	+ int mask = NONE;
	481	+
	482	+ // Check against use of constants (used heavily within the JDK)
	483	+ if (action == SecurityConstants.SOCKET_RESOLVE_ACTION) {
	484	+ return RESOLVE;
	485	+ } else if (action == SecurityConstants.SOCKET_CONNECT_ACTION) {
	486	+ return CONNECT;
	487	+ } else if (action == SecurityConstants.SOCKET_LISTEN_ACTION) {
	488	+ return LISTEN;
	489	+ } else if (action == SecurityConstants.SOCKET_ACCEPT_ACTION) {
	490	+ return ACCEPT;
	491	+ } else if (action == SecurityConstants.SOCKET_CONNECT_ACCEPT_ACTION) {
	492	+ return CONNECT\|ACCEPT;
	493	+ }
	494	+
	495	+ char[] a = action.toCharArray();
	496	+
	497	+ int i = a.length - 1;
	498	+ if (i < 0)
	499	+ return mask;
	500	+
	501	+ while (i != -1) {
	502	+ char c;
	503	+
	504	+ // skip whitespace
	505	+ while ((i!=-1) && ((c = a[i]) == ' ' \|\|
	506	+ c == '\r' \|\|
	507	+ c == '\n' \|\|
	508	+ c == '\f' \|\|
	509	+ c == '\t'))
	510	+ i--;
	511	+
	512	+ // check for the known strings
	513	+ int matchlen;
	514	+
	515	+ if (i >= 6 && (a[i-6] == 'c' \|\| a[i-6] == 'C') &&
	516	+ (a[i-5] == 'o' \|\| a[i-5] == 'O') &&
	517	+ (a[i-4] == 'n' \|\| a[i-4] == 'N') &&
	518	+ (a[i-3] == 'n' \|\| a[i-3] == 'N') &&
	519	+ (a[i-2] == 'e' \|\| a[i-2] == 'E') &&
	520	+ (a[i-1] == 'c' \|\| a[i-1] == 'C') &&
	521	+ (a[i] == 't' \|\| a[i] == 'T'))
	522	+ {
	523	+ matchlen = 7;
	524	+ mask \|= CONNECT;
	525	+
	526	+ } else if (i >= 6 && (a[i-6] == 'r' \|\| a[i-6] == 'R') &&
	527	+ (a[i-5] == 'e' \|\| a[i-5] == 'E') &&
	528	+ (a[i-4] == 's' \|\| a[i-4] == 'S') &&
	529	+ (a[i-3] == 'o' \|\| a[i-3] == 'O') &&
	530	+ (a[i-2] == 'l' \|\| a[i-2] == 'L') &&
	531	+ (a[i-1] == 'v' \|\| a[i-1] == 'V') &&
	532	+ (a[i] == 'e' \|\| a[i] == 'E'))
	533	+ {
	534	+ matchlen = 7;
	535	+ mask \|= RESOLVE;
	536	+
	537	+ } else if (i >= 5 && (a[i-5] == 'l' \|\| a[i-5] == 'L') &&
	538	+ (a[i-4] == 'i' \|\| a[i-4] == 'I') &&
	539	+ (a[i-3] == 's' \|\| a[i-3] == 'S') &&
	540	+ (a[i-2] == 't' \|\| a[i-2] == 'T') &&
	541	+ (a[i-1] == 'e' \|\| a[i-1] == 'E') &&
	542	+ (a[i] == 'n' \|\| a[i] == 'N'))
	543	+ {
	544	+ matchlen = 6;
	545	+ mask \|= LISTEN;
	546	+
	547	+ } else if (i >= 5 && (a[i-5] == 'a' \|\| a[i-5] == 'A') &&
	548	+ (a[i-4] == 'c' \|\| a[i-4] == 'C') &&
	549	+ (a[i-3] == 'c' \|\| a[i-3] == 'C') &&
	550	+ (a[i-2] == 'e' \|\| a[i-2] == 'E') &&
	551	+ (a[i-1] == 'p' \|\| a[i-1] == 'P') &&
	552	+ (a[i] == 't' \|\| a[i] == 'T'))
	553	+ {
	554	+ matchlen = 6;
	555	+ mask \|= ACCEPT;
	556	+
	557	+ } else {
	558	+ // parse error
	559	+ throw new IllegalArgumentException(
	560	+ "invalid permission: " + action);
	561	+ }
	562	+
	563	+ // make sure we didn't just match the tail of a word
	564	+ // like "ackbarfaccept". Also, skip to the comma.
	565	+ boolean seencomma = false;
	566	+ while (i >= matchlen && !seencomma) {
	567	+ switch(a[i-matchlen]) {
	568	+ case ',':
	569	+ seencomma = true;
	570	+ /FALLTHROUGH/
	571	+ case ' ': case '\r': case '\n':
	572	+ case '\f': case '\t':
	573	+ break;
	574	+ default:
	575	+ throw new IllegalArgumentException(
	576	+ "invalid permission: " + action);
	577	+ }
	578	+ i--;
	579	+ }
	580	+
	581	+ // point i at the location of the comma minus one (or -1).
	582	+ i -= matchlen;
	583	+ }
	584	+
	585	+ return mask;
	586	+ }
	587	+
	588	+ private boolean isUntrusted()
	589	+ throws UnknownHostException
	590	+ {
	591	+ if (trusted) return false;
	592	+ if (invalid \|\| untrusted) return true;
	593	+ try {
	594	+ if (!trustNameService && (defaultDeny \|\|
	595	+ sun.net.www.URLConnection.isProxiedHost(hostname))) {
	596	+ if (this.cname == null) {
	597	+ this.getCanonName();
	598	+ }
	599	+ if (!match(cname, hostname)) {
	600	+ // Last chance
	601	+ if (!authorized(hostname, addresses[0].getAddress())) {
	602	+ untrusted = true;
	603	+ Debug debug = getDebug();
	604	+ if (debug != null && Debug.isOn("failure")) {
	605	+ debug.println("socket access restriction: proxied host " + "(" + addresses[0] + ")" + " does not match " + cname + " from reverse lookup");
	606	+ }
	607	+ return true;
	608	+ }
	609	+ }
	610	+ trusted = true;
	611	+ }
	612	+ } catch (UnknownHostException uhe) {
	613	+ invalid = true;
	614	+ throw uhe;
	615	+ }
	616	+ return false;
	617	+ }
	618	+
	619	+ /**
	620	+ * attempt to get the fully qualified domain name
	621	+ *
	622	+ */
	623	+ void getCanonName()
	624	+ throws UnknownHostException
	625	+ {
	626	+ if (cname != null \|\| invalid \|\| untrusted) return;
	627	+
	628	+ // attempt to get the canonical name
	629	+
	630	+ try {
	631	+ // first get the IP addresses if we don't have them yet
	632	+ // this is because we need the IP address to then get
	633	+ // FQDN.
	634	+ if (addresses == null) {
	635	+ getIP();
	636	+ }
	637	+
	638	+ // we have to do this check, otherwise we might not
	639	+ // get the fully qualified domain name
	640	+ if (init_with_ip) {
	641	+ cname = addresses[0].getHostName(false).toLowerCase();
	642	+ } else {
	643	+ cname = InetAddress.getByName(addresses[0].getHostAddress()).
	644	+ getHostName(false).toLowerCase();
	645	+ }
	646	+ } catch (UnknownHostException uhe) {
	647	+ invalid = true;
	648	+ throw uhe;
	649	+ }
	650	+ }
	651	+
	652	+ private transient String cdomain, hdomain;
	653	+
	654	+ private boolean match(String cname, String hname) {
	655	+ String a = cname.toLowerCase();
	656	+ String b = hname.toLowerCase();
	657	+ if (a.startsWith(b) &&
	658	+ ((a.length() == b.length()) \|\| (a.charAt(b.length()) == '.')))
	659	+ return true;
	660	+ if (cdomain == null) {
	661	+ cdomain = RegisteredDomain.getRegisteredDomain(a);
	662	+ }
	663	+ if (hdomain == null) {
	664	+ hdomain = RegisteredDomain.getRegisteredDomain(b);
	665	+ }
	666	+
	667	+ return cdomain.length() != 0 && hdomain.length() != 0
	668	+ && cdomain.equals(hdomain);
	669	+ }
	670	+
	671	+ private boolean authorized(String cname, byte[] addr) {
	672	+ if (addr.length == 4)
	673	+ return authorizedIPv4(cname, addr);
	674	+ else if (addr.length == 16)
	675	+ return authorizedIPv6(cname, addr);
	676	+ else
	677	+ return false;
	678	+ }
	679	+
	680	+ private boolean authorizedIPv4(String cname, byte[] addr) {
	681	+ String authHost = "";
	682	+ InetAddress auth;
	683	+
	684	+ try {
	685	+ authHost = "auth." +
	686	+ (addr[3] & 0xff) + "." + (addr[2] & 0xff) + "." +
	687	+ (addr[1] & 0xff) + "." + (addr[0] & 0xff) +
	688	+ ".in-addr.arpa";
	689	+ // Following check seems unnecessary
	690	+ // auth = InetAddress.getAllByName0(authHost, false)[0];
	691	+ authHost = hostname + '.' + authHost;
	692	+ auth = InetAddress.getAllByName0(authHost, false)[0];
	693	+ if (auth.equals(InetAddress.getByAddress(addr))) {
	694	+ return true;
	695	+ }
	696	+ Debug debug = getDebug();
	697	+ if (debug != null && Debug.isOn("failure")) {
	698	+ debug.println("socket access restriction: IP address of " + auth + " != " + InetAddress.getByAddress(addr));
	699	+ }
	700	+ } catch (UnknownHostException uhe) {
	701	+ Debug debug = getDebug();
	702	+ if (debug != null && Debug.isOn("failure")) {
	703	+ debug.println("socket access restriction: forward lookup failed for " + authHost);
	704	+ }
	705	+ }
	706	+ return false;
	707	+ }
	708	+
	709	+ private boolean authorizedIPv6(String cname, byte[] addr) {
	710	+ String authHost = "";
	711	+ InetAddress auth;
	712	+
	713	+ try {
	714	+ StringBuffer sb = new StringBuffer(39);
	715	+
	716	+ for (int i = 15; i >= 0; i--) {
	717	+ sb.append(Integer.toHexString(((addr[i]) & 0x0f)));
	718	+ sb.append('.');
	719	+ sb.append(Integer.toHexString(((addr[i] >> 4) & 0x0f)));
	720	+ sb.append('.');
	721	+ }
	722	+ authHost = "auth." + sb.toString() + "IP6.ARPA";
	723	+ //auth = InetAddress.getAllByName0(authHost, false)[0];
	724	+ authHost = hostname + '.' + authHost;
	725	+ auth = InetAddress.getAllByName0(authHost, false)[0];
	726	+ if (auth.equals(InetAddress.getByAddress(addr)))
	727	+ return true;
	728	+ Debug debug = getDebug();
	729	+ if (debug != null && Debug.isOn("failure")) {
	730	+ debug.println("socket access restriction: IP address of " + auth + " != " + InetAddress.getByAddress(addr));
	731	+ }
	732	+ } catch (UnknownHostException uhe) {
	733	+ Debug debug = getDebug();
	734	+ if (debug != null && Debug.isOn("failure")) {
	735	+ debug.println("socket access restriction: forward lookup failed for " + authHost);
	736	+ }
	737	+ }
	738	+ return false;
	739	+ }
	740	+
	741	+
	742	+ /**
	743	+ * get IP addresses. Sets invalid to true if we can't get them.
	744	+ *
	745	+ */
	746	+ void getIP()
	747	+ throws UnknownHostException
	748	+ {
	749	+ if (addresses != null \|\| wildcard \|\| invalid) return;
	750	+
	751	+ try {
	752	+ // now get all the IP addresses
	753	+ String host;
	754	+ if (getName().charAt(0) == '[') {
	755	+ // Literal IPv6 address
	756	+ host = getName().substring(1, getName().indexOf(']'));
	757	+ } else {
	758	+ int i = getName().indexOf(":");
	759	+ if (i == -1)
	760	+ host = getName();
	761	+ else {
	762	+ host = getName().substring(0,i);
	763	+ }
	764	+ }
	765	+
	766	+ addresses =
	767	+ new InetAddress[] {InetAddress.getAllByName0(host, false)[0]};
	768	+
	769	+ } catch (UnknownHostException uhe) {
	770	+ invalid = true;
	771	+ throw uhe;
	772	+ } catch (IndexOutOfBoundsException iobe) {
	773	+ invalid = true;
	774	+ throw new UnknownHostException(getName());
	775	+ }
	776	+ }
	777	+
	778	+ /**
	779	+ * Checks if this socket permission object "implies" the
	780	+ * specified permission.
	781	+ * <P>
	782	+ * More specifically, this method first ensures that all of the following
	783	+ * are true (and returns false if any of them are not):<p>
	784	+ * <ul>
	785	+ * <li> <i>p</i> is an instanceof SocketPermission,<p>
	786	+ * <li> <i>p</i>'s actions are a proper subset of this
	787	+ * object's actions, and<p>
	788	+ * <li> <i>p</i>'s port range is included in this port range. Note:
	789	+ * port range is ignored when p only contains the action, 'resolve'.<p>
	790	+ * </ul>
	791	+ *
	792	+ * Then <code>implies</code> checks each of the following, in order,
	793	+ * and for each returns true if the stated condition is true:<p>
	794	+ * <ul>
	795	+ * <li> If this object was initialized with a single IP address and one of <i>p</i>'s
	796	+ * IP addresses is equal to this object's IP address.<p>
	797	+ * <li>If this object is a wildcard domain (such as *.sun.com), and
	798	+ * <i>p</i>'s canonical name (the name without any preceding *)
	799	+ * ends with this object's canonical host name. For example, *.sun.com
	800	+ * implies *.eng.sun.com..<p>
	801	+ * <li>If this object was not initialized with a single IP address, and one of this
	802	+ * object's IP addresses equals one of <i>p</i>'s IP addresses.<p>
	803	+ * <li>If this canonical name equals <i>p</i>'s canonical name.<p>
	804	+ * </ul>
	805	+ *
	806	+ * If none of the above are true, <code>implies</code> returns false.
	807	+ * @param p the permission to check against.
	808	+ *
	809	+ * @return true if the specified permission is implied by this object,
	810	+ * false if not.
	811	+ */
	812	+
	813	+ public boolean implies(Permission p) {
	814	+ int i,j;
	815	+
	816	+ if (!(p instanceof SocketPermission))
	817	+ return false;
	818	+
	819	+ if (p == this)
	820	+ return true;
	821	+
	822	+ SocketPermission that = (SocketPermission) p;
	823	+
	824	+ return ((this.mask & that.mask) == that.mask) &&
	825	+ impliesIgnoreMask(that);
	826	+ }
	827	+
	828	+ /**
	829	+ * Checks if the incoming Permission's action are a proper subset of
	830	+ * the this object's actions.
	831	+ * <P>
	832	+ * Check, in the following order:
	833	+ * <ul>
	834	+ * <li> Checks that "p" is an instanceof a SocketPermission
	835	+ * <li> Checks that "p"'s actions are a proper subset of the
	836	+ * current object's actions.
	837	+ * <li> Checks that "p"'s port range is included in this port range
	838	+ * <li> If this object was initialized with an IP address, checks that
	839	+ * one of "p"'s IP addresses is equal to this object's IP address.
	840	+ * <li> If either object is a wildcard domain (i.e., "*.sun.com"),
	841	+ * attempt to match based on the wildcard.
	842	+ * <li> If this object was not initialized with an IP address, attempt
	843	+ * to find a match based on the IP addresses in both objects.
	844	+ * <li> Attempt to match on the canonical hostnames of both objects.
	845	+ * </ul>
	846	+ * @param p the incoming permission request
	847	+ *
	848	+ * @return true if "permission" is a proper subset of the current object,
	849	+ * false if not.
	850	+ */
	851	+
	852	+ boolean impliesIgnoreMask(SocketPermission that) {
	853	+ int i,j;
	854	+
	855	+ if ((that.mask & RESOLVE) != that.mask) {
	856	+ // check port range
	857	+ if ((that.portrange[0] < this.portrange[0]) \|\|
	858	+ (that.portrange[1] > this.portrange[1])) {
	859	+ return false;
	860	+ }
	861	+ }
	862	+
	863	+ // allow a "*" wildcard to always match anything
	864	+ if (this.wildcard && "".equals(this.cname))
	865	+ return true;
	866	+
	867	+ // return if either one of these NetPerm objects are invalid...
	868	+ if (this.invalid \|\| that.invalid) {
	869	+ return compareHostnames(that);
	870	+ }
	871	+
	872	+ try {
	873	+ if (this.init_with_ip) { // we only check IP addresses
	874	+ if (that.wildcard)
	875	+ return false;
	876	+
	877	+ if (that.init_with_ip) {
	878	+ return (this.addresses[0].equals(that.addresses[0]));
	879	+ } else {
	880	+ if (that.addresses == null) {
	881	+ that.getIP();
	882	+ }
	883	+ for (i=0; i < that.addresses.length; i++) {
	884	+ if (this.addresses[0].equals(that.addresses[i]))
	885	+ return true;
	886	+ }
	887	+ }
	888	+ // since "this" was initialized with an IP address, we
	889	+ // don't check any other cases
	890	+ return false;
	891	+ }
	892	+
	893	+ // check and see if we have any wildcards...
	894	+ if (this.wildcard \|\| that.wildcard) {
	895	+ // if they are both wildcards, return true iff
	896	+ // that's cname ends with this cname (i.e., *.sun.com
	897	+ // implies *.eng.sun.com)
	898	+ if (this.wildcard && that.wildcard)
	899	+ return (that.cname.endsWith(this.cname));
	900	+
	901	+ // a non-wildcard can't imply a wildcard
	902	+ if (that.wildcard)
	903	+ return false;
	904	+
	905	+ // this is a wildcard, lets see if that's cname ends with
	906	+ // it...
	907	+ if (that.cname == null) {
	908	+ that.getCanonName();
	909	+ }
	910	+ return (that.cname.endsWith(this.cname));
	911	+ }
	912	+
	913	+ // comapare IP addresses
	914	+ if (this.addresses == null) {
	915	+ this.getIP();
	916	+ }
	917	+
	918	+ if (that.addresses == null) {
	919	+ that.getIP();
	920	+ }
	921	+
	922	+ if (!(that.init_with_ip && this.isUntrusted())) {
	923	+ for (j = 0; j < this.addresses.length; j++) {
	924	+ for (i=0; i < that.addresses.length; i++) {
	925	+ if (this.addresses[j].equals(that.addresses[i]))
	926	+ return true;
	927	+ }
	928	+ }
	929	+
	930	+ // XXX: if all else fails, compare hostnames?
	931	+ // Do we really want this?
	932	+ if (this.cname == null) {
	933	+ this.getCanonName();
	934	+ }
	935	+
	936	+ if (that.cname == null) {
	937	+ that.getCanonName();
	938	+ }
	939	+
	940	+ return (this.cname.equalsIgnoreCase(that.cname));
	941	+ }
	942	+
	943	+ } catch (UnknownHostException uhe) {
	944	+ return compareHostnames(that);
	945	+ }
	946	+
	947	+ // make sure the first thing that is done here is to return
	948	+ // false. If not, uncomment the return false in the above catch.
	949	+
	950	+ return false;
	951	+ }
	952	+
	953	+ private boolean compareHostnames(SocketPermission that) {
	954	+ // we see if the original names/IPs passed in were equal.
	955	+
	956	+ String thisHost = hostname;
	957	+ String thatHost = that.hostname;
	958	+
	959	+ if (thisHost == null)
	960	+ return false;
	961	+ else
	962	+ return thisHost.equalsIgnoreCase(thatHost);
	963	+ }
	964	+
	965	+ /**
	966	+ * Checks two SocketPermission objects for equality.
	967	+ * <P>
	968	+ * @param obj the object to test for equality with this object.
	969	+ *
	970	+ * @return true if <i>obj</i> is a SocketPermission, and has the
	971	+ * same hostname, port range, and actions as this
	972	+ * SocketPermission object. However, port range will be ignored
	973	+ * in the comparison if <i>obj</i> only contains the action, 'resolve'.
	974	+ */
	975	+ public boolean equals(Object obj) {
	976	+ if (obj == this)
	977	+ return true;
	978	+
	979	+ if (! (obj instanceof SocketPermission))
	980	+ return false;
	981	+
	982	+ SocketPermission that = (SocketPermission) obj;
	983	+
	984	+ //this is (overly?) complex!!!
	985	+
	986	+ // check the mask first
	987	+ if (this.mask != that.mask) return false;
	988	+
	989	+ if ((that.mask & RESOLVE) != that.mask) {
	990	+ // now check the port range...
	991	+ if ((this.portrange[0] != that.portrange[0]) \|\|
	992	+ (this.portrange[1] != that.portrange[1])) {
	993	+ return false;
	994	+ }
	995	+ }
	996	+
	997	+ // short cut. This catches:
	998	+ // "crypto" equal to "crypto", or
	999	+ // "1.2.3.4" equal to "1.2.3.4.", or
	1000	+ // ".edu" equal to ".edu", but it
	1001	+ // does not catch "crypto" equal to
	1002	+ // "crypto.eng.sun.com".
	1003	+
	1004	+ if (this.getName().equalsIgnoreCase(that.getName())) {
	1005	+ return true;
	1006	+ }
	1007	+
	1008	+ // we now attempt to get the Canonical (FQDN) name and
	1009	+ // compare that. If this fails, about all we can do is return
	1010	+ // false.
	1011	+
	1012	+ try {
	1013	+ this.getCanonName();
	1014	+ that.getCanonName();
	1015	+ } catch (UnknownHostException uhe) {
	1016	+ return false;
	1017	+ }
	1018	+
	1019	+ if (this.invalid \|\| that.invalid)
	1020	+ return false;
	1021	+
	1022	+ if (this.cname != null) {
	1023	+ return this.cname.equalsIgnoreCase(that.cname);
	1024	+ }
	1025	+
	1026	+ return false;
	1027	+ }
	1028	+
	1029	+ /**
	1030	+ * Returns the hash code value for this object.
	1031	+ *
	1032	+ * @return a hash code value for this object.
	1033	+ */
	1034	+
	1035	+ public int hashCode() {
	1036	+ /*
	1037	+ * If this SocketPermission was initialized with an IP address
	1038	+ * or a wildcard, use getName().hashCode(), otherwise use
	1039	+ * the hashCode() of the host name returned from
	1040	+ * java.net.InetAddress.getHostName method.
	1041	+ */
	1042	+
	1043	+ if (init_with_ip \|\| wildcard) {
	1044	+ return this.getName().hashCode();
	1045	+ }
	1046	+
	1047	+ try {
	1048	+ getCanonName();
	1049	+ } catch (UnknownHostException uhe) {
	1050	+
	1051	+ }
	1052	+
	1053	+ if (invalid \|\| cname == null)
	1054	+ return this.getName().hashCode();
	1055	+ else
	1056	+ return this.cname.hashCode();
	1057	+ }
	1058	+
	1059	+ /**
	1060	+ * Return the current action mask.
	1061	+ *
	1062	+ * @return the actions mask.
	1063	+ */
	1064	+
	1065	+ int getMask() {
	1066	+ return mask;
	1067	+ }
	1068	+
	1069	+ /**
	1070	+ * Returns the "canonical string representation" of the actions in the
	1071	+ * specified mask.
	1072	+ * Always returns present actions in the following order:
	1073	+ * connect, listen, accept, resolve.
	1074	+ *
	1075	+ * @param mask a specific integer action mask to translate into a string
	1076	+ * @return the canonical string representation of the actions
	1077	+ */
	1078	+ private static String getActions(int mask)
	1079	+ {
	1080	+ StringBuilder sb = new StringBuilder();
	1081	+ boolean comma = false;
	1082	+
	1083	+ if ((mask & CONNECT) == CONNECT) {
	1084	+ comma = true;
	1085	+ sb.append("connect");
	1086	+ }
	1087	+
	1088	+ if ((mask & LISTEN) == LISTEN) {
	1089	+ if (comma) sb.append(',');
	1090	+ else comma = true;
	1091	+ sb.append("listen");
	1092	+ }
	1093	+
	1094	+ if ((mask & ACCEPT) == ACCEPT) {
	1095	+ if (comma) sb.append(',');
	1096	+ else comma = true;
	1097	+ sb.append("accept");
	1098	+ }
	1099	+
	1100	+
	1101	+ if ((mask & RESOLVE) == RESOLVE) {
	1102	+ if (comma) sb.append(',');
	1103	+ else comma = true;
	1104	+ sb.append("resolve");
	1105	+ }
	1106	+
	1107	+ return sb.toString();
	1108	+ }
	1109	+
	1110	+ /**
	1111	+ * Returns the canonical string representation of the actions.
	1112	+ * Always returns present actions in the following order:
	1113	+ * connect, listen, accept, resolve.
	1114	+ *
	1115	+ * @return the canonical string representation of the actions.
	1116	+ */
	1117	+ public String getActions()
	1118	+ {
	1119	+ if (actions == null)
	1120	+ actions = getActions(this.mask);
	1121	+
	1122	+ return actions;
	1123	+ }
	1124	+
	1125	+ /**
	1126	+ * Returns a new PermissionCollection object for storing SocketPermission
	1127	+ * objects.
	1128	+ * <p>
	1129	+ * SocketPermission objects must be stored in a manner that allows them
	1130	+ * to be inserted into the collection in any order, but that also enables the
	1131	+ * PermissionCollection <code>implies</code>
	1132	+ * method to be implemented in an efficient (and consistent) manner.
	1133	+ *
	1134	+ * @return a new PermissionCollection object suitable for storing SocketPermissions.
	1135	+ */
	1136	+
	1137	+ public PermissionCollection newPermissionCollection() {
	1138	+ return new SocketPermissionCollection();
	1139	+ }
	1140	+
	1141	+ /**
	1142	+ * WriteObject is called to save the state of the SocketPermission
	1143	+ * to a stream. The actions are serialized, and the superclass
	1144	+ * takes care of the name.
	1145	+ */
	1146	+ private synchronized void writeObject(java.io.ObjectOutputStream s)
	1147	+ throws IOException
	1148	+ {
	1149	+ // Write out the actions. The superclass takes care of the name
	1150	+ // call getActions to make sure actions field is initialized
	1151	+ if (actions == null)
	1152	+ getActions();
	1153	+ s.defaultWriteObject();
	1154	+ }
	1155	+
	1156	+ /**
	1157	+ * readObject is called to restore the state of the SocketPermission from
	1158	+ * a stream.
	1159	+ */
	1160	+ private synchronized void readObject(java.io.ObjectInputStream s)
	1161	+ throws IOException, ClassNotFoundException
	1162	+ {
	1163	+ // Read in the action, then initialize the rest
	1164	+ s.defaultReadObject();
	1165	+ init(getName(),getMask(actions));
	1166	+ }
	1167	+
	1168	+ /*
	1169	+ public String toString()
	1170	+ {
	1171	+ StringBuffer s = new StringBuffer(super.toString() + "\n" +
	1172	+ "cname = " + cname + "\n" +
	1173	+ "wildcard = " + wildcard + "\n" +
	1174	+ "invalid = " + invalid + "\n" +
	1175	+ "portrange = " + portrange[0] + "," + portrange[1] + "\n");
	1176	+ if (addresses != null) for (int i=0; i<addresses.length; i++) {
	1177	+ s.append( addresses[i].getHostAddress());
	1178	+ s.append("\n");
	1179	+ } else {
	1180	+ s.append("(no addresses)\n");
	1181	+ }
	1182	+
	1183	+ return s.toString();
	1184	+ }
	1185	+
	1186	+ public static void main(String args[]) throws Exception {
	1187	+ SocketPermission this_ = new SocketPermission(args[0], "connect");
	1188	+ SocketPermission that_ = new SocketPermission(args[1], "connect");
	1189	+ System.out.println("-----\n");
	1190	+ System.out.println("this.implies(that) = " + this_.implies(that_));
	1191	+ System.out.println("-----\n");
	1192	+ System.out.println("this = "+this_);
	1193	+ System.out.println("-----\n");
	1194	+ System.out.println("that = "+that_);
	1195	+ System.out.println("-----\n");
	1196	+
	1197	+ SocketPermissionCollection nps = new SocketPermissionCollection();
	1198	+ nps.add(this_);
	1199	+ nps.add(new SocketPermission("www-leland.stanford.edu","connect"));
	1200	+ nps.add(new SocketPermission("www-sun.com","connect"));
	1201	+ System.out.println("nps.implies(that) = " + nps.implies(that_));
	1202	+ System.out.println("-----\n");
	1203	+ }
	1204	+ */
	1205	+}
	1206	+
	1207	+/**
	1208	+
	1209	+if (init'd with IP, key is IP as string)
	1210	+if wildcard, its the wild card
	1211	+else its the cname?
	1212	+
	1213	+ *
	1214	+ * @see java.security.Permission
	1215	+ * @see java.security.Permissions
	1216	+ * @see java.security.PermissionCollection
	1217	+ *
	1218	+ *
	1219	+ * @author Roland Schemers
	1220	+ *
	1221	+ * @serial include
	1222	+ */
	1223	+
	1224	+final class SocketPermissionCollection extends PermissionCollection
	1225	+implements Serializable
	1226	+{
	1227	+ // Not serialized; see serialization section at end of class
	1228	+ private transient List perms;
	1229	+
	1230	+ /**
	1231	+ * Create an empty SocketPermissions object.
	1232	+ *
	1233	+ */
	1234	+
	1235	+ public SocketPermissionCollection() {
	1236	+ perms = new ArrayList();
	1237	+ }
	1238	+
	1239	+ /**
	1240	+ * Adds a permission to the SocketPermissions. The key for the hash is
	1241	+ * the name in the case of wildcards, or all the IP addresses.
	1242	+ *
	1243	+ * @param permission the Permission object to add.
	1244	+ *
	1245	+ * @exception IllegalArgumentException - if the permission is not a
	1246	+ * SocketPermission
	1247	+ *
	1248	+ * @exception SecurityException - if this SocketPermissionCollection object
	1249	+ * has been marked readonly
	1250	+ */
	1251	+
	1252	+ public void add(Permission permission)
	1253	+ {
	1254	+ if (! (permission instanceof SocketPermission))
	1255	+ throw new IllegalArgumentException("invalid permission: "+
	1256	+ permission);
	1257	+ if (isReadOnly())
	1258	+ throw new SecurityException(
	1259	+ "attempt to add a Permission to a readonly PermissionCollection");
	1260	+
	1261	+ // optimization to ensure perms most likely to be tested
	1262	+ // show up early (4301064)
	1263	+ synchronized (this) {
	1264	+ perms.add(0, permission);
	1265	+ }
	1266	+ }
	1267	+
	1268	+ /**
	1269	+ * Check and see if this collection of permissions implies the permissions
	1270	+ * expressed in "permission".
	1271	+ *
	1272	+ * @param p the Permission object to compare
	1273	+ *
	1274	+ * @return true if "permission" is a proper subset of a permission in
	1275	+ * the collection, false if not.
	1276	+ */
	1277	+
	1278	+ public boolean implies(Permission permission)
	1279	+ {
	1280	+ if (! (permission instanceof SocketPermission))
	1281	+ return false;
	1282	+
	1283	+ SocketPermission np = (SocketPermission) permission;
	1284	+
	1285	+ int desired = np.getMask();
	1286	+ int effective = 0;
	1287	+ int needed = desired;
	1288	+
	1289	+ synchronized (this) {
	1290	+ int len = perms.size();
	1291	+ //System.out.println("implies "+np);
	1292	+ for (int i = 0; i < len; i++) {
	1293	+ SocketPermission x = (SocketPermission) perms.get(i);
	1294	+ //System.out.println(" trying "+x);
	1295	+ if (((needed & x.getMask()) != 0) && x.impliesIgnoreMask(np)) {
	1296	+ effective \|= x.getMask();
	1297	+ if ((effective & desired) == desired)
	1298	+ return true;
	1299	+ needed = (desired ^ effective);
	1300	+ }
	1301	+ }
	1302	+ }
	1303	+ return false;
	1304	+ }
	1305	+
	1306	+ /**
	1307	+ * Returns an enumeration of all the SocketPermission objects in the
	1308	+ * container.
	1309	+ *
	1310	+ * @return an enumeration of all the SocketPermission objects.
	1311	+ */
	1312	+
	1313	+ public Enumeration elements() {
	1314	+ // Convert Iterator into Enumeration
	1315	+ synchronized (this) {
	1316	+ return Collections.enumeration(perms);
	1317	+ }
	1318	+ }
	1319	+
	1320	+ private static final long serialVersionUID = 2787186408602843674L;
	1321	+
	1322	+ // Need to maintain serialization interoperability with earlier releases,
	1323	+ // which had the serializable field:
	1324	+
	1325	+ //
	1326	+ // The SocketPermissions for this set.
	1327	+ // @serial
	1328	+ //
	1329	+ // private Vector permissions;
	1330	+
	1331	+ /**
	1332	+ * @serialField permissions java.util.Vector
	1333	+ * A list of the SocketPermissions for this set.
	1334	+ */
	1335	+ private static final ObjectStreamField[] serialPersistentFields = {
	1336	+ new ObjectStreamField("permissions", Vector.class),
	1337	+ };
	1338	+
	1339	+ /**
	1340	+ * @serialData "permissions" field (a Vector containing the SocketPermissions).
	1341	+ */
	1342	+ /*
	1343	+ * Writes the contents of the perms field out as a Vector for
	1344	+ * serialization compatibility with earlier releases.
	1345	+ */
	1346	+ private void writeObject(ObjectOutputStream out) throws IOException {
	1347	+ // Don't call out.defaultWriteObject()
	1348	+
	1349	+ // Write out Vector
	1350	+ Vector permissions = new Vector(perms.size());
	1351	+
	1352	+ synchronized (this) {
	1353	+ permissions.addAll(perms);
	1354	+ }
	1355	+
	1356	+ ObjectOutputStream.PutField pfields = out.putFields();
	1357	+ pfields.put("permissions", permissions);
	1358	+ out.writeFields();
	1359	+ }
	1360	+
	1361	+ /*
	1362	+ * Reads in a Vector of SocketPermissions and saves them in the perms field.
	1363	+ */
	1364	+ private void readObject(ObjectInputStream in) throws IOException,
	1365	+ ClassNotFoundException {
	1366	+ // Don't call in.defaultReadObject()
	1367	+
	1368	+ // Read in serialized fields
	1369	+ ObjectInputStream.GetField gfields = in.readFields();
	1370	+
	1371	+ // Get the one we want
	1372	+ Vector permissions = (Vector)gfields.get("permissions", null);
	1373	+ perms = new ArrayList(permissions.size());
	1374	+ perms.addAll(permissions);
	1375	+ }
	1376	+}

java/pkg/java/net/SocketPermissionCollection.class+0−0

Binary file not shown.

java/pkg/java/net/SocketTimeoutException.class+0−0

Binary file not shown.

java/pkg/java/net/SocketTimeoutException.java+50−0

@@ -0,0 +1,50 @@
	1	+/*
	2	+ * Copyright (c) 2000, 2008, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.net;
	27	+
	28	+/**
	29	+ * Signals that a timeout has occurred on a socket read or accept.
	30	+ *
	31	+ * @since 1.4
	32	+ */
	33	+
	34	+public class SocketTimeoutException extends java.io.InterruptedIOException {
	35	+ private static final long serialVersionUID = -8846654841826352300L;
	36	+
	37	+ /**
	38	+ * Constructs a new SocketTimeoutException with a detail
	39	+ * message.
	40	+ * @param msg the detail message
	41	+ */
	42	+ public SocketTimeoutException(String msg) {
	43	+ super(msg);
	44	+ }
	45	+
	46	+ /**
	47	+ * Construct a new SocketTimeoutException with no detailed message.
	48	+ */
	49	+ public SocketTimeoutException() {}
	50	+}

java/pkg/java/net/SocksConsts.class+0−0

Binary file not shown.

java/pkg/java/net/SocksConsts.java+58−0

@@ -0,0 +1,58 @@
	1	+/*
	2	+ * Copyright (c) 2000, 2001, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+package java.net;
	26	+
	27	+/**
	28	+ * Constants used by the SOCKS protocol implementation.
	29	+ */
	30	+
	31	+interface SocksConsts {
	32	+ static final int PROTO_VERS4 = 4;
	33	+ static final int PROTO_VERS = 5;
	34	+ static final int DEFAULT_PORT = 1080;
	35	+
	36	+ static final int NO_AUTH = 0;
	37	+ static final int GSSAPI = 1;
	38	+ static final int USER_PASSW = 2;
	39	+ static final int NO_METHODS = -1;
	40	+
	41	+ static final int CONNECT = 1;
	42	+ static final int BIND = 2;
	43	+ static final int UDP_ASSOC = 3;
	44	+
	45	+ static final int IPV4 = 1;
	46	+ static final int DOMAIN_NAME = 3;
	47	+ static final int IPV6 = 4;
	48	+
	49	+ static final int REQUEST_OK = 0;
	50	+ static final int GENERAL_FAILURE = 1;
	51	+ static final int NOT_ALLOWED = 2;
	52	+ static final int NET_UNREACHABLE = 3;
	53	+ static final int HOST_UNREACHABLE = 4;
	54	+ static final int CONN_REFUSED = 5;
	55	+ static final int TTL_EXPIRED = 6;
	56	+ static final int CMD_NOT_SUPPORTED = 7;
	57	+ static final int ADDR_TYPE_NOT_SUP = 8;
	58	+}

java/pkg/java/net/SocksSocketImpl$1.class+0−0

Binary file not shown.

java/pkg/java/net/SocksSocketImpl$2.class+0−0

Binary file not shown.

java/pkg/java/net/SocksSocketImpl$3.class+0−0

Binary file not shown.

java/pkg/java/net/SocksSocketImpl$4.class+0−0

Binary file not shown.

java/pkg/java/net/SocksSocketImpl$5.class+0−0

Binary file not shown.

java/pkg/java/net/SocksSocketImpl$6.class+0−0

Binary file not shown.

java/pkg/java/net/SocksSocketImpl.class+0−0

Binary file not shown.

java/pkg/java/net/SocksSocketImpl.java+1085−0

@@ -0,0 +1,1085 @@
	1	+/*
	2	+ * Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+package java.net;
	26	+import java.io.IOException;
	27	+import java.io.InputStream;
	28	+import java.io.OutputStream;
	29	+import java.io.BufferedOutputStream;
	30	+import java.security.AccessController;
	31	+import java.security.PrivilegedExceptionAction;
	32	+import sun.net.SocksProxy;
	33	+import sun.net.www.ParseUtil;
	34	+/* import org.ietf.jgss.; /
	35	+
	36	+/**
	37	+ * SOCKS (V4 & V5) TCP socket implementation (RFC 1928).
	38	+ * This is a subclass of PlainSocketImpl.
	39	+ * Note this class should <b>NOT</b> be public.
	40	+ */
	41	+
	42	+class SocksSocketImpl extends PlainSocketImpl implements SocksConsts {
	43	+ private String server = null;
	44	+ private int serverPort = DEFAULT_PORT;
	45	+ private InetSocketAddress external_address;
	46	+ private boolean useV4 = false;
	47	+ private Socket cmdsock = null;
	48	+ private InputStream cmdIn = null;
	49	+ private OutputStream cmdOut = null;
	50	+ /* true if the Proxy has been set programatically */
	51	+ private boolean applicationSetProxy; /* false */
	52	+
	53	+
	54	+ SocksSocketImpl() {
	55	+ // Nothing needed
	56	+ }
	57	+
	58	+ SocksSocketImpl(String server, int port) {
	59	+ this.server = server;
	60	+ this.serverPort = (port == -1 ? DEFAULT_PORT : port);
	61	+ }
	62	+
	63	+ SocksSocketImpl(Proxy proxy) {
	64	+ SocketAddress a = proxy.address();
	65	+ if (a instanceof InetSocketAddress) {
	66	+ InetSocketAddress ad = (InetSocketAddress) a;
	67	+ // Use getHostString() to avoid reverse lookups
	68	+ server = ad.getHostString();
	69	+ serverPort = ad.getPort();
	70	+ }
	71	+ }
	72	+
	73	+ void setV4() {
	74	+ useV4 = true;
	75	+ }
	76	+
	77	+ private synchronized void privilegedConnect(final String host,
	78	+ final int port,
	79	+ final int timeout)
	80	+ throws IOException
	81	+ {
	82	+ try {
	83	+ AccessController.doPrivileged(
	84	+ new java.security.PrivilegedExceptionAction<Void>() {
	85	+ public Void run() throws IOException {
	86	+ superConnectServer(host, port, timeout);
	87	+ cmdIn = getInputStream();
	88	+ cmdOut = getOutputStream();
	89	+ return null;
	90	+ }
	91	+ });
	92	+ } catch (java.security.PrivilegedActionException pae) {
	93	+ throw (IOException) pae.getException();
	94	+ }
	95	+ }
	96	+
	97	+ private void superConnectServer(String host, int port,
	98	+ int timeout) throws IOException {
	99	+ super.connect(new InetSocketAddress(host, port), timeout);
	100	+ }
	101	+
	102	+ private static int remainingMillis(long deadlineMillis) throws IOException {
	103	+ if (deadlineMillis == 0L)
	104	+ return 0;
	105	+
	106	+ final long remaining = deadlineMillis - System.currentTimeMillis();
	107	+ if (remaining > 0)
	108	+ return (int) remaining;
	109	+
	110	+ throw new SocketTimeoutException();
	111	+ }
	112	+
	113	+ private int readSocksReply(InputStream in, byte[] data) throws IOException {
	114	+ return readSocksReply(in, data, 0L);
	115	+ }
	116	+
	117	+ private int readSocksReply(InputStream in, byte[] data, long deadlineMillis) throws IOException {
	118	+ int len = data.length;
	119	+ int received = 0;
	120	+ for (int attempts = 0; received < len && attempts < 3; attempts++) {
	121	+ int count;
	122	+ try {
	123	+ count = ((SocketInputStream)in).read(data, received, len - received, remainingMillis(deadlineMillis));
	124	+ } catch (SocketTimeoutException e) {
	125	+ throw new SocketTimeoutException("Connect timed out");
	126	+ }
	127	+ if (count < 0)
	128	+ throw new SocketException("Malformed reply from SOCKS server");
	129	+ received += count;
	130	+ }
	131	+ return received;
	132	+ }
	133	+
	134	+ /**
	135	+ * Provides the authentication machanism required by the proxy.
	136	+ */
	137	+ private boolean authenticate(byte method, InputStream in,
	138	+ BufferedOutputStream out) throws IOException {
	139	+ return authenticate(method, in, out, 0L);
	140	+ }
	141	+
	142	+ private boolean authenticate(byte method, InputStream in,
	143	+ BufferedOutputStream out,
	144	+ long deadlineMillis) throws IOException {
	145	+ // No Authentication required. We're done then!
	146	+ if (method == NO_AUTH)
	147	+ return true;
	148	+ /**
	149	+ * User/Password authentication. Try, in that order :
	150	+ * - The application provided Authenticator, if any
	151	+ * - the user.name & no password (backward compatibility behavior).
	152	+ */
	153	+ if (method == USER_PASSW) {
	154	+ String userName;
	155	+ String password = null;
	156	+ final InetAddress addr = InetAddress.getByName(server);
	157	+ PasswordAuthentication pw =
	158	+ java.security.AccessController.doPrivileged(
	159	+ new java.security.PrivilegedAction<PasswordAuthentication>() {
	160	+ public PasswordAuthentication run() {
	161	+ return Authenticator.requestPasswordAuthentication(
	162	+ server, addr, serverPort, "SOCKS5", "SOCKS authentication", null);
	163	+ }
	164	+ });
	165	+ if (pw != null) {
	166	+ userName = pw.getUserName();
	167	+ password = new String(pw.getPassword());
	168	+ } else {
	169	+ userName = java.security.AccessController.doPrivileged(
	170	+ new sun.security.action.GetPropertyAction("user.name"));
	171	+ }
	172	+ if (userName == null)
	173	+ return false;
	174	+ out.write(1);
	175	+ out.write(userName.length());
	176	+ try {
	177	+ out.write(userName.getBytes("ISO-8859-1"));
	178	+ } catch (java.io.UnsupportedEncodingException uee) {
	179	+ assert false;
	180	+ }
	181	+ if (password != null) {
	182	+ out.write(password.length());
	183	+ try {
	184	+ out.write(password.getBytes("ISO-8859-1"));
	185	+ } catch (java.io.UnsupportedEncodingException uee) {
	186	+ assert false;
	187	+ }
	188	+ } else
	189	+ out.write(0);
	190	+ out.flush();
	191	+ byte[] data = new byte[2];
	192	+ int i = readSocksReply(in, data, deadlineMillis);
	193	+ if (i != 2 \|\| data[1] != 0) {
	194	+ /* RFC 1929 specifies that the connection MUST be closed if
	195	+ authentication fails */
	196	+ out.close();
	197	+ in.close();
	198	+ return false;
	199	+ }
	200	+ /* Authentication succeeded */
	201	+ return true;
	202	+ }
	203	+ /**
	204	+ * GSSAPI authentication mechanism.
	205	+ * Unfortunately the RFC seems out of sync with the Reference
	206	+ * implementation. I'll leave this in for future completion.
	207	+ */
	208	+// if (method == GSSAPI) {
	209	+// try {
	210	+// GSSManager manager = GSSManager.getInstance();
	211	+// GSSName name = manager.createName("SERVICE:socks@"+server,
	212	+// null);
	213	+// GSSContext context = manager.createContext(name, null, null,
	214	+// GSSContext.DEFAULT_LIFETIME);
	215	+// context.requestMutualAuth(true);
	216	+// context.requestReplayDet(true);
	217	+// context.requestSequenceDet(true);
	218	+// context.requestCredDeleg(true);
	219	+// byte []inToken = new byte[0];
	220	+// while (!context.isEstablished()) {
	221	+// byte[] outToken
	222	+// = context.initSecContext(inToken, 0, inToken.length);
	223	+// // send the output token if generated
	224	+// if (outToken != null) {
	225	+// out.write(1);
	226	+// out.write(1);
	227	+// out.writeShort(outToken.length);
	228	+// out.write(outToken);
	229	+// out.flush();
	230	+// data = new byte[2];
	231	+// i = readSocksReply(in, data, deadlineMillis);
	232	+// if (i != 2 \|\| data[1] == 0xff) {
	233	+// in.close();
	234	+// out.close();
	235	+// return false;
	236	+// }
	237	+// i = readSocksReply(in, data, deadlineMillis);
	238	+// int len = 0;
	239	+// len = ((int)data[0] & 0xff) << 8;
	240	+// len += data[1];
	241	+// data = new byte[len];
	242	+// i = readSocksReply(in, data, deadlineMillis);
	243	+// if (i == len)
	244	+// return true;
	245	+// in.close();
	246	+// out.close();
	247	+// }
	248	+// }
	249	+// } catch (GSSException e) {
	250	+// /* RFC 1961 states that if Context initialisation fails the connection
	251	+// MUST be closed */
	252	+// e.printStackTrace();
	253	+// in.close();
	254	+// out.close();
	255	+// }
	256	+// }
	257	+ return false;
	258	+ }
	259	+
	260	+ private void connectV4(InputStream in, OutputStream out,
	261	+ InetSocketAddress endpoint,
	262	+ long deadlineMillis) throws IOException {
	263	+ if (!(endpoint.getAddress() instanceof Inet4Address)) {
	264	+ throw new SocketException("SOCKS V4 requires IPv4 only addresses");
	265	+ }
	266	+ out.write(PROTO_VERS4);
	267	+ out.write(CONNECT);
	268	+ out.write((endpoint.getPort() >> 8) & 0xff);
	269	+ out.write((endpoint.getPort() >> 0) & 0xff);
	270	+ out.write(endpoint.getAddress().getAddress());
	271	+ String userName = getUserName();
	272	+ try {
	273	+ out.write(userName.getBytes("ISO-8859-1"));
	274	+ } catch (java.io.UnsupportedEncodingException uee) {
	275	+ assert false;
	276	+ }
	277	+ out.write(0);
	278	+ out.flush();
	279	+ byte[] data = new byte[8];
	280	+ int n = readSocksReply(in, data, deadlineMillis);
	281	+ if (n != 8)
	282	+ throw new SocketException("Reply from SOCKS server has bad length: " + n);
	283	+ if (data[0] != 0 && data[0] != 4)
	284	+ throw new SocketException("Reply from SOCKS server has bad version");
	285	+ SocketException ex = null;
	286	+ switch (data[1]) {
	287	+ case 90:
	288	+ // Success!
	289	+ external_address = endpoint;
	290	+ break;
	291	+ case 91:
	292	+ ex = new SocketException("SOCKS request rejected");
	293	+ break;
	294	+ case 92:
	295	+ ex = new SocketException("SOCKS server couldn't reach destination");
	296	+ break;
	297	+ case 93:
	298	+ ex = new SocketException("SOCKS authentication failed");
	299	+ break;
	300	+ default:
	301	+ ex = new SocketException("Reply from SOCKS server contains bad status");
	302	+ break;
	303	+ }
	304	+ if (ex != null) {
	305	+ in.close();
	306	+ out.close();
	307	+ throw ex;
	308	+ }
	309	+ }
	310	+
	311	+ /**
	312	+ * Connects the Socks Socket to the specified endpoint. It will first
	313	+ * connect to the SOCKS proxy and negotiate the access. If the proxy
	314	+ * grants the connections, then the connect is successful and all
	315	+ * further traffic will go to the "real" endpoint.
	316	+ *
	317	+ * @param endpoint the <code>SocketAddress</code> to connect to.
	318	+ * @param timeout the timeout value in milliseconds
	319	+ * @throws IOException if the connection can't be established.
	320	+ * @throws SecurityException if there is a security manager and it
	321	+ * doesn't allow the connection
	322	+ * @throws IllegalArgumentException if endpoint is null or a
	323	+ * SocketAddress subclass not supported by this socket
	324	+ */
	325	+ @Override
	326	+ protected void connect(SocketAddress endpoint, int timeout) throws IOException {
	327	+ final long deadlineMillis;
	328	+
	329	+ if (timeout == 0) {
	330	+ deadlineMillis = 0L;
	331	+ } else {
	332	+ long finish = System.currentTimeMillis() + timeout;
	333	+ deadlineMillis = finish < 0 ? Long.MAX_VALUE : finish;
	334	+ }
	335	+
	336	+ SecurityManager security = System.getSecurityManager();
	337	+ if (endpoint == null \|\| !(endpoint instanceof InetSocketAddress))
	338	+ throw new IllegalArgumentException("Unsupported address type");
	339	+ InetSocketAddress epoint = (InetSocketAddress) endpoint;
	340	+ if (security != null) {
	341	+ if (epoint.isUnresolved())
	342	+ security.checkConnect(epoint.getHostName(),
	343	+ epoint.getPort());
	344	+ else
	345	+ security.checkConnect(epoint.getAddress().getHostAddress(),
	346	+ epoint.getPort());
	347	+ }
	348	+ if (server == null) {
	349	+ // This is the general case
	350	+ // server is not null only when the socket was created with a
	351	+ // specified proxy in which case it does bypass the ProxySelector
	352	+ ProxySelector sel = java.security.AccessController.doPrivileged(
	353	+ new java.security.PrivilegedAction<ProxySelector>() {
	354	+ public ProxySelector run() {
	355	+ return ProxySelector.getDefault();
	356	+ }
	357	+ });
	358	+ if (sel == null) {
	359	+ /*
	360	+ * No default proxySelector --> direct connection
	361	+ */
	362	+ super.connect(epoint, remainingMillis(deadlineMillis));
	363	+ return;
	364	+ }
	365	+ URI uri;
	366	+ // Use getHostString() to avoid reverse lookups
	367	+ String host = epoint.getHostString();
	368	+ // IPv6 litteral?
	369	+ if (epoint.getAddress() instanceof Inet6Address &&
	370	+ (!host.startsWith("[")) && (host.indexOf(":") >= 0)) {
	371	+ host = "[" + host + "]";
	372	+ }
	373	+ try {
	374	+ uri = new URI("socket://" + ParseUtil.encodePath(host) + ":"+ epoint.getPort());
	375	+ } catch (URISyntaxException e) {
	376	+ // This shouldn't happen
	377	+ assert false : e;
	378	+ uri = null;
	379	+ }
	380	+ Proxy p = null;
	381	+ IOException savedExc = null;
	382	+ java.util.Iterator<Proxy> iProxy = null;
	383	+ iProxy = sel.select(uri).iterator();
	384	+ if (iProxy == null \|\| !(iProxy.hasNext())) {
	385	+ super.connect(epoint, remainingMillis(deadlineMillis));
	386	+ return;
	387	+ }
	388	+ while (iProxy.hasNext()) {
	389	+ p = iProxy.next();
	390	+ if (p == null \|\| p == Proxy.NO_PROXY) {
	391	+ super.connect(epoint, remainingMillis(deadlineMillis));
	392	+ return;
	393	+ }
	394	+ if (p.type() != Proxy.Type.SOCKS)
	395	+ throw new SocketException("Unknown proxy type : " + p.type());
	396	+ if (!(p.address() instanceof InetSocketAddress))
	397	+ throw new SocketException("Unknow address type for proxy: " + p);
	398	+ // Use getHostString() to avoid reverse lookups
	399	+ server = ((InetSocketAddress) p.address()).getHostString();
	400	+ serverPort = ((InetSocketAddress) p.address()).getPort();
	401	+ if (p instanceof SocksProxy) {
	402	+ if (((SocksProxy)p).protocolVersion() == 4) {
	403	+ useV4 = true;
	404	+ }
	405	+ }
	406	+
	407	+ // Connects to the SOCKS server
	408	+ try {
	409	+ privilegedConnect(server, serverPort, remainingMillis(deadlineMillis));
	410	+ // Worked, let's get outta here
	411	+ break;
	412	+ } catch (IOException e) {
	413	+ // Ooops, let's notify the ProxySelector
	414	+ sel.connectFailed(uri,p.address(),e);
	415	+ server = null;
	416	+ serverPort = -1;
	417	+ savedExc = e;
	418	+ // Will continue the while loop and try the next proxy
	419	+ }
	420	+ }
	421	+
	422	+ /*
	423	+ * If server is still null at this point, none of the proxy
	424	+ * worked
	425	+ */
	426	+ if (server == null) {
	427	+ throw new SocketException("Can't connect to SOCKS proxy:"
	428	+ + savedExc.getMessage());
	429	+ }
	430	+ } else {
	431	+ // Connects to the SOCKS server
	432	+ try {
	433	+ privilegedConnect(server, serverPort, remainingMillis(deadlineMillis));
	434	+ } catch (IOException e) {
	435	+ throw new SocketException(e.getMessage());
	436	+ }
	437	+ }
	438	+
	439	+ // cmdIn & cmdOut were intialized during the privilegedConnect() call
	440	+ BufferedOutputStream out = new BufferedOutputStream(cmdOut, 512);
	441	+ InputStream in = cmdIn;
	442	+
	443	+ if (useV4) {
	444	+ // SOCKS Protocol version 4 doesn't know how to deal with
	445	+ // DOMAIN type of addresses (unresolved addresses here)
	446	+ if (epoint.isUnresolved())
	447	+ throw new UnknownHostException(epoint.toString());
	448	+ connectV4(in, out, epoint, deadlineMillis);
	449	+ return;
	450	+ }
	451	+
	452	+ // This is SOCKS V5
	453	+ out.write(PROTO_VERS);
	454	+ out.write(2);
	455	+ out.write(NO_AUTH);
	456	+ out.write(USER_PASSW);
	457	+ out.flush();
	458	+ byte[] data = new byte[2];
	459	+ int i = readSocksReply(in, data, deadlineMillis);
	460	+ if (i != 2 \|\| ((int)data[0]) != PROTO_VERS) {
	461	+ // Maybe it's not a V5 sever after all
	462	+ // Let's try V4 before we give up
	463	+ // SOCKS Protocol version 4 doesn't know how to deal with
	464	+ // DOMAIN type of addresses (unresolved addresses here)
	465	+ if (epoint.isUnresolved())
	466	+ throw new UnknownHostException(epoint.toString());
	467	+ connectV4(in, out, epoint, deadlineMillis);
	468	+ return;
	469	+ }
	470	+ if (((int)data[1]) == NO_METHODS)
	471	+ throw new SocketException("SOCKS : No acceptable methods");
	472	+ if (!authenticate(data[1], in, out, deadlineMillis)) {
	473	+ throw new SocketException("SOCKS : authentication failed");
	474	+ }
	475	+ out.write(PROTO_VERS);
	476	+ out.write(CONNECT);
	477	+ out.write(0);
	478	+ /* Test for IPV4/IPV6/Unresolved */
	479	+ if (epoint.isUnresolved()) {
	480	+ out.write(DOMAIN_NAME);
	481	+ out.write(epoint.getHostName().length());
	482	+ try {
	483	+ out.write(epoint.getHostName().getBytes("ISO-8859-1"));
	484	+ } catch (java.io.UnsupportedEncodingException uee) {
	485	+ assert false;
	486	+ }
	487	+ out.write((epoint.getPort() >> 8) & 0xff);
	488	+ out.write((epoint.getPort() >> 0) & 0xff);
	489	+ } else if (epoint.getAddress() instanceof Inet6Address) {
	490	+ out.write(IPV6);
	491	+ out.write(epoint.getAddress().getAddress());
	492	+ out.write((epoint.getPort() >> 8) & 0xff);
	493	+ out.write((epoint.getPort() >> 0) & 0xff);
	494	+ } else {
	495	+ out.write(IPV4);
	496	+ out.write(epoint.getAddress().getAddress());
	497	+ out.write((epoint.getPort() >> 8) & 0xff);
	498	+ out.write((epoint.getPort() >> 0) & 0xff);
	499	+ }
	500	+ out.flush();
	501	+ data = new byte[4];
	502	+ i = readSocksReply(in, data, deadlineMillis);
	503	+ if (i != 4)
	504	+ throw new SocketException("Reply from SOCKS server has bad length");
	505	+ SocketException ex = null;
	506	+ int len;
	507	+ byte[] addr;
	508	+ switch (data[1]) {
	509	+ case REQUEST_OK:
	510	+ // success!
	511	+ switch(data[3]) {
	512	+ case IPV4:
	513	+ addr = new byte[4];
	514	+ i = readSocksReply(in, addr, deadlineMillis);
	515	+ if (i != 4)
	516	+ throw new SocketException("Reply from SOCKS server badly formatted");
	517	+ data = new byte[2];
	518	+ i = readSocksReply(in, data, deadlineMillis);
	519	+ if (i != 2)
	520	+ throw new SocketException("Reply from SOCKS server badly formatted");
	521	+ break;
	522	+ case DOMAIN_NAME:
	523	+ len = data[1];
	524	+ byte[] host = new byte[len];
	525	+ i = readSocksReply(in, host, deadlineMillis);
	526	+ if (i != len)
	527	+ throw new SocketException("Reply from SOCKS server badly formatted");
	528	+ data = new byte[2];
	529	+ i = readSocksReply(in, data, deadlineMillis);
	530	+ if (i != 2)
	531	+ throw new SocketException("Reply from SOCKS server badly formatted");
	532	+ break;
	533	+ case IPV6:
	534	+ len = data[1];
	535	+ addr = new byte[len];
	536	+ i = readSocksReply(in, addr, deadlineMillis);
	537	+ if (i != len)
	538	+ throw new SocketException("Reply from SOCKS server badly formatted");
	539	+ data = new byte[2];
	540	+ i = readSocksReply(in, data, deadlineMillis);
	541	+ if (i != 2)
	542	+ throw new SocketException("Reply from SOCKS server badly formatted");
	543	+ break;
	544	+ default:
	545	+ ex = new SocketException("Reply from SOCKS server contains wrong code");
	546	+ break;
	547	+ }
	548	+ break;
	549	+ case GENERAL_FAILURE:
	550	+ ex = new SocketException("SOCKS server general failure");
	551	+ break;
	552	+ case NOT_ALLOWED:
	553	+ ex = new SocketException("SOCKS: Connection not allowed by ruleset");
	554	+ break;
	555	+ case NET_UNREACHABLE:
	556	+ ex = new SocketException("SOCKS: Network unreachable");
	557	+ break;
	558	+ case HOST_UNREACHABLE:
	559	+ ex = new SocketException("SOCKS: Host unreachable");
	560	+ break;
	561	+ case CONN_REFUSED:
	562	+ ex = new SocketException("SOCKS: Connection refused");
	563	+ break;
	564	+ case TTL_EXPIRED:
	565	+ ex = new SocketException("SOCKS: TTL expired");
	566	+ break;
	567	+ case CMD_NOT_SUPPORTED:
	568	+ ex = new SocketException("SOCKS: Command not supported");
	569	+ break;
	570	+ case ADDR_TYPE_NOT_SUP:
	571	+ ex = new SocketException("SOCKS: address type not supported");
	572	+ break;
	573	+ }
	574	+ if (ex != null) {
	575	+ in.close();
	576	+ out.close();
	577	+ throw ex;
	578	+ }
	579	+ external_address = epoint;
	580	+ }
	581	+
	582	+ private void bindV4(InputStream in, OutputStream out,
	583	+ InetAddress baddr,
	584	+ int lport) throws IOException {
	585	+ if (!(baddr instanceof Inet4Address)) {
	586	+ throw new SocketException("SOCKS V4 requires IPv4 only addresses");
	587	+ }
	588	+ super.bind(baddr, lport);
	589	+ byte[] addr1 = baddr.getAddress();
	590	+ /* Test for AnyLocal */
	591	+ InetAddress naddr = baddr;
	592	+ if (naddr.isAnyLocalAddress()) {
	593	+ naddr = cmdsock.getLocalAddress();
	594	+ addr1 = naddr.getAddress();
	595	+ }
	596	+ out.write(PROTO_VERS4);
	597	+ out.write(BIND);
	598	+ out.write((super.getLocalPort() >> 8) & 0xff);
	599	+ out.write((super.getLocalPort() >> 0) & 0xff);
	600	+ out.write(addr1);
	601	+ String userName = getUserName();
	602	+ try {
	603	+ out.write(userName.getBytes("ISO-8859-1"));
	604	+ } catch (java.io.UnsupportedEncodingException uee) {
	605	+ assert false;
	606	+ }
	607	+ out.write(0);
	608	+ out.flush();
	609	+ byte[] data = new byte[8];
	610	+ int n = readSocksReply(in, data);
	611	+ if (n != 8)
	612	+ throw new SocketException("Reply from SOCKS server has bad length: " + n);
	613	+ if (data[0] != 0 && data[0] != 4)
	614	+ throw new SocketException("Reply from SOCKS server has bad version");
	615	+ SocketException ex = null;
	616	+ switch (data[1]) {
	617	+ case 90:
	618	+ // Success!
	619	+ external_address = new InetSocketAddress(baddr, lport);
	620	+ break;
	621	+ case 91:
	622	+ ex = new SocketException("SOCKS request rejected");
	623	+ break;
	624	+ case 92:
	625	+ ex = new SocketException("SOCKS server couldn't reach destination");
	626	+ break;
	627	+ case 93:
	628	+ ex = new SocketException("SOCKS authentication failed");
	629	+ break;
	630	+ default:
	631	+ ex = new SocketException("Reply from SOCKS server contains bad status");
	632	+ break;
	633	+ }
	634	+ if (ex != null) {
	635	+ in.close();
	636	+ out.close();
	637	+ throw ex;
	638	+ }
	639	+
	640	+ }
	641	+
	642	+ /**
	643	+ * Sends the Bind request to the SOCKS proxy. In the SOCKS protocol, bind
	644	+ * means "accept incoming connection from", so the SocketAddress is the
	645	+ * the one of the host we do accept connection from.
	646	+ *
	647	+ * @param addr the Socket address of the remote host.
	648	+ * @exception IOException if an I/O error occurs when binding this socket.
	649	+ */
	650	+ protected synchronized void socksBind(InetSocketAddress saddr) throws IOException {
	651	+ if (socket != null) {
	652	+ // this is a client socket, not a server socket, don't
	653	+ // call the SOCKS proxy for a bind!
	654	+ return;
	655	+ }
	656	+
	657	+ // Connects to the SOCKS server
	658	+
	659	+ if (server == null) {
	660	+ // This is the general case
	661	+ // server is not null only when the socket was created with a
	662	+ // specified proxy in which case it does bypass the ProxySelector
	663	+ ProxySelector sel = java.security.AccessController.doPrivileged(
	664	+ new java.security.PrivilegedAction<ProxySelector>() {
	665	+ public ProxySelector run() {
	666	+ return ProxySelector.getDefault();
	667	+ }
	668	+ });
	669	+ if (sel == null) {
	670	+ /*
	671	+ * No default proxySelector --> direct connection
	672	+ */
	673	+ return;
	674	+ }
	675	+ URI uri;
	676	+ // Use getHostString() to avoid reverse lookups
	677	+ String host = saddr.getHostString();
	678	+ // IPv6 litteral?
	679	+ if (saddr.getAddress() instanceof Inet6Address &&
	680	+ (!host.startsWith("[")) && (host.indexOf(":") >= 0)) {
	681	+ host = "[" + host + "]";
	682	+ }
	683	+ try {
	684	+ uri = new URI("serversocket://" + ParseUtil.encodePath(host) + ":"+ saddr.getPort());
	685	+ } catch (URISyntaxException e) {
	686	+ // This shouldn't happen
	687	+ assert false : e;
	688	+ uri = null;
	689	+ }
	690	+ Proxy p = null;
	691	+ Exception savedExc = null;
	692	+ java.util.Iterator<Proxy> iProxy = null;
	693	+ iProxy = sel.select(uri).iterator();
	694	+ if (iProxy == null \|\| !(iProxy.hasNext())) {
	695	+ return;
	696	+ }
	697	+ while (iProxy.hasNext()) {
	698	+ p = iProxy.next();
	699	+ if (p == null \|\| p == Proxy.NO_PROXY) {
	700	+ return;
	701	+ }
	702	+ if (p.type() != Proxy.Type.SOCKS)
	703	+ throw new SocketException("Unknown proxy type : " + p.type());
	704	+ if (!(p.address() instanceof InetSocketAddress))
	705	+ throw new SocketException("Unknow address type for proxy: " + p);
	706	+ // Use getHostString() to avoid reverse lookups
	707	+ server = ((InetSocketAddress) p.address()).getHostString();
	708	+ serverPort = ((InetSocketAddress) p.address()).getPort();
	709	+ if (p instanceof SocksProxy) {
	710	+ if (((SocksProxy)p).protocolVersion() == 4) {
	711	+ useV4 = true;
	712	+ }
	713	+ }
	714	+
	715	+ // Connects to the SOCKS server
	716	+ try {
	717	+ AccessController.doPrivileged(
	718	+ new PrivilegedExceptionAction<Void>() {
	719	+ public Void run() throws Exception {
	720	+ cmdsock = new Socket(new PlainSocketImpl());
	721	+ cmdsock.connect(new InetSocketAddress(server, serverPort));
	722	+ cmdIn = cmdsock.getInputStream();
	723	+ cmdOut = cmdsock.getOutputStream();
	724	+ return null;
	725	+ }
	726	+ });
	727	+ } catch (Exception e) {
	728	+ // Ooops, let's notify the ProxySelector
	729	+ sel.connectFailed(uri,p.address(),new SocketException(e.getMessage()));
	730	+ server = null;
	731	+ serverPort = -1;
	732	+ cmdsock = null;
	733	+ savedExc = e;
	734	+ // Will continue the while loop and try the next proxy
	735	+ }
	736	+ }
	737	+
	738	+ /*
	739	+ * If server is still null at this point, none of the proxy
	740	+ * worked
	741	+ */
	742	+ if (server == null \|\| cmdsock == null) {
	743	+ throw new SocketException("Can't connect to SOCKS proxy:"
	744	+ + savedExc.getMessage());
	745	+ }
	746	+ } else {
	747	+ try {
	748	+ AccessController.doPrivileged(
	749	+ new PrivilegedExceptionAction<Void>() {
	750	+ public Void run() throws Exception {
	751	+ cmdsock = new Socket(new PlainSocketImpl());
	752	+ cmdsock.connect(new InetSocketAddress(server, serverPort));
	753	+ cmdIn = cmdsock.getInputStream();
	754	+ cmdOut = cmdsock.getOutputStream();
	755	+ return null;
	756	+ }
	757	+ });
	758	+ } catch (Exception e) {
	759	+ throw new SocketException(e.getMessage());
	760	+ }
	761	+ }
	762	+ BufferedOutputStream out = new BufferedOutputStream(cmdOut, 512);
	763	+ InputStream in = cmdIn;
	764	+ if (useV4) {
	765	+ bindV4(in, out, saddr.getAddress(), saddr.getPort());
	766	+ return;
	767	+ }
	768	+ out.write(PROTO_VERS);
	769	+ out.write(2);
	770	+ out.write(NO_AUTH);
	771	+ out.write(USER_PASSW);
	772	+ out.flush();
	773	+ byte[] data = new byte[2];
	774	+ int i = readSocksReply(in, data);
	775	+ if (i != 2 \|\| ((int)data[0]) != PROTO_VERS) {
	776	+ // Maybe it's not a V5 sever after all
	777	+ // Let's try V4 before we give up
	778	+ bindV4(in, out, saddr.getAddress(), saddr.getPort());
	779	+ return;
	780	+ }
	781	+ if (((int)data[1]) == NO_METHODS)
	782	+ throw new SocketException("SOCKS : No acceptable methods");
	783	+ if (!authenticate(data[1], in, out)) {
	784	+ throw new SocketException("SOCKS : authentication failed");
	785	+ }
	786	+ // We're OK. Let's issue the BIND command.
	787	+ out.write(PROTO_VERS);
	788	+ out.write(BIND);
	789	+ out.write(0);
	790	+ int lport = saddr.getPort();
	791	+ if (saddr.isUnresolved()) {
	792	+ out.write(DOMAIN_NAME);
	793	+ out.write(saddr.getHostName().length());
	794	+ try {
	795	+ out.write(saddr.getHostName().getBytes("ISO-8859-1"));
	796	+ } catch (java.io.UnsupportedEncodingException uee) {
	797	+ assert false;
	798	+ }