Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
JDK 1.1 Source Code Directory
JDK 1.1 source code directory contains Java source code for JDK 1.1 core classes:
"C:\fyicenter\jdk-1.1.8\src".
Here is the list of Java classes of the JDK 1.1 source code:
✍: FYIcenter
⏎ java/net/InetAddress.java
/* * @(#)InetAddress.java 1.47 01/12/10 * * Copyright 2002 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package java.net; import java.util.Hashtable; /** * This class represents an Internet Protocol (IP) address. * <p> * Applications should use the methods <code>getLocalHost</code>, * <code>getByName</code>, or <code>getAllByName</code> to * create a new <code>InetAddress</code> instance. * * @author Chris Warth * @version 1.47, 12/10/01 * @see java.net.InetAddress#getAllByName(java.lang.String) * @see java.net.InetAddress#getByName(java.lang.String) * @see java.net.InetAddress#getLocalHost() * @since JDK1.0 */ public final class InetAddress implements java.io.Serializable { String hostName; int address; // Currently we only deal effectively with 32-bit addresses. // However this field can be expanded to be a byte array // or a 64-bit quantity without too much effort. int family; /** use serialVersionUID from JDK 1.0.2 for interoperability */ private static final long serialVersionUID = 3286316764910316507L; /* * Load net library into runtime. */ static { System.loadLibrary("net"); } /** * Constructor for the Socket.accept() method. * This creates an empty InetAddress, which is filled in by * the accept() method. This InetAddress, however, is not * put in the address cache, since it is not created by name. */ InetAddress() { family = impl.getInetFamily(); } /** * Creates an InetAddress with the specified host name and IP address. * @param hostName the specified host name * @param addr the specified IP address. The address is expected in * network byte order. * @exception UnknownHostException If the address is unknown. */ InetAddress(String hostName, byte addr[]) { this.hostName = new String(hostName); this.family = impl.getInetFamily(); /* * We must be careful here to maintain the network byte * order of the address. As it comes in, the most * significant byte of the address is in addr[0]. It * actually doesn't matter what order they end up in the * array, as long as it is documented and consistent. */ address = addr[3] & 0xFF; address |= ((addr[2] << 8) & 0xFF00); address |= ((addr[1] << 16) & 0xFF0000); address |= ((addr[0] << 24) & 0xFF000000); } /** * Utility routine to check if the InetAddress is a * IP multicast address. IP multicast address is a Class D * address i.e first four bits of the address are 1110. * @since JDK1.1 */ public boolean isMulticastAddress() { return ((address & 0xf0000000) == 0xe0000000); } /** * Returns the fully qualified host name for this address. * If the host is equal to null, then this address refers to any * of the local machine's available network addresses. * * @return the fully qualified host name for this address. * @since JDK1.0 */ public String getHostName() { if (hostName == null) { try { hostName = new String(impl.getHostByAddr(address)); InetAddress[] arr = (InetAddress[])addressCache.get(hostName); if(arr != null) { for(int i = 0; i < arr.length; i++) { if(hostName.equalsIgnoreCase(arr[i].hostName) && address != arr[i].address) { /* This means someone's playing funny games with DNS * This hostName used to have one IP address, now it * has another. At any rate, don't let them "see" * the new hostName, and don't cache it either. */ hostName = getHostAddress(); break; } } } else { /* hostname wasn't in cache before. It's a real hostname, * not "%d.%d.%d.%d" so cache it */ arr = new InetAddress[1]; arr[0] = this; addressCache.put(hostName, arr); } /* finally check to see if calling code is allowed to know * the hostname for this IP address, ie, connect to the host */ SecurityManager sec = System.getSecurityManager(); if (sec != null && !sec.getInCheck()) { sec.checkConnect(hostName, -1); } } catch (SecurityException e) { hostName = getHostAddress(); } catch (UnknownHostException e) { hostName = getHostAddress(); } } return hostName; } /** * Returns the raw IP address of this <code>InetAddress</code> * object. The result is in network byte order: the highest order * byte of the address is in <code>getAddress()[0]</code>. * * @return the raw IP address of this object. * @since JDK1.0 */ public byte[] getAddress() { byte[] addr = new byte[4]; addr[0] = (byte) ((address >>> 24) & 0xFF); addr[1] = (byte) ((address >>> 16) & 0xFF); addr[2] = (byte) ((address >>> 8) & 0xFF); addr[3] = (byte) (address & 0xFF); return addr; } /** * Returns the IP address string "%d.%d.%d.%d" * @return raw IP address in a string format * @since JDK1.1 */ public String getHostAddress() { return ((address >>> 24) & 0xFF) + "." + ((address >>> 16) & 0xFF) + "." + ((address >>> 8) & 0xFF) + "." + ((address >>> 0) & 0xFF); } /** * Returns a hashcode for this IP address. * * @return a hash code value for this IP address. * @since JDK1.0 */ public int hashCode() { return address; } /** * Compares this object against the specified object. * The result is <code>true</code> if and only if the argument is * not <code>null</code> and it represents the same IP address as * this object. * <p> * Two instances of <code>InetAddress</code> represent the same IP * address if the length of the byte arrays returned by * <code>getAddress</code> is the same for both, and each of the * array components is the same for the byte arrays. * * @param obj the object to compare against. * @return <code>true</code> if the objects are the same; * <code>false</code> otherwise. * @see java.net.InetAddress#getAddress() * @since JDK1.0 */ public boolean equals(Object obj) { return (obj != null) && (obj instanceof InetAddress) && (((InetAddress)obj).address == address); } /** * Converts this IP address to a <code>String</code>. * * @return a string representation of this IP address. * @since JDK1.0 */ public String toString() { return getHostName() + "/" + getHostAddress(); } /* * Cached addresses - our own litle nis, not! * * Do not purge cache of numerical IP addresses, since * duplicate dynamic DNS name lookups can leave the system * vulnerable to hostname spoofing attacks. Once a hostname * has been looked up in DNS and entered into the Java cache, * from then on, the hostname is translated to IP address only * via the cache. */ static Hashtable addressCache = new Hashtable(); static InetAddress unknownAddress; static InetAddress anyLocalAddress; static InetAddress localHost; static InetAddress[] unknown_array; // put THIS in cache static InetAddressImpl impl; /* * generic localHost to give back to applets * - private so not API delta */ private static InetAddress loopbackHost; static { /* * Property "impl.prefix" will be prepended to the classname of the * implementation object we instantiate, to which we delegate the real work * (like native methods). This property can vary across implementations * of the java.* classes. The default is an empty String "". */ String prefix = System.getProperty("impl.prefix", ""); try { impl = null; impl = (InetAddressImpl)(Class.forName("java.net." + prefix + "InetAddressImpl") .newInstance()); } catch (ClassNotFoundException e) { System.err.println("Class not found: java.net." + prefix + "InetAddressImpl:\ncheck impl.prefix property " + "in your properties file."); } catch (InstantiationException e) { System.err.println("Could not instantiate: java.net." + prefix + "InetAddressImpl:\ncheck impl.prefix property " + "in your properties file."); } catch (IllegalAccessException e) { System.err.println("Cannot access class: java.net." + prefix + "InetAddressImpl:\ncheck impl.prefix property " + "in your properties file."); } if (impl == null) { try { impl = (InetAddressImpl)(Class.forName("java.net.InetAddressImpl") .newInstance()); } catch (Exception e) { throw new Error("System property impl.prefix incorrect"); } } unknownAddress = new InetAddress(); anyLocalAddress = new InetAddress(); impl.makeAnyLocalAddress(anyLocalAddress); byte[] IP = new byte[4]; IP[0] = 0x7F; IP[1] = 0x00; IP[2] = 0x00; IP[3] = 0x01; loopbackHost = new InetAddress("localhost", IP); /* find the local host name */ try { localHost = new InetAddress(); localHost.hostName = impl.getLocalHostName(); /* we explicitly leave the address of the local host * uninitialized. A DNS lookup in this, the static * initializer, will cause a machine disconnected * from the network to hang - it'll be trying to query * a DNS server that isn't there. * * Instead, we just get the hostname of the local host. * The native code for this just calls gethostname() * which should be pretty innocuous - it shouldn't try * to contact a DNS server. If any application * calls InetAddress.getLocalHost(), we initialize * the local host's address there if not already initialized. * * Note that for this to work it is also essential that * the localHost InetAddress is _NOT_ put into the address cache * here in the static initializer (which happens if we call * getByName() from the static initializer). It _IS_ OK * to put it in the addressCache after initialization. * * The unitialized state of the localHost's address is -1, * or IP address 255.255.255.255 which we know cannot be * a legal host address. */ localHost.address = -1; } catch (Exception ex) { /* this shouldn't happen */ localHost = unknownAddress; } /* cache the name/address pair "0.0.0.0"/0.0.0.0 */ String unknownByAddr = new String("0.0.0.0"); unknown_array = new InetAddress[1]; unknown_array[0] = new InetAddress(unknownByAddr, unknownAddress.getAddress()); addressCache.put(unknownByAddr, unknown_array); } /** * Determines the IP address of a host, given the host's name. The * host name can either be a machine name, such as * "<code>java.sun.com</code>", or a string representing its IP * address, such as "<code>206.26.48.100</code>". * * @param host the specified host, or <code>null</code> for the * local host. * @return an IP address for the given host name. * @exception UnknownHostException if no IP address for the * <code>host</code> could be found. * @since JDK1.0 */ public static InetAddress getByName(String host) throws UnknownHostException { Object obj = null; if (host == null || host.length() == 0) { return loopbackHost; } if (!Character.isDigit(host.charAt(0))) { return getAllByName0(host)[0]; } else { /* The string (probably) represents a numerical IP address. * Parse it into an int, don't do uneeded reverese lookup, * leave hostName null, don't cache. If it isn't an IP address, * (i.e., not "%d.%d.%d.%d") or if any element > 0xFF, * we treat it as a hostname, and lookup that way. * This seems to be 100% compliant to the RFC1123 spec: * a partial hostname like 3com.domain4 is technically valid. */ int IP = 0x00; int hitDots = 0; char[] data = host.toCharArray(); for(int i = 0; i < data.length; i++) { char c = data[i]; if (c < 48 || c > 57) { // !digit return getAllByName0(host)[0]; } int b = 0x00; while(c != '.') { if (c < 48 || c > 57) { // !digit return getAllByName0(host)[0]; } b = b*10 + c - '0'; if (++i >= data.length) break; c = data[i]; } if(b > 0xFF) { /* bogus - bigger than a byte */ return getAllByName0(host)[0]; } IP = (IP << 8) + b; hitDots++; } if(hitDots != 4 || host.endsWith(".")) { return getAllByName0(host)[0]; } InetAddress in = new InetAddress(); in.address = IP; in.hostName = null; return in; } } /** * Determines all the IP addresses of a host, given the host's name. * The host name can either be a machine name, such as * "<code>java.sun.com</code>", or a string representing * its IP address, such as "<code>206.26.48.100</code>". * * @param host the name of the host. * @return an array of all the IP addresses for a given host name. * @exception UnknownHostException if no IP address for the * <code>host</code> could be found. * @since JDK1.0 */ public static InetAddress getAllByName(String host)[] throws UnknownHostException { if (host == null || host.length() == 0) { throw new UnknownHostException("empty string"); } if(Character.isDigit(host.charAt(0))) { InetAddress[] ret = new InetAddress[1]; ret[0] = getByName(host); return ret; } else { return getAllByName0(host); } } private static InetAddress[] getAllByName0 (String host) throws UnknownHostException { /* If it gets here it is presumed to be a hostname */ /* Cache.get can return: null, unknownAddress, or InetAddress[] */ Object obj = null; Object objcopy = null; /* make sure the connection to the host is allowed, before we * give out a hostname */ SecurityManager security = System.getSecurityManager(); if (security != null && !security.getInCheck()) { security.checkConnect(host, -1); } synchronized (addressCache) { obj = addressCache.get(host); /* If no entry in cache, then do the host lookup */ if (obj == null) { try { /* * Do not put the call to lookup() inside the * constructor. if you do you will still be * allocating space when the lookup fails. */ byte[][] byte_array = impl.lookupAllHostAddr(host); InetAddress[] addr_array = new InetAddress[byte_array.length]; for (int i = 0; i < byte_array.length; i++) { byte addr[] = byte_array[i]; addr_array[i] = new InetAddress(host, addr); } obj = addr_array; } catch (UnknownHostException e) { obj = unknown_array; } if (obj != unknown_array) addressCache.put(host, obj); } } /* end synchronized block */ if (obj == unknown_array) { /* * We currently cache the fact that a host is unknown. */ throw new UnknownHostException(host); } /* Make a copy of the InetAddress array */ try { objcopy = ((InetAddress [])obj).clone(); // the following line is a hack, to ensure that the code // can compile for both the broken compiler and the fixed one. if (objcopy == null) throw new CloneNotSupportedException(); } catch (CloneNotSupportedException cnse) { cnse.printStackTrace(); } return (InetAddress [])objcopy; } /** * Returns the local host. * * @return the IP address of the local host. * @exception UnknownHostException if no IP address for the * <code>host</code> could be found. * @since JDK1.0 */ public static InetAddress getLocalHost() throws UnknownHostException { if (localHost.equals(unknownAddress)) { throw new UnknownHostException(); } try { /* If the localhost's address is not initialized yet, initialize * it. It is no longer initialized in the static initializer * (see comment there). */ if (localHost.address == -1) { localHost = getAllByName(localHost.hostName)[0]; /* This puts it in the address cache as well */ } /* make sure the connection to the host is allowed: if yes, * return the "real" localHost; if not, return loopback "127.0.0.1" */ SecurityManager security = System.getSecurityManager(); if (security != null && !security.getInCheck()) security.checkConnect(localHost.getHostName(), -1); return localHost; } catch (java.lang.SecurityException e) { return loopbackHost; } } } class InetAddressImpl { native String getLocalHostName() throws UnknownHostException; native void makeAnyLocalAddress(InetAddress addr); native byte[][] lookupAllHostAddr(String hostname) throws UnknownHostException; native String getHostByAddr(int addr) throws UnknownHostException; native int getInetFamily(); }
⏎ java/net/InetAddress.java
Or download all of them as a single archive file:
File name: jdk-1.1.8-src.zip File size: 1574187 bytes Release date: 2018-11-16 Download
⇒ Backup JDK 1.1 Installation Directory
2018-11-17, 176988👍, 0💬
Popular Posts:
JDK 11 jdk.compiler.jmod is the JMOD file for JDK 11 Compiler tool, which can be invoked by the "jav...
commons-fileupload-1.3.3 -sources.jaris the source JAR file for Apache Commons FileUpload 1.3., whic...
Snappy-Java is a Java port of the "snappy", a fast C++ compresser/decompresser developed by Google. ...
What Is commons-fileupload-1.3.3 .jar?commons-fileupload-1.3.3 .jaris the JAR file for Apache Common...
iText is an ideal library for developers looking to enhance web- and other applications with dynamic...