Java Code Examples for java.net.InetAddress#equals()

protected boolean
sameAs(
	NetworkAdminNATDeviceImpl	other )
{
	if ( 	!getAddress().equals( other.getAddress()) ||
			getPort() != other.getPort()){
		
		return( false );
	}
	
	InetAddress e1 = getExternalAddress();
	InetAddress e2 = other.getExternalAddress();
	
	if ( e1 == null && e2 == null ){
		
		return( true );
	}
	if ( e1 == null || e2 == null ){
		
		return( false );
	}
			
	return( e1.equals( e2 ));
}
 

/**
 * This utility method tries to connect to the JobManager using the InetAddress returned by
 * InetAddress.getLocalHost(). The purpose of the utility is to have a final try connecting to
 * the target address using the LocalHost before using the address returned.
 * We do a second try because the JM might have been unavailable during the first check.
 *
 * @param preliminaryResult The address detected by the heuristic
 * @return either the preliminaryResult or the address returned by InetAddress.getLocalHost() (if
 * 			we are able to connect to targetAddress from there)
 */
private static InetAddress tryLocalHostBeforeReturning(
			InetAddress preliminaryResult, SocketAddress targetAddress, boolean logging) throws IOException {

	InetAddress localhostName = InetAddress.getLocalHost();

	if (preliminaryResult.equals(localhostName)) {
		// preliminary result is equal to the local host name
		return preliminaryResult;
	}
	else if (tryToConnect(localhostName, targetAddress, AddressDetectionState.SLOW_CONNECT.getTimeout(), logging)) {
		// success, we were able to use local host to connect
		LOG.debug("Preferring {} (InetAddress.getLocalHost()) for local bind point over previous candidate {}",
				localhostName, preliminaryResult);
		return localhostName;
	}
	else {
		// we have to make the preliminary result the final result
		return preliminaryResult;
	}
}
 

private InetAddress getRpcAddress(InetAddress endpoint)
{
    try
    {
        InetAddress rpcAddress = InetAddress.getByName(StorageService.instance.getRpcaddress(endpoint));
        // If rpcAddress == 0.0.0.0 (i.e. bound on all addresses), returning that is not very helpful,
        // so return the internal address (which is ok since "we're bound on all addresses").
        // Note that after all nodes are running a version that includes CASSANDRA-5899, rpcAddress should
        // never be 0.0.0.0, so this can eventually be removed.
        return rpcAddress.equals(bindAll) ? endpoint : rpcAddress;
    }
    catch (UnknownHostException e)
    {
        // That should not happen, so log an error, but return the
        // endpoint address since there's a good change this is right
        logger.error("Problem retrieving RPC address for {}", endpoint, e);
        return endpoint;
    }
}
 

/**
 * Checks if the <code>newIP</code> address matches the session of <code>lastIP</code> address.
 *
 * Usually this is only <code>true</code> if both addresses are equal by {@link InetAddress#equals(Object)}.
 * This method is called to detect if a session is stolen by a 3rd party.
 * There are two properties (with their default value) to modify this behavior and specify netmasks:
 * <pre>
 * MCR.Servlet.Session.NetMask.IPv4=255.255.255.255
 * MCR.Servlet.Session.NetMask.IPv6=FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF
 * </pre>
 *
 * @param lastIP IP address from former request
 * @param newIP IP address from current request
 * @return
 * @throws UnknownHostException if <code>lastIP</code> or <code>newIP</code> are not valid IP addresses.
 */
public static boolean isIPAddrAllowed(String lastIP, String newIP) throws UnknownHostException {
    InetAddress lastIPAddress = InetAddress.getByName(lastIP);
    InetAddress newIPAddress = InetAddress.getByName(newIP);
    byte[] lastIPMask = decideNetmask(lastIPAddress);
    byte[] newIPMask = decideNetmask(newIPAddress);
    lastIPAddress = InetAddress.getByAddress(filterIPByNetmask(lastIPAddress.getAddress(), lastIPMask));
    newIPAddress = InetAddress.getByAddress(filterIPByNetmask(newIPAddress.getAddress(), newIPMask));
    if (lastIPAddress.equals(newIPAddress)) {
        return true;
    }
    String hostIP = getHostIP();
    InetAddress hostIPAddress = InetAddress.getByName(hostIP);
    byte[] hostIPMask = decideNetmask(hostIPAddress);
    hostIPAddress = InetAddress.getByAddress(filterIPByNetmask(hostIPAddress.getAddress(), hostIPMask));
    return newIPAddress.equals(hostIPAddress);
}
 

protected boolean
sameAs(
	NetworkAdminNATDeviceImpl	other )
{
	if ( 	!getAddress().equals( other.getAddress()) ||
			getPort() != other.getPort()){

		return( false );
	}

	InetAddress e1 = getExternalAddress();
	InetAddress e2 = other.getExternalAddress();

	if ( e1 == null && e2 == null ){

		return( true );
	}
	if ( e1 == null || e2 == null ){

		return( false );
	}

	return( e1.equals( e2 ));
}
 

private static boolean isLocalHost(String hostname) throws IOException {
    InetAddress remoteAddr = InetAddress.getByName(hostname);
    // Retrieve all the network interfaces on this host.
    Enumeration<NetworkInterface> nis =
            NetworkInterface.getNetworkInterfaces();
    // Walk through the network interfaces to see
    // if any of them matches the client's address.
    // If true, then the client's address is local.
    while (nis.hasMoreElements()) {
        NetworkInterface ni = nis.nextElement();
        Enumeration<InetAddress> addrs = ni.getInetAddresses();
        while (addrs.hasMoreElements()) {
            InetAddress localAddr = addrs.nextElement();
            if (localAddr.equals(remoteAddr)) {
                return true;
            }
        }
    }
    return false;
}
 

public void setClientAddress(@Nonnull InetAddress clientAddress) {
    Preconditions.checkArgument(!AddressUtils.isZeroAddress(clientAddress), "Client address was null or zero.");
    if (clientAddress.equals(this.clientAddress))
        return;
    Preconditions.checkState(this.clientAddress == null, "Already have a (different) client address.");
    this.clientAddress = clientAddress;
    setInterfaceAddressFrom(clientAddress);
}
 

private void checkAddressIsLocal(InetAddress inetAddr) throws UnknownHostException,Exception
{
	for(int i = 0; i < localAddresses.size(); i++)
	{
		if (inetAddr.equals((InetAddress)localAddresses.get(i)))
		{
			return;
		}
	}
	consolePropertyMessage("DRDA_NeedLocalHost.S", new String[] {inetAddr.getHostName(),serverSocket.getInetAddress().getHostName()});

}
 

/**
 * Disconnects all clients from the server with the address.
 * 
 * @param address
 *            the IP address of the client.
 * @param reason
 *            the reason for client disconnection. A <code>null</code>
 *            reason will have <code>"Disconnected"</code> be used as the
 *            reason instead.
 * @return <code>true</code> if a client was disconnect, <code>false</code>
 *         otherwise.
 */
public final boolean disconnect(InetAddress address, String reason) {
	if (address == null) {
		return false;
	}
	boolean disconnected = false;
	for (InetSocketAddress peerAddress : clients.keySet()) {
		if (address.equals(peerAddress.getAddress())) {
			this.disconnect(peerAddress, reason);
			disconnected = true;
		}
	}
	return disconnected;
}
 

@Override
public ChannelFuture leaveGroup(
        InetAddress multicastAddress, NetworkInterface networkInterface, InetAddress source,
        ChannelPromise promise) {
    checkJavaVersion();

    if (multicastAddress == null) {
        throw new NullPointerException("multicastAddress");
    }
    if (networkInterface == null) {
        throw new NullPointerException("networkInterface");
    }

    synchronized (this) {
        if (memberships != null) {
            List<MembershipKey> keys = memberships.get(multicastAddress);
            if (keys != null) {
                Iterator<MembershipKey> keyIt = keys.iterator();

                while (keyIt.hasNext()) {
                    MembershipKey key = keyIt.next();
                    if (networkInterface.equals(key.networkInterface())) {
                       if (source == null && key.sourceAddress() == null ||
                           source != null && source.equals(key.sourceAddress())) {
                           key.drop();
                           keyIt.remove();
                       }
                    }
                }
                if (keys.isEmpty()) {
                    memberships.remove(multicastAddress);
                }
            }
        }
    }

    promise.setSuccess();
    return promise;
}
 

/**
 * Checks registry for membership of the group on the given
 * network interface.
 */
MembershipKey checkMembership(InetAddress group, NetworkInterface interf,
                              InetAddress source)
{
    if (groups != null) {
        List<MembershipKeyImpl> keys = groups.get(group);
        if (keys != null) {
            for (MembershipKeyImpl key: keys) {
                if (key.networkInterface().equals(interf)) {
                    // already a member to receive all packets so return
                    // existing key or detect conflict
                    if (source == null) {
                        if (key.sourceAddress() == null)
                            return key;
                        throw new IllegalStateException("Already a member to receive all packets");
                    }

                    // already have source-specific membership so return key
                    // or detect conflict
                    if (key.sourceAddress() == null)
                        throw new IllegalStateException("Already have source-specific membership");
                    if (source.equals(key.sourceAddress()))
                        return key;
                }
            }
        }
    }
    return null;
}
 

/**
 * Return the rpc address associated with an endpoint as a string.
 * @param endpoint The endpoint to get rpc address for
 * @return the rpc address
 */
public String getRpcaddress(InetAddress endpoint)
{
    if (endpoint.equals(FBUtilities.getBroadcastAddress()))
        return DatabaseDescriptor.getBroadcastRpcAddress().getHostAddress();
    else if (Gossiper.instance.getEndpointStateForEndpoint(endpoint).getApplicationState(ApplicationState.RPC_ADDRESS) == null)
        return endpoint.getHostAddress();
    else
        return Gossiper.instance.getEndpointStateForEndpoint(endpoint).getApplicationState(ApplicationState.RPC_ADDRESS).value;
}
 

private String getKnownAddress(String addr) {
    try {
        InetAddress a = InetAddress.getByName(addr);
        if (a.equals(dns1))
            return "dns1";
        if (a.equals(dns2))
            return "dns2";
        if (a.equals(vpn4) || a.equals(vpn6))
            return "vpn";
    } catch (UnknownHostException ignored) {
    }
    return addr;
}
 

/**
 * Record tokens being used by another node
 */
public static synchronized void updateTokens(InetAddress ep, Collection<Token> tokens)
{
    if (ep.equals(FBUtilities.getBroadcastAddress()))
    {
        removeEndpoint(ep);
        return;
    }

    String req = "INSERT INTO system.%s (peer, tokens) VALUES (?, ?)";
    executeInternal(String.format(req, PEERS_CF), ep, tokensAsSet(tokens));
}
 

public String getDatacenter(InetAddress endpoint)
{
    if (endpoint.equals(FBUtilities.getBroadcastAddress()))
        return gceRegion;
    EndpointState state = Gossiper.instance.getEndpointStateForEndpoint(endpoint);
    if (state == null || state.getApplicationState(ApplicationState.DC) == null)
    {
        if (savedEndpoints == null)
            savedEndpoints = SystemKeyspace.loadDcRackInfo();
        if (savedEndpoints.containsKey(endpoint))
            return savedEndpoints.get(endpoint).get("data_center");
        return DEFAULT_DC;
    }
    return state.getApplicationState(ApplicationState.DC).value;
}
 

private static boolean isLocal(final URI uri) {
    try {
        final String hostName = uri.getHost();
        final InetAddress address = InetAddress.getByName(hostName);
        NetworkInterface nic;
        if (address.isLinkLocalAddress()) {
            /*
             * AS7-6382 On Windows the getByInetAddress was not identifying a NIC where the address did not have the zone
             * ID, this manual iteration does allow for the address to be matched.
             */
            Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
            nic = null;
            while (interfaces.hasMoreElements() && nic == null) {
                NetworkInterface current = interfaces.nextElement();
                Enumeration<InetAddress> addresses = current.getInetAddresses();
                while (addresses.hasMoreElements() && nic == null) {
                    InetAddress currentAddress = addresses.nextElement();
                    if (address.equals(currentAddress)) {
                        nic = current;
                    }
                }
            }
        } else {
            nic = NetworkInterface.getByInetAddress(address);
        }
        return address.isLoopbackAddress() || nic != null;
    } catch (Exception e) {
        return false;
    }
}
 

public static boolean isLocallyConnected(com.mysql.jdbc.ConnectionImpl conn) throws SQLException {
    long threadId = conn.getId();
    java.sql.Statement processListStmt = conn.getMetadataSafeStatement();
    ResultSet rs = null;
    String processHost = null;

    // "inject" for tests
    if (System.getProperty(IS_LOCAL_HOSTNAME_REPLACEMENT_PROPERTY_NAME) != null) {
        processHost = System.getProperty(IS_LOCAL_HOSTNAME_REPLACEMENT_PROPERTY_NAME);

    } else if (conn.getProperties().getProperty(IS_LOCAL_HOSTNAME_REPLACEMENT_PROPERTY_NAME) != null) {
        processHost = conn.getProperties().getProperty(IS_LOCAL_HOSTNAME_REPLACEMENT_PROPERTY_NAME);

    } else { // get it from server
        try {
            processHost = findProcessHost(threadId, processListStmt);

            if (processHost == null) {
                // http://bugs.mysql.com/bug.php?id=44167 - connection ids on the wire wrap at 4 bytes even though they're 64-bit numbers
                conn.getLog()
                        .logWarn(String.format(
                                "Connection id %d not found in \"SHOW PROCESSLIST\", assuming 32-bit overflow, using SELECT CONNECTION_ID() instead",
                                threadId));

                rs = processListStmt.executeQuery("SELECT CONNECTION_ID()");

                if (rs.next()) {
                    threadId = rs.getLong(1);

                    processHost = findProcessHost(threadId, processListStmt);
                } else {
                    conn.getLog().logError(
                            "No rows returned for statement \"SELECT CONNECTION_ID()\", local connection check will most likely be incorrect");
                }
            }
        } finally {
            processListStmt.close();
        }
    }

    if (processHost != null) {
        conn.getLog().logDebug(String.format("Using 'host' value of '%s' to determine locality of connection", processHost));

        int endIndex = processHost.lastIndexOf(":");
        if (endIndex != -1) {
            processHost = processHost.substring(0, endIndex);

            try {
                boolean isLocal = false;

                InetAddress[] allHostAddr = InetAddress.getAllByName(processHost);

                // mysqlConnection should be the raw socket
                SocketAddress remoteSocketAddr = conn.getIO().mysqlConnection.getRemoteSocketAddress();

                if (remoteSocketAddr instanceof InetSocketAddress) {
                    InetAddress whereIConnectedTo = ((InetSocketAddress) remoteSocketAddr).getAddress();

                    for (InetAddress hostAddr : allHostAddr) {
                        if (hostAddr.equals(whereIConnectedTo)) {
                            conn.getLog().logDebug(
                                    String.format("Locally connected - HostAddress(%s).equals(whereIconnectedTo({%s})", hostAddr, whereIConnectedTo));
                            isLocal = true;
                            break;
                        }
                        conn.getLog()
                                .logDebug(String.format("Attempted locally connected check failed - ! HostAddress(%s).equals(whereIconnectedTo(%s)",
                                        hostAddr, whereIConnectedTo));
                    }
                } else {
                    String msg = String.format("Remote socket address %s is not an inet socket address", remoteSocketAddr);
                    conn.getLog().logDebug(msg);
                }

                return isLocal;
            } catch (UnknownHostException e) {
                conn.getLog().logWarn(Messages.getString("Connection.CantDetectLocalConnect", new Object[] { processHost }), e);
                return false;
            }
        }
        conn.getLog().logWarn(String
                .format("No port number present in 'host' from SHOW PROCESSLIST '%s', unable to determine whether locally connected", processHost));
        return false;
    }
    conn.getLog().logWarn(String
            .format("Cannot find process listing for connection %d in SHOW PROCESSLIST output, unable to determine if locally connected", threadId));
    return false;
}
 

public boolean isSameRM(XAResource xares) throws XAException {
    boolean isSame = false; // preset that the RMs are NOT the same
    exceptionsOnXA = null;

    if (conn_.agent_.loggingEnabled()) {
        conn_.agent_.logWriter_.traceEntry(this, "isSameRM", xares);
    }
    if (conn_.isPhysicalConnClosed()) {
        connectionClosedFailure();
    }

    if (xares instanceof com.splicemachine.db.client.net.NetXAResource) { // both are NetXAResource so check to see if this is the same RM
        // remember, isSame is initialized to false
        NetXAResource derbyxares = (NetXAResource) xares;
        while (true) {
            if (!conn_.databaseName_.equalsIgnoreCase(derbyxares.conn_.databaseName_)) {
                break; // database names are not equal, not same RM
            }
            if (!conn_.netAgent_.server_.equalsIgnoreCase
                    (derbyxares.conn_.netAgent_.server_)) { // server name strings not equal, compare IP addresses
                try {
                    // 1st convert "localhost" to actual server name
                    String server1 = this.processLocalHost(conn_.netAgent_.server_);
                    String server2 =
                            this.processLocalHost(derbyxares.conn_.netAgent_.server_);
                    // now convert the server name to ip address
                    InetAddress serverIP1 = InetAddress.getByName(server1);
                    InetAddress serverIP2 = InetAddress.getByName(server2);
                    if (!serverIP1.equals(serverIP2)) {
                        break; // server IPs are not equal, not same RM
                    }
                } catch (UnknownHostException ue) {
                    break;
                }
            }
            if (conn_.netAgent_.port_ != derbyxares.conn_.netAgent_.port_) {
                break; // ports are not equal, not same RM
            }
            isSame = true; // everything the same, set RMs are the same
            break;
        }
    }

    if (conn_.agent_.loggingEnabled()) {
        conn_.agent_.logWriter_.traceExit
                (this, "isSameRM", isSame);
    }
    return isSame;
}
 

protected void
check(
	ClientInstance instance )
{
	if ( instance == my_instance ){

		return;
	}

	InetAddress	my_ext 		= my_instance.getExternalAddress();
	InetAddress	other_ext 	= instance.getExternalAddress();

	if ( 	my_ext.isLoopbackAddress() ||
			other_ext.isLoopbackAddress() ||
			my_ext.equals( other_ext )){

		String	warning = null;

		int	my_tcp = my_instance.getTCPListenPort();

		if ( my_tcp != 0 && my_tcp != last_warned_tcp && my_tcp == instance.getTCPListenPort()){

			warning = "TCP " + my_tcp;

			last_warned_tcp	= my_tcp;
		}

		int	my_udp 	= my_instance.getUDPListenPort();
		int my_udp2	= my_instance.getUDPNonDataListenPort();

		int	other_udp 	= instance.getUDPListenPort();
		int other_udp2	= instance.getUDPNonDataListenPort();

		if ( my_udp != 0 && my_udp != last_warned_udp && ( my_udp == other_udp || my_udp == other_udp2 )){

			warning = (warning==null?"":(warning + ", ")) + "UDP " + my_udp;

			last_warned_udp	= my_udp;
		}

		if ( my_udp != my_udp2 && my_udp2 != 0 && my_udp2 != last_warned_udp2 && ( my_udp2 == other_udp || my_udp2 == other_udp2 )){

			warning = (warning==null?"":(warning + ", ")) + "UDP " + my_udp2;

			last_warned_udp2	= my_udp2;
		}


		if ( warning != null ){

			Logger.logTextResource(
				new LogAlert(true, LogAlert.AT_WARNING,"azinstancehandler.alert.portclash"),
				new String[]{
					warning,
					String.valueOf(RandomUtils.LISTEN_PORT_MIN ),
					String.valueOf(RandomUtils.LISTEN_PORT_MAX)});
		}
	}
}
 

public final boolean equals(InternalDistributedMember m) {
    if (this == m) {
      return true;
    }
    if (m == null) {
      return false;
    }
    
    if (getPort() != m.getPort()) {
      return false;
    }

    final InetAddress myAddr = getIpAddress();
    final InetAddress otherAddr = m.getIpAddress();

    // Discard null cases
    if (myAddr == null && otherAddr == null) {
        return true;
    }
    else if (myAddr == null || otherAddr == null) {
      return false;
    }
    
    if(!myAddr.equals(otherAddr)) {
      return false;
    }
    
    // [bruce] names are no longer transmitted in writeEssentialData and
    // so cannot be used in comparing IDs
//    if (this.name == null && other.name == null) {
//      // do nothing
//    } else if (this.name == null) {
//      return -1;
//    }
//    else if (other.name == null) {
//      return 1;
//    }
//    else {
//      int i = this.name.compareTo(other.name);
//      if (i != 0) {
//        return i;
//      }
//    }

    if (this.uniqueTag == null && m.uniqueTag == null) {
      // not loners, so look at P2P view ID
      if (this.vmViewId != m.vmViewId) {
        return false;
      } // else they're the same, so continue
    } else if (this.uniqueTag == null || m.uniqueTag == null) {
      return false;
    }
    else if (!this.uniqueTag.equals(m.uniqueTag) ){
      return false;
    }

    // purposely avoid comparing roles
    // @todo Add durableClientAttributes to compare
    return true;
  }