/**
* Get all predefined all floating IPs defined in cartridge definition.
*
* @param array of {@link NetworkInterface}
* @return list of predefined floating IPs
*/
public List<String> getAllPredefinedFloatingIPs(NetworkInterface[] networkInterfaces) {
String nwInterfacesNullMsg = "Input NetworkInterface array cannot be null";
assertNotNull(networkInterfaces, nwInterfacesNullMsg);
List<String> allPredefinedFloatingIPs = new ArrayList<String>();
for (NetworkInterface networkInterface : networkInterfaces) {
// if no floating networks defined, skip it
if (null == networkInterface.getFloatingNetworks()) {
continue;
}
FloatingNetwork[] floatingNetworks =
networkInterface.getFloatingNetworks().getFloatingNetworks();
if (floatingNetworks == null || floatingNetworks.length == 0) {
continue;
}
for (FloatingNetwork floatingNetwork : floatingNetworks) {
String floatingIP = floatingNetwork.getFloatingIP();
// we are giving more priority to network uuid over fixed floating IPs
// so if both network uuid and floating IPs defined, we are not going to assign those
// floating IPs
// so these can be assigned to some other interfaces
// hence excluding from predefined floating IPs list
String networkUuid = floatingNetwork.getNetworkUuid();
if (networkUuid == null || networkUuid.isEmpty()) {
if (floatingIP != null && InetAddresses.isInetAddress(floatingIP)) {
allPredefinedFloatingIPs.add(floatingIP);
}
}
}
}
return allPredefinedFloatingIPs;
}
public void testForStringIPv6Input() throws UnknownHostException {
String ipStr = "3ffe::1";
InetAddress ipv6Addr = null;
// Shouldn't hit DNS, because it's an IP string literal.
ipv6Addr = InetAddress.getByName(ipStr);
assertEquals(ipv6Addr, InetAddresses.forString(ipStr));
assertTrue(InetAddresses.isInetAddress(ipStr));
}
public void test3ff31() {
try {
InetAddresses.forString("3ffe:::1");
fail("IllegalArgumentException expected");
} catch (IllegalArgumentException expected) {
// expected behavior
}
assertFalse(InetAddresses.isInetAddress("016.016.016.016"));
}
public void testConvertDottedQuadToHex() throws UnknownHostException {
String[] ipStrings = {
"7::0.128.0.127", "7::0.128.0.128", "7::128.128.0.127", "7::0.128.128.127"
};
for (String ipString : ipStrings) {
// Shouldn't hit DNS, because it's an IP string literal.
InetAddress ipv6Addr = InetAddress.getByName(ipString);
assertEquals(ipv6Addr, InetAddresses.forString(ipString));
assertTrue(InetAddresses.isInetAddress(ipString));
}
}
public void testForStringIPv6EightColons() throws UnknownHostException {
String[] eightColons = {
"::7:6:5:4:3:2:1", "::7:6:5:4:3:2:0", "7:6:5:4:3:2:1::", "0:6:5:4:3:2:1::",
};
for (int i = 0; i < eightColons.length; i++) {
InetAddress ipv6Addr = null;
// Shouldn't hit DNS, because it's an IP string literal.
ipv6Addr = InetAddress.getByName(eightColons[i]);
assertEquals(ipv6Addr, InetAddresses.forString(eightColons[i]));
assertTrue(InetAddresses.isInetAddress(eightColons[i]));
}
}
/**
* Tests the SMTP settings from the initial setup form, rendering the result as JSON.
*
* @param setup the initial setup form.
*/
@Restrictions({
@Restrict({"SYSTEM_ADMIN", "SECURITY_ADMIN"}),
@Restrict({"RESTRICTED_SYSTEM_ADMIN", "RESTRICTED_SECURITY_ADMIN"})
})
public static void testSmtpSettings(SetupForm setup) {
setup.validateSmtp();
Validation.required("setup.smtpTo", setup.smtpTo);
Validation.email("setup.smtpTo", setup.smtpTo);
if (Validation.hasErrors()) {
renderJSON(ValidationResponse.collectErrors());
}
MailSettingsValidator.Settings settings = new MailSettingsValidator.Settings();
if (StringUtils.isNotEmpty(setup.nameservers)
&& !InetAddresses.isInetAddress(setup.smtpServer)) {
Set<String> ips = Sets.newHashSet(setup.nameservers.split(","));
try {
settings.server = DnsUtils.getHostIpAddress(ips, setup.smtpServer).getHostAddress();
} catch (ViPRException e) {
renderJSON(ValidationResponse.invalid(e.getMessage()));
}
} else {
settings.server = setup.smtpServer;
}
settings.port = ConfigProperties.getPort(setup.smtpPort, setup.smtpEnableTls);
settings.username = setup.smtpUsername;
settings.password = PasswordUtil.decryptedValue(setup.smtpPassword);
settings.channel = StringUtils.equals("yes", setup.smtpEnableTls) ? "starttls" : "clear";
settings.authType = setup.smtpAuthType;
settings.fromAddress = setup.smtpFrom;
try {
MailSettingsValidator.validate(settings, setup.smtpTo);
} catch (RuntimeException e) {
Logger.error(e, "Failed to send email");
Validation.addError(null, "setup.testEmail.failure", e.getMessage());
if (StringUtils.isEmpty(setup.nameservers)) {
Validation.addError(null, "setup.smtpServer.invalidEmptyNameserver");
}
}
if (Validation.hasErrors()) {
renderJSON(ValidationResponse.collectErrors());
} else {
renderJSON(ValidationResponse.valid(MessagesUtils.get("setup.testEmail.success")));
}
}
public static long ipToLong(String ip) throws ElasticsearchIllegalArgumentException {
try {
if (!InetAddresses.isInetAddress(ip)) {
throw new ElasticsearchIllegalArgumentException(
"failed to parse ip [" + ip + "], not a valid ip address");
}
String[] octets = pattern.split(ip);
if (octets.length != 4) {
throw new ElasticsearchIllegalArgumentException(
"failed to parse ip [" + ip + "], not a valid ipv4 address (4 dots)");
}
return (Long.parseLong(octets[0]) << 24)
+ (Integer.parseInt(octets[1]) << 16)
+ (Integer.parseInt(octets[2]) << 8)
+ Integer.parseInt(octets[3]);
} catch (Exception e) {
if (e instanceof ElasticsearchIllegalArgumentException) {
throw (ElasticsearchIllegalArgumentException) e;
}
throw new ElasticsearchIllegalArgumentException("failed to parse ip [" + ip + "]", e);
}
}
public static void checkIpAddress(String ip) {
InetAddresses.isInetAddress(ip);
}
/**
* Check whether the given IP is valid.
*
* @param ip IP to be validated
* @return true if valid, false otherwise
*/
private boolean isValidIP(String ip) {
return (ip != null && InetAddresses.isInetAddress(ip));
}
@Override
public boolean onCommand(
final CommandSender sender, Command command, String commandName, String[] args) {
if (args.length < 1) {
return false;
}
if (CommandUtils.isValidNameDelimiter(args[0])) {
CommandUtils.handleMultipleNames(sender, commandName, args);
return true;
}
final String ipStr = args[0];
final boolean isName = !InetAddresses.isInetAddress(ipStr);
if (isName && ipStr.length() > 16) {
Message message = Message.get("sender.error.invalidIp");
message.set("ip", ipStr);
sender.sendMessage(message.toString());
return true;
}
final String reason = args.length > 1 ? CommandUtils.getReason(1, args).getMessage() : "";
plugin
.getServer()
.getScheduler()
.runTaskAsynchronously(
plugin,
new Runnable() {
@Override
public void run() {
final Long ip = CommandUtils.getIp(ipStr);
if (ip == null) {
sender.sendMessage(
Message.get("sender.error.notFound").set("player", ipStr).toString());
return;
}
if (!plugin.getIpMuteStorage().isMuted(ip)) {
Message message = Message.get("unmuteip.error.noExists");
message.set("ip", ipStr);
sender.sendMessage(message.toString());
return;
}
IpMuteData mute = plugin.getIpMuteStorage().getMute(ip);
final PlayerData actor = CommandUtils.getActor(sender);
if (actor == null) return;
boolean unmuted;
try {
unmuted = plugin.getIpMuteStorage().unmute(mute, actor, reason);
} catch (SQLException e) {
sender.sendMessage(Message.get("sender.error.exception").toString());
e.printStackTrace();
return;
}
if (!unmuted) {
return;
}
Message message = Message.get("unmuteip.notify");
message.set("ip", ipStr).set("actor", actor.getName()).set("reason", reason);
if (!sender.hasPermission("bm.notify.unmuteip")) {
message.sendTo(sender);
}
CommandUtils.broadcast(message.toString(), "bm.notify.unmuteip");
}
});
return true;
}
public void testForStringBogusInput() {
String[] bogusInputs = {
"",
"016.016.016.016",
"016.016.016",
"016.016",
"016",
"000.000.000.000",
"000",
"0x0a.0x0a.0x0a.0x0a",
"0x0a.0x0a.0x0a",
"0x0a.0x0a",
"0x0a",
"42.42.42.42.42",
"42.42.42",
"42.42",
"42",
"42..42.42",
"42..42.42.42",
"42.42.42.42.",
"42.42.42.42...",
".42.42.42.42",
"...42.42.42.42",
"42.42.42.-0",
"42.42.42.+0",
".",
"...",
"bogus",
"bogus.com",
"192.168.0.1.com",
"12345.67899.-54321.-98765",
"257.0.0.0",
"42.42.42.-42",
"3ffe::1.net",
"3ffe::1::1",
"1::2::3::4:5",
"::7:6:5:4:3:2:", // should end with ":0"
":6:5:4:3:2:1::", // should begin with "0:"
"2001::db:::1",
"FEDC:9878",
"+1.+2.+3.4",
"1.2.3.4e0",
"::7:6:5:4:3:2:1:0", // too many parts
"7:6:5:4:3:2:1:0::", // too many parts
"9:8:7:6:5:4:3::2:1", // too many parts
"0:1:2:3::4:5:6:7", // :: must remove at least one 0.
"3ffe:0:0:0:0:0:0:0:1", // too many parts (9 instead of 8)
"3ffe::10000", // hextet exceeds 16 bits
"3ffe::goog",
"3ffe::-0",
"3ffe::+0",
"3ffe::-1",
":",
":::",
"::1.2.3",
"::1.2.3.4.5",
"::1.2.3.4:",
"1.2.3.4::",
"2001:db8::1:",
":2001:db8::1",
":1:2:3:4:5:6:7",
"1:2:3:4:5:6:7:",
":1:2:3:4:5:6:"
};
for (int i = 0; i < bogusInputs.length; i++) {
try {
InetAddresses.forString(bogusInputs[i]);
fail("IllegalArgumentException expected for '" + bogusInputs[i] + "'");
} catch (IllegalArgumentException expected) {
// expected behavior
}
assertFalse(InetAddresses.isInetAddress(bogusInputs[i]));
}
}
