com.ardikars.jxpacket.spring.boot.JxnetAutoConfiguration Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jxpacket-spring-boot-autoconfigure Show documentation
Show all versions of jxpacket-spring-boot-autoconfigure Show documentation
Jxpacket is a network packet crafting library for java.
/**
* Copyright (C) 2017-2018 Ardika Rommy Sanjaya
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see alldevsp = new ArrayList<>();
if (PcapFindAllDevs(alldevsp, errbuf) != OK && LOGGER.isDebugEnabled()) {
LOGGER.debug("Error: {}", errbuf.toString());
}
if (source == null || source.isEmpty()) {
for (PcapIf dev : alldevsp) {
for (PcapAddr addr : dev.getAddresses()) {
if (addr.getAddr().getSaFamily() == SockAddr.Family.AF_INET && addr.getAddr().getData() != null) {
Inet4Address d = Inet4Address.valueOf(addr.getAddr().getData());
if (!d.equals(Inet4Address.LOCALHOST) && !d.equals(Inet4Address.ZERO)) {
return parsePcapNetworkInterface(dev);
}
}
}
}
} else {
for (PcapIf dev : alldevsp) {
if (dev.getName().equals(source)) {
return parsePcapNetworkInterface(dev);
}
}
}
throw new DeviceNotFoundException();
}
/**
* Error buffer.
* @return error buffer.
*/
@Bean
public StringBuilder errbuf() {
return new StringBuilder();
}
private PcapNetworkInterface parsePcapNetworkInterface(PcapIf networkInterface) {
List hardwareAddresses = findHardwareAddress(networkInterface);
List addresses = findAddresses(networkInterface);
return new PcapNetworkInterface.Builder()
.name(networkInterface.getName())
.description(networkInterface.getDescription())
.hardwareAddresses(hardwareAddresses)
.addresses(addresses)
.loopback(networkInterface.isLoopback())
.up(networkInterface.isUp())
.running(networkInterface.isRunning())
.addresses(addresses)
.build();
}
private List findHardwareAddress(PcapIf networkInterface) {
List hardwareAddresses = new ArrayList<>();
if (networkInterface.isLoopback()) {
hardwareAddresses.add(MacAddress.ZERO);
} else {
if (Platforms.isWindows()) {
byte[] hardwareAddress = FindHardwareAddress(networkInterface.getName());
if (hardwareAddress != null && hardwareAddress.length == MacAddress.MAC_ADDRESS_LENGTH) {
hardwareAddresses.add(MacAddress.valueOf(hardwareAddress));
} else {
return hardwareAddresses;
}
} else {
try {
hardwareAddresses.add(MacAddress.fromNicName(networkInterface.getName()));
} catch (SocketException e) {
return hardwareAddresses;
}
}
}
return hardwareAddresses;
}
private List findAddresses(PcapIf networkInterface) {
return networkInterface.getAddresses().stream()
.filter(pcapAddr -> pcapAddr.getAddr().getSaFamily() == SockAddr.Family.AF_INET
|| pcapAddr.getAddr().getSaFamily() == SockAddr.Family.AF_INET6)
.map(pcapAddr -> {
byte[] rawAddress = pcapAddr.getAddr().getData();
byte[] rawNetmask = pcapAddr.getNetmask().getData();
byte[] rawBroadcastAddress = pcapAddr.getBroadAddr().getData();
byte[] rawDestinationAddress = pcapAddr.getBroadAddr().getData();
if (pcapAddr.getAddr().getSaFamily() == SockAddr.Family.AF_INET) {
Inet4Address address;
Inet4Address netmask;
Inet4Address broadcastAddress;
Inet4Address destinationAddress;
if (rawAddress != null && rawAddress.length == Inet4Address.IPV4_ADDRESS_LENGTH) {
address = Inet4Address.valueOf(rawAddress);
} else {
address = Inet4Address.valueOf(0);
}
if (rawNetmask != null && rawNetmask.length == Inet4Address.IPV4_ADDRESS_LENGTH) {
netmask = Inet4Address.valueOf(rawNetmask);
} else {
netmask = Inet4Address.valueOf(0);
}
if (rawBroadcastAddress != null && rawBroadcastAddress.length == Inet4Address.IPV4_ADDRESS_LENGTH) {
broadcastAddress = Inet4Address.valueOf(rawBroadcastAddress);
} else {
broadcastAddress = Inet4Address.valueOf(0);
}
if (rawDestinationAddress != null && rawDestinationAddress.length == Inet4Address.IPV4_ADDRESS_LENGTH) {
destinationAddress = Inet4Address.valueOf(rawDestinationAddress);
} else {
destinationAddress = Inet4Address.valueOf(0);
}
return new PcapNetworkInterface.PcapInet4Address.Builder()
.address(address)
.netmask(netmask)
.broadcastAddress(broadcastAddress)
.destinationAddress(destinationAddress)
.build();
} else {
Inet6Address address;
Inet6Address netmask;
Inet6Address broadcastAddress;
Inet6Address destinationAddress;
if (rawAddress != null && rawAddress.length == Inet6Address.IPV6_ADDRESS_LENGTH) {
address = Inet6Address.valueOf(rawAddress);
} else {
address = Inet6Address.valueOf(IPV6_ZERO_BYTES);
}
if (rawNetmask != null && rawNetmask.length == Inet6Address.IPV6_ADDRESS_LENGTH) {
netmask = Inet6Address.valueOf(rawNetmask);
} else {
netmask = Inet6Address.valueOf(IPV6_ZERO_BYTES);
}
if (rawBroadcastAddress != null && rawBroadcastAddress.length == Inet6Address.IPV6_ADDRESS_LENGTH) {
broadcastAddress = Inet6Address.valueOf(rawBroadcastAddress);
} else {
broadcastAddress = Inet6Address.valueOf(IPV6_ZERO_BYTES);
}
if (rawDestinationAddress != null && rawDestinationAddress.length == Inet6Address.IPV6_ADDRESS_LENGTH) {
destinationAddress = Inet6Address.valueOf(rawDestinationAddress);
} else {
destinationAddress = Inet6Address.valueOf(IPV6_ZERO_BYTES);
}
return new PcapNetworkInterface.PcapInet6Address.Builder()
.address(address)
.netmask(netmask)
.broadcastAddress(broadcastAddress)
.destinationAddress(destinationAddress)
.build();
}
}).collect(Collectors.toList());
}
@Override
public String prettyApplicationInformation() {
return new StringBuilder()
.append("Jxnet")
.append(super.toString()).toString();
}
@Override
public String toString() {
return prettyApplicationInformation();
}
}