Example usage for com.google.common.net InetAddresses fromInteger

List of usage examples for com.google.common.net InetAddresses fromInteger

Introduction

In this page you can find the example usage for com.google.common.net InetAddresses fromInteger.

Prototype

public static Inet4Address fromInteger(int address) 

Source Link

Document

Returns an Inet4Address having the integer value specified by the argument.

Usage

From source file:org.opendaylight.genius.mdsalutil.NWUtil.java

/**
* Converts IPv4 Address in long to String.
* {@link #longToIpv4(long, long)} fixes the issue of {@link MDSALUtil#longToIp(long, long)}
* not handling IP address greater than byte.
*
* @param ipAddress IP Address to be converted to String
* @param mask Network mask to be appended
* @return IP Address converted to String
*///w  w  w.ja va  2s . c  o  m
public static String longToIpv4(final long ipAddress, final long mask) {
    final StringBuilder builder = new StringBuilder(20);
    final Inet4Address address = InetAddresses.fromInteger((int) ipAddress);
    builder.append(address.toString());
    if (mask != 0) {
        builder.append("/").append(mask);
    }
    return builder.toString();
}

From source file:io.airlift.http.server.Inet4Network.java

public Inet4Address getEndingAddress() {
    int start = InetAddresses.coerceToInteger(address);
    int length = (bits == 0) ? 0 : (1 << (32 - bits));
    int end = start + length - 1;
    return InetAddresses.fromInteger(end);
}

From source file:org.opendaylight.protocol.bgp.rib.impl.RouterIds.java

public static PeerId createPeerId(@Nonnull final UnsignedInteger intAddress) {
    final String inet4Address = InetAddresses.fromInteger(intAddress.intValue()).getHostAddress();
    return new PeerId(BGP_PREFIX.concat(inet4Address));
}

From source file:io.airlift.http.server.Inet4Network.java

public static Inet4Network truncatedFromAddress(Inet4Address address, int bits) {
    int mask = (bits == 0) ? 0 : (-1 << (32 - bits));
    int ip = InetAddresses.coerceToInteger(address);
    return fromAddress(InetAddresses.fromInteger(ip & mask), bits);
}

From source file:org.n52.iceland.util.net.IPAddress.java

/**
 * @return the IP address as an {@code Inet4Address}
 */
public Inet4Address asInetAddress() {
    return InetAddresses.fromInteger(this.address);
}

From source file:org.n52.janmayen.net.IPAddress.java

/**
 * Creates a new {@code IPAddress} from an 32-Bit integer.
 *
 * @param address the address/* ww  w  . j  a va  2 s.c o m*/
 */
public IPAddress(int address) {
    this.address = InetAddresses.fromInteger(address);
}

From source file:org.opendaylight.sfc.sfc_lisp.provider.SfcLispUtil.java

public static Ip createLocator(ApplicationData applicationData) {
    IpAddress ip = new IpAddress(new Ipv4Address(
            InetAddresses.fromInteger(applicationData.getApplicationData().getIpTos()).getHostAddress()));
    Ip locatorType = new IpBuilder().setIp(ip).setPort(applicationData.getApplicationData().getLocalPortLow())
            .build();/*from   ww  w  . ja  v a 2s . com*/
    return locatorType;
}

From source file:org.opendaylight.sfc.sfclisp.provider.SfcLispUtil.java

public static Ip createLocator(ApplicationData applicationData) {
    IpAddress ip = new IpAddress(new Ipv4Address(
            InetAddresses.fromInteger(applicationData.getApplicationData().getIpTos()).getHostAddress()));
    return new IpBuilder().setIp(ip).setPort(applicationData.getApplicationData().getLocalPortLow()).build();
}

From source file:io.airlift.node.NodeInfo.java

public NodeInfo(String environment, String pool, String nodeId, InetAddress internalIp, InetAddress bindIp,
        String externalAddress, String location, String binarySpec, String configSpec) {
    checkNotNull(environment, "environment is null");
    checkNotNull(pool, "pool is null");
    checkArgument(environment.matches(NodeConfig.ENV_REGEXP), "environment '%s' is invalid", environment);
    checkArgument(pool.matches(NodeConfig.POOL_REGEXP), "pool '%s' is invalid", pool);

    this.environment = environment;
    this.pool = pool;

    if (nodeId != null) {
        checkArgument(nodeId.matches(NodeConfig.ID_REGEXP), "nodeId '%s' is invalid", nodeId);
        this.nodeId = nodeId;
    } else {//from  w w  w.java2s  . c o m
        this.nodeId = UUID.randomUUID().toString();
    }

    if (location != null) {
        this.location = location;
    } else {
        this.location = "/" + this.nodeId;
    }

    this.binarySpec = binarySpec;
    this.configSpec = configSpec;

    if (internalIp != null) {
        this.internalIp = internalIp;
    } else {
        this.internalIp = findPublicIp();
    }

    if (bindIp != null) {
        this.bindIp = bindIp;
    } else {
        this.bindIp = InetAddresses.fromInteger(0);
    }

    if (externalAddress != null) {
        this.externalAddress = externalAddress;
    } else {
        this.externalAddress = InetAddresses.toAddrString(this.internalIp);
    }
}

From source file:pl.umk.mat.olaf.lobby.lobbythread.LobbyThread.java

/**
 * Find Server addres. Fist looks for chat server on localhost, next checks another interfaces.
 *
 * @throws SocketException the socket exception
 *//*from  w  w w . ja  va  2 s . co m*/
public void findServerAddressAndReceiveInfo() throws SocketException {
    boolean serverFound = true;

    if (serverAddress == null) {
        Enumeration<NetworkInterface> netInterfaces = null;
        try {
            netInterfaces = NetworkInterface.getNetworkInterfaces();

            while (netInterfaces.hasMoreElements()) {
                NetworkInterface ni = netInterfaces.nextElement();
                Enumeration<InetAddress> address = ni.getInetAddresses();
                while (address.hasMoreElements()) {
                    InetAddress addr = address.nextElement();
                    if (!addr.isLoopbackAddress() && addr.isSiteLocalAddress()
                            && !(addr.getHostAddress().indexOf(":") > -1)) {
                        serverAddress = addr.getHostAddress();
                    }
                }
            }
            if (serverAddress == null) {
                serverAddress = "127.0.0.1";
            }
            /**
             * check localhost connection
             */
            System.out.println("Mam ju jaki adres...");
            try {
                clientSocket = new Socket("localhost", port);
            } catch (IOException ex) {

                System.out.println("There is no active severs on the local computer");
                Logger.getLogger(LobbyThread.class.getName()).log(Level.SEVERE, null, ex);
                serverFound = false;
            }
            if (serverFound == true) {
                System.out.println("A jednak jest co na localhoscie!");
                try {
                    rooms = returnRoomInfo(clientSocket);
                    serverAddress = "127.0.0.1";
                    clientSocket.close();
                } catch (IOException | ClassNotFoundException ex) {
                    System.out.println("Error while closing socket!!");
                    Logger.getLogger(LobbyThread.class.getName()).log(Level.SEVERE, null, ex);
                }
            } else if (serverAddress != "127.0.0.1" && !serverFound) {
                System.out.println("nie znalazem na porcie 127.0.0.01, szukam dalej!");
                /**
                 * compute mask, network and broadcast ip address in the network
                 * and
                 * looks for running server
                 */
                int maxMask = ~0;
                mask = maxMask << (32 - NetworkInterface.getByInetAddress(Inet4Address.getByName(serverAddress))
                        .getInterfaceAddresses().get(0).getNetworkPrefixLength());
                networkAddress = InetAddresses.coerceToInteger(InetAddresses.forString(serverAddress)) & mask;
                broadcastAddress = (~mask) | (networkAddress);

                System.out.println("Maska " + InetAddresses.fromInteger(mask).getHostAddress()
                        + " networkAddress " + InetAddresses.fromInteger(networkAddress).getHostAddress()
                        + " broadcast " + InetAddresses.fromInteger(broadcastAddress).getHostAddress());
                /**
                 * check each address between networkAddress and broadcastAddress
                 */
                for (int address = networkAddress + 1; address < broadcastAddress; address++) {
                    System.out.println("Adres: " + InetAddresses.fromInteger(address).getHostAddress());
                    serverFound = true;
                    try {

                        clientSocket = new Socket();
                        clientSocket.connect(new InetSocketAddress(InetAddresses.fromInteger(address), port),
                                250);
                        serverFound = true;
                    } catch (IOException ex) {
                        serverFound = false;
                        Logger.getLogger(LobbyThread.class.getName()).log(Level.SEVERE, null, ex);
                    }
                    if (serverFound == true) {
                        serverAddress = InetAddresses.fromInteger(address).getHostAddress();
                        try {
                            rooms = returnRoomInfo(clientSocket);
                            clientSocket.close();
                        } catch (IOException | ClassNotFoundException ex) {
                            Logger.getLogger(LobbyThread.class.getName()).log(Level.SEVERE, null, ex);
                        }
                        break;
                    }

                }
            }
            if (serverFound == false) {
                serverAddress = "0.0.0.0";
            }

        } catch (SocketException e) {
            serverAddress = "127.0.0.1";
        } catch (UnknownHostException ex) {
            Logger.getLogger(LobbyThread.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}