下面列出了java.net.InetAddress#getByAddress ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
/**
* 解析响应内容中的 DHT 节点信息
*
* @param r
*/
private void resolveNodes(Map r) {
byte[] nodes = (byte[]) r.get("nodes");
if (nodes == null)
return;
for (int i = 0; i < nodes.length; i += 26) {
try {
//limit the node queue size
if (NODES_QUEUE.size() > 5000)
continue;
InetAddress ip = InetAddress.getByAddress(new byte[]{nodes[i + 20], nodes[i + 21], nodes[i + 22], nodes[i + 23]});
InetSocketAddress address = new InetSocketAddress(ip, (0x0000FF00 & (nodes[i + 24] << 8)) | (0x000000FF & nodes[i + 25]));
byte[] nid = new byte[20];
System.arraycopy(nodes, i, nid, 0, 20);
NODES_QUEUE.offer(new Node(nid, address));
//log.info("get node address=[{}] ", address);
} catch (Exception e) {
log.error("", e);
}
}
}
@Test
public void resolve_nullResourceResolver() throws Exception {
InetAddress backendAddr = InetAddress.getByAddress(new byte[] {127, 0, 0, 0});
AddressResolver mockAddressResolver = mock(AddressResolver.class);
when(mockAddressResolver.resolveAddress(anyString()))
.thenReturn(Collections.singletonList(backendAddr));
ResourceResolver resourceResolver = null;
resolver.setAddressResolver(mockAddressResolver);
resolver.setResourceResolver(resourceResolver);
resolver.start(mockListener);
assertThat(fakeClock.runDueTasks()).isEqualTo(1);
verify(mockListener).onResult(resultCaptor.capture());
ResolutionResult result = resultCaptor.getValue();
assertThat(result.getAddresses())
.containsExactly(
new EquivalentAddressGroup(new InetSocketAddress(backendAddr, DEFAULT_PORT)));
assertThat(result.getAttributes()).isEqualTo(Attributes.EMPTY);
assertThat(result.getServiceConfig()).isNull();
}
public InetAddress[] lookupAllHostAddr(String host) throws UnknownHostException {
lookupCalls ++;
String value = (String)hosts.get(host);
if (value == null) {
throw new UnknownHostException(host);
}
StringTokenizer st = new StringTokenizer(value, ".");
byte addr[] = new byte[4];
for (int i=0; i<4; i++) {
addr[i] = (byte)Integer.parseInt(st.nextToken());
}
InetAddress[] res = new InetAddress[1];
res[0] = InetAddress.getByAddress(host, addr);
return res;
}
static InetAddress prefixTranslate(byte[] address, byte[] prefix, int nofBytes) {
System.arraycopy(prefix, 0, address, 0, nofBytes);
try {
return InetAddress.getByAddress(address);
} catch (UnknownHostException e) {
throw new UncheckedIOException(e);
}
}
/**
* This method uses InetAddress.getByAddress, and so does not block.
*
* @return java.net.InetAddress representing this IPv4 address
* @throws UnknownHostException if not host found
*/
public final InetAddress getInetAddress() throws UnknownHostException {
final int[] ints = toArray(address, false);
return InetAddress.getByAddress(new byte[] {
(byte) ints[0],
(byte) ints[1],
(byte) ints[2],
(byte) ints[3]});
}
/**
* Get InetAddress masked with prefixLength. Will never return null.
* @param address the IP address to mask with
* @param prefixLength the prefixLength used to mask the IP
*/
public static InetAddress getNetworkPart(InetAddress address, int prefixLength) {
byte[] array = address.getAddress();
maskRawAddress(array, prefixLength);
InetAddress netPart = null;
try {
netPart = InetAddress.getByAddress(array);
} catch (UnknownHostException e) {
throw new RuntimeException("getNetworkPart error - " + e.toString());
}
return netPart;
}
public Host createUnknownHost() {
try {
return new Host("unknown", InetAddress.getByAddress(new byte[] { 0, 0, 0, 0 })) {}; // NOI18N
} catch (UnknownHostException e) {
LOGGER.severe("Failure: cannot resolve <unknown> host"); // NOI18N
return null;
}
}
private void calculate() throws UnknownHostException {
ByteBuffer maskBuffer;
int targetSize;
if (inetAddress.getAddress().length == 4) {
maskBuffer =
ByteBuffer
.allocate(4)
.putInt(-1);
targetSize = 4;
} else {
maskBuffer = ByteBuffer.allocate(16)
.putLong(-1L)
.putLong(-1L);
targetSize = 16;
}
BigInteger mask = (new BigInteger(1, maskBuffer.array())).not().shiftRight(prefixLength);
ByteBuffer buffer = ByteBuffer.wrap(inetAddress.getAddress());
BigInteger ipVal = new BigInteger(1, buffer.array());
BigInteger startIp = ipVal.and(mask);
BigInteger endIp = startIp.add(mask.not());
byte[] startIpArr = toBytes(startIp.toByteArray(), targetSize);
byte[] endIpArr = toBytes(endIp.toByteArray(), targetSize);
this.startAddress = InetAddress.getByAddress(startIpArr);
this.endAddress = InetAddress.getByAddress(endIpArr);
}
public InetSocketAddress getInetSocketAddress() {
try {
return new InetSocketAddress(InetAddress.getByAddress(address),
port);
} catch (UnknownHostException e) {
throw new RuntimeException(e.getMessage());
}
}
/**
* Gets the InetAddress of this HostAddress.
* @return the IP address for this specified host.
* @exception if no IP address for the host could be found.
*
*/
public InetAddress getInetAddress() throws UnknownHostException {
// the type of internet addresses is 2.
if (addrType == Krb5.ADDRTYPE_INET ||
addrType == Krb5.ADDRTYPE_INET6) {
return (InetAddress.getByAddress(address));
} else {
// if it is other type (ISO address, XNS address, etc)
return null;
}
}
/**
* Get instances of InetAddress by calling InetAddress.getByAddress(byte[]),
* Inet4Address.getByAddress(byte[]), and Inet6Address.getByAddress(byte[]),
* passing in a 4-byte address,
* and then test their properties.
* @param response HttpServletResponse used to return failure message
* @throws IOException If method being tested throws this.
* @throws AssertionFailedException If an assertion fails
*/
private static void testGetByAddress4(HttpServletResponse response)
throws IOException, AssertionFailedException {
byte[] addressBytes = new byte[] {74, 125, (byte) 224, 19};
String addressString = "74.125.224.19";
String name = null;
InetAddress googleDotCom = InetAddress.getByAddress(addressBytes);
testNameAndAddress4(name, addressString, addressBytes, googleDotCom, response);
googleDotCom = Inet4Address.getByAddress(addressBytes);
testNameAndAddress4(name, addressString, addressBytes, googleDotCom, response);
googleDotCom = Inet6Address.getByAddress(addressBytes);
testNameAndAddress4(name, addressString, addressBytes, googleDotCom, response);
}
public static PeersMessage parse(byte[] data) throws Exception
{
//READ LENGTH
byte[] lengthBytes = Arrays.copyOfRange(data, 0, DATA_LENGTH);
int length = Ints.fromByteArray(lengthBytes);
//CHECK IF DATA MATCHES LENGTH
if(data.length != DATA_LENGTH + (length * ADDRESS_LENGTH))
{
throw new Exception("Data does not match length");
}
//CREATE PEER LIST
List<Peer> peers = new ArrayList<Peer>();
for(int i=0; i<length; i++)
{
//CALCULATE POSITION
int position = lengthBytes.length + (i * ADDRESS_LENGTH);
//READ ADDRESS
byte[] addressBytes = Arrays.copyOfRange(data, position, position + ADDRESS_LENGTH);
InetAddress address = InetAddress.getByAddress(addressBytes);
//CREATE PEER
Peer peer = new Peer(address);
//ADD TO LIST
peers.add(peer);
}
return new PeersMessage(peers);
}
@Test
public void resolve_presentResourceResolver() throws Exception {
InetAddress backendAddr = InetAddress.getByAddress(new byte[] {127, 0, 0, 0});
InetAddress lbAddr = InetAddress.getByAddress(new byte[] {10, 1, 0, 0});
int lbPort = 8080;
String lbName = "foo.example.com."; // original name in SRV record
SrvRecord srvRecord = new SrvRecord(lbName, 8080);
AddressResolver mockAddressResolver = mock(AddressResolver.class);
when(mockAddressResolver.resolveAddress(hostName))
.thenReturn(Collections.singletonList(backendAddr));
when(mockAddressResolver.resolveAddress(lbName))
.thenReturn(Collections.singletonList(lbAddr));
ResourceResolver mockResourceResolver = mock(ResourceResolver.class);
when(mockResourceResolver.resolveTxt(anyString()))
.thenReturn(
Collections.singletonList(
"grpc_config=[{\"clientLanguage\": [\"java\"], \"serviceConfig\": {}}]"));
when(mockResourceResolver.resolveSrv(anyString()))
.thenReturn(Collections.singletonList(srvRecord));
when(serviceConfigParser.parseServiceConfig(ArgumentMatchers.<String, Object>anyMap()))
.thenAnswer(new Answer<ConfigOrError>() {
@Override
public ConfigOrError answer(InvocationOnMock invocation) {
Object[] args = invocation.getArguments();
return ConfigOrError.fromConfig(args[0]);
}
});
resolver.setAddressResolver(mockAddressResolver);
resolver.setResourceResolver(mockResourceResolver);
resolver.start(mockListener);
assertThat(fakeClock.runDueTasks()).isEqualTo(1);
verify(mockListener).onResult(resultCaptor.capture());
ResolutionResult result = resultCaptor.getValue();
InetSocketAddress resolvedBackendAddr =
(InetSocketAddress) Iterables.getOnlyElement(
Iterables.getOnlyElement(result.getAddresses()).getAddresses());
assertThat(resolvedBackendAddr.getAddress()).isEqualTo(backendAddr);
EquivalentAddressGroup resolvedBalancerAddr =
Iterables.getOnlyElement(result.getAttributes().get(GrpclbConstants.ATTR_LB_ADDRS));
assertThat(resolvedBalancerAddr.getAttributes().get(GrpclbConstants.ATTR_LB_ADDR_AUTHORITY))
.isEqualTo("foo.example.com");
InetSocketAddress resolvedBalancerSockAddr =
(InetSocketAddress) Iterables.getOnlyElement(resolvedBalancerAddr.getAddresses());
assertThat(resolvedBalancerSockAddr.getAddress()).isEqualTo(lbAddr);
assertThat(resolvedBalancerSockAddr.getPort()).isEqualTo(lbPort);
assertThat(result.getServiceConfig().getConfig()).isNotNull();
verify(mockAddressResolver).resolveAddress(hostName);
verify(mockResourceResolver).resolveTxt("_grpc_config." + hostName);
verify(mockResourceResolver).resolveSrv("_grpclb._tcp." + hostName);
}
Command processPacketInMessage(IOFSwitch sw, OFPacketIn pi,
FloodlightContext cntx) {
Ethernet eth = IFloodlightProviderService.bcStore.get(cntx,
IFloodlightProviderService.CONTEXT_PI_PAYLOAD);
long dpid = sw.getId();
short inport = pi.getInPort();
Port switch_port = new Port(dpid, inport);
MACAddress src_mac = eth.getSourceMAC();
PortProperty pp = this.port_list.get(switch_port);
if (pp == null)
return Command.CONTINUE;
DeviceType dt = pp.getDeviceType();
// testify if the packet is the response to Host Probing
if (eth.isBroadcast())
return Command.CONTINUE;
try {
if (eth.getEtherType() == Ethernet.TYPE_IPv4){
IPv4 ip = (IPv4) eth.getPayload();
InetAddress srcIP = InetAddress.getByAddress(
BigInteger.valueOf(ip.getSourceAddress()).toByteArray());
InetAddress dstIP = InetAddress.getByAddress(
BigInteger.valueOf(ip.getDestinationAddress()).toByteArray());
if(ip.getProtocol() == IPv4.PROTOCOL_ICMP){
ICMP icmp = (ICMP) ip.getPayload();
if (icmp.getIcmpCode() == ICMP.ECHO_REPLY){
if (hostProber.probedPorts.containsKey(switch_port)){
for (HostEntity he : hostProber.probedPorts.get(switch_port)){
if (he.ip.equals(srcIP) && he.mac.equals(eth.getSourceMAC()) &&
InetAddress.getByName(ControllerIP).equals(dstIP)){
//we think this is the response to host probing
//Violation: host is still reachable at previous locaiton
logger.warn("Violation: Host Move from switch {} port {} is still reachable"
, dpid, inport);
List<HostEntity> hostEntity = hostProber.probedPorts.get(switch_port);
hostEntity.remove(he);
hostProber.probedPorts.put(switch_port, hostEntity);
return Command.STOP;
}
}
}
}
}
}
} catch (UnknownHostException e) {
logger.error("Cannot construct InetAddress, {}", e.getMessage());
}
// if the payload is lldp, we do not verify correctness of LLDP in this point
if (eth.getPayload() instanceof LLDP) {
if (dt == DeviceType.ANY) {
pp.setPortSwitch();
} else if (dt == DeviceType.HOST) {
// Violation: impossible to receive LLDP from HOST port, Countermeasure: eat the lldp
logger.warn("Violation: Receive LLDP packets from HOST port: SW {} port {}"
, dpid, inport);
return Command.STOP;
}
}
// if the payload is host traffic
else {
// if this host found before
if (this.mac_port.containsKey(src_mac)) {
Port host_location = this.mac_port.get(src_mac);
if (host_location == switch_port) {
// this port is first hop port for found host
if (dt == DeviceType.SWITCH) {
// Violation: receive first hop traffic from SWITH port
logger.warn("Violation: Receive first hop host packets from SWITCH port: SW {} port {}"
, dpid, inport);
//return Command.STOP;
} else if (dt == DeviceType.ANY) {
//this happened if the port is shutdown
pp.setPortHost();
pp.disableHostShutDown(src_mac);
this.port_list.put(switch_port, pp);
}
}
}
else { // new host
this.mac_port.put(src_mac, switch_port);
pp.addHost(src_mac);
pp.setPortAny();
this.port_list.put(switch_port, pp);
}
}
return Command.CONTINUE;
}
@Test
public void testJmxServer() throws Exception {
JmxServer server1 = null;
JmxServer server2 = null;
JmxClient client1 = null;
JmxClient client2 = null;
TestObject testObject = new TestObject();
try {
InetAddress serverAddr1 = InetAddress.getByAddress(new byte[] { 127, 0, 0, 1 });
int serverPort1 = DEFAULT_PORT;
server1 = new JmxServer(serverAddr1, serverPort1);
InetAddress serverAddr2 = InetAddress.getLocalHost();
int serverPort2 = DEFAULT_PORT + 1;
server2 = new JmxServer(serverAddr2, serverPort2);
server1.start();
server2.start();
/*
* NOTE: since the platform MbeanServer is used, this registers one both servers.
*/
server1.register(testObject);
// Thread.sleep(1000000000);
client1 = new JmxClient(serverAddr1, serverPort1);
client2 = new JmxClient(serverAddr2, serverPort2);
testClient(client1);
testClient(client2);
} finally {
if (server1 != null) {
server1.unregister(testObject);
IoUtils.closeQuietly(server1);
}
if (server2 != null) {
server2.unregister(testObject);
IoUtils.closeQuietly(server2);
}
System.gc();
}
}
/**
* Initialize the SocketPermission object. We don't do any DNS lookups
* as this point, instead we hold off until the implies method is
* called.
*/
private void init(String host, int mask) {
// Set the integer mask that represents the actions
if ((mask & ALL) != mask)
throw new IllegalArgumentException("invalid actions mask");
// always OR in RESOLVE if we allow any of the others
this.mask = mask | RESOLVE;
// Parse the host name. A name has up to three components, the
// hostname, a port number, or two numbers representing a port
// range. "www.example.com:8080-9090" is a valid host name.
// With IPv6 an address can be 2010:836B:4179::836B:4179
// An IPv6 address needs to be enclose in []
// For ex: [2010:836B:4179::836B:4179]:8080-9090
// Refer to RFC 2732 for more information.
int rb = 0 ;
int start = 0, end = 0;
int sep = -1;
String hostport = host;
if (host.charAt(0) == '[') {
start = 1;
rb = host.indexOf(']');
if (rb != -1) {
host = host.substring(start, rb);
} else {
throw new
IllegalArgumentException("invalid host/port: "+host);
}
sep = hostport.indexOf(':', rb+1);
} else {
start = 0;
sep = host.indexOf(':', rb);
end = sep;
if (sep != -1) {
host = host.substring(start, end);
}
}
if (sep != -1) {
String port = hostport.substring(sep+1);
try {
portrange = parsePort(port);
} catch (Exception e) {
throw new
IllegalArgumentException("invalid port range: "+port);
}
} else {
portrange = new int[] { PORT_MIN, PORT_MAX };
}
hostname = host;
// is this a domain wildcard specification
if (host.lastIndexOf('*') > 0) {
throw new
IllegalArgumentException("invalid host wildcard specification");
} else if (host.startsWith("*")) {
wildcard = true;
if (host.equals("*")) {
cname = "";
} else if (host.startsWith("*.")) {
cname = host.substring(1).toLowerCase();
} else {
throw new
IllegalArgumentException("invalid host wildcard specification");
}
return;
} else {
if (!host.isEmpty()) {
// see if we are being initialized with an IP address.
char ch = host.charAt(0);
if (ch == ':' || Character.digit(ch, 16) != -1) {
byte ip[] = IPAddressUtil.textToNumericFormatV4(host);
if (ip == null) {
ip = IPAddressUtil.textToNumericFormatV6(host);
}
if (ip != null) {
try {
addresses =
new InetAddress[]
{InetAddress.getByAddress(ip) };
init_with_ip = true;
} catch (UnknownHostException uhe) {
// this shouldn't happen
invalid = true;
}
}
}
}
}
}
public static InetAddress readInetAddress(final DataInput in, final boolean fixedLength) throws IOException {
// Read boolean null value marker
if (in.readBoolean()) {
// The address is null
if (fixedLength) {
// Read padded bytes
in.readByte();
in.readLong();
in.readLong();
}
return null;
}
// Read the address
final byte addrLength = in.readByte();
switch (addrLength) {
case 4:
final int address = in.readInt();
if (fixedLength) {
// Pad 12 bytes
in.readInt();
in.readLong();
}
final 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 InetAddress.getByAddress(addr);
case 16:
final byte[] result = new byte[16];
in.readFully(result);
return InetAddress.getByAddress(result);
default:
throw new IOException("Unknown address format, length: " + addrLength);
}
}
@Override
public InetAddress[] resolve(final String hostname) throws UnknownHostException {
if ("localhost".equals(hostname)) return Frontier.LOOPBACK;
return new InetAddress[] { InetAddress.getByAddress(com.google.common.primitives.Ints.toByteArray(hostname.hashCode())) };
}
protected InetAddress
getCIDREndAddress()
throws NetworkAdminException
{
int pos = bgp_prefix.indexOf('/');
try{
InetAddress start = InetAddress.getByName( bgp_prefix.substring(0,pos));
int cidr_mask = Integer.parseInt( bgp_prefix.substring( pos+1 ));
byte[] bytes = start.getAddress();
for ( int i=cidr_mask;i<bytes.length*8;i++){
bytes[i/8] |= 1<<(7-(i%8));
}
return( InetAddress.getByAddress( bytes ));
}catch( Throwable e ){
throw( new NetworkAdminException( "Parse failure for '" + bgp_prefix + "'", e ));
}
}
public static InetAddress
syncResolve(
String host )
throws UnknownHostException
{
if ( isNonDNSName( host )){
throw( new HostNameToIPResolverException( "non-DNS name '" + host + "'", true ));
}
// handle any raw addresses up front
byte[] bytes = textToNumericFormat( host );
if ( bytes != null ){
return( InetAddress.getByAddress( bytes ));
}
// filter out partially complete raw addresses by applying the basic rule in ftp://ftp.is.co.za/rfc/rfc3696.txt
// at least one dot + not all numeric
char[] chars = host.toCharArray();
boolean resolve = false;
for (int i=0;i<chars.length;i++){
if ( !( chars[i] == '.' || Character.isDigit(chars[i]))){
resolve = true;
break;
}
}
if ( resolve && host.startsWith( "websocket." )){
resolve = false;
for (int i=10;i<chars.length;i++){
if ( !Character.isDigit(chars[i])){
resolve = true;
break;
}
}
}
if ( resolve ){
return( InetAddress.getByName( host));
}else{
throw( new UnknownHostException( "Host '" + host + "' doesn't obey minimal validation rules"));
}
}