core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/WifiConfigurationHelper.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2010, The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.connectivitymanagertest;

 import android.net.IpConfiguration.IpAssignment;
 import android.net.IpConfiguration.ProxySettings;
 import android.net.LinkAddress;
 import android.net.StaticIpConfiguration;
 import android.net.wifi.WifiConfiguration;
 import android.net.wifi.WifiConfiguration.AuthAlgorithm;
 import android.net.wifi.WifiConfiguration.KeyMgmt;
 import android.net.wifi.WifiEnterpriseConfig;

 import org.json.JSONArray;
 import org.json.JSONException;
 import org.json.JSONObject;

 import java.net.InetAddress;
 import java.net.UnknownHostException;
 import java.util.ArrayList;
 import java.util.List;

 /**
  * Helper for dealing with creating {@link WifiConfiguration} objects.
  */
 public class WifiConfigurationHelper {
     private static final int NONE = 0;
     private static final int WEP = 1;
     private static final int PSK = 2;
     private static final int EAP = 3;

     /**
      * Private constructor since this a static class.
      */
     private WifiConfigurationHelper() {}

     /**
      * Create a {@link WifiConfiguration} for an open network
      *
      * @param ssid The SSID of the wifi network
      * @return The {@link WifiConfiguration}
      */
     public static WifiConfiguration createOpenConfig(String ssid) {
         WifiConfiguration config = createGenericConfig(ssid);

         config.allowedKeyManagement.set(KeyMgmt.NONE);
         return config;
     }

     /**
      * Create a {@link WifiConfiguration} for a WEP secured network
      *
      * @param ssid The SSID of the wifi network
      * @param password Either a 10, 26, or 58 character hex string or the plain text password
      * @return The {@link WifiConfiguration}
      */
     public static WifiConfiguration createWepConfig(String ssid, String password) {
         WifiConfiguration config = createGenericConfig(ssid);

         if (isHex(password, 10) || isHex(password, 26) || isHex(password, 58)) {
             config.wepKeys[0] = password;
         } else {
             config.wepKeys[0] = quotedString(password);
         }

         config.allowedKeyManagement.set(KeyMgmt.NONE);
         config.allowedAuthAlgorithms.set(AuthAlgorithm.OPEN);
         config.allowedAuthAlgorithms.set(AuthAlgorithm.SHARED);
         return config;
     }

     /**
      * Create a {@link WifiConfiguration} for a PSK secured network
      *
      * @param ssid The SSID of the wifi network
      * @param password Either a 64 character hex string or the plain text password
      * @return The {@link WifiConfiguration}
      */
     public static WifiConfiguration createPskConfig(String ssid, String password) {
         WifiConfiguration config = createGenericConfig(ssid);

         if (isHex(password, 64)) {
             config.preSharedKey = password;
         } else {
             config.preSharedKey = quotedString(password);
         }
         config.allowedKeyManagement.set(KeyMgmt.WPA_PSK);
         return config;
     }

     /**
      * Create a {@link WifiConfiguration} for an EAP secured network
      *
      * @param ssid The SSID of the wifi network
      * @param password The password
      * @param eapMethod The EAP method
      * @param phase2 The phase 2 method or null
      * @param identity The identity or null
      * @param anonymousIdentity The anonymous identity or null
      * @param caCert The CA certificate or null
      * @param clientCert The client certificate or null
      * @return The {@link WifiConfiguration}
      */
     public static WifiConfiguration createEapConfig(String ssid, String password, int eapMethod,
             Integer phase2, String identity, String anonymousIdentity, String caCert,
             String clientCert) {
         WifiConfiguration config = new WifiConfiguration();
         config.SSID = quotedString(ssid);

         config.allowedKeyManagement.set(KeyMgmt.WPA_EAP);
         config.allowedKeyManagement.set(KeyMgmt.IEEE8021X);

         // Set defaults
         if (phase2 == null) phase2 = WifiEnterpriseConfig.Phase2.NONE;
         if (identity == null) identity = "";
         if (anonymousIdentity == null) anonymousIdentity = "";
         if (caCert == null) caCert = "";
         if (clientCert == null) clientCert = "";

         config.enterpriseConfig.setPassword(password);
         config.enterpriseConfig.setEapMethod(eapMethod);
         config.enterpriseConfig.setPhase2Method(phase2);
         config.enterpriseConfig.setIdentity(identity);
         config.enterpriseConfig.setAnonymousIdentity(anonymousIdentity);
         config.enterpriseConfig.setCaCertificateAlias(caCert);
         config.enterpriseConfig.setClientCertificateAlias(clientCert);
         return config;
     }

     /**
      * Create a generic {@link WifiConfiguration} used by the other create methods.
      */
     private static WifiConfiguration createGenericConfig(String ssid) {
         WifiConfiguration config = new WifiConfiguration();
         config.SSID = quotedString(ssid);
         config.setIpAssignment(IpAssignment.DHCP);
         config.setProxySettings(ProxySettings.NONE);
         return config;
     }

     /**
      * Parse a JSON string for WiFi configurations stored as a JSON string.
      * <p>
      * This json string should be a list of dictionaries, with each dictionary containing a single
      * wifi configuration. The wifi configuration requires the fields "ssid" and "security" with
      * security being one of NONE, WEP, PSK, or EAP. If WEP, PSK, or EAP are selected, the field
      * "password" must also be provided.  If EAP is selected, then the fiels "eap", "phase2",
      * "identity", "ananymous_identity", "ca_cert", and "client_cert" are also required. Lastly,
      * static IP settings are also supported.  If the field "ip" is set, then the fields "gateway",
      * "prefix_length", "dns1", and "dns2" are required.
      * </p>
      * @throws IllegalArgumentException if the input string was not valid JSON or if any mandatory
      * fields are missing.
      */
     public static List<WifiConfiguration> parseJson(String in) {
         try {
             JSONArray jsonConfigs = new JSONArray(in);
             List<WifiConfiguration> wifiConfigs = new ArrayList<>(jsonConfigs.length());

             for (int i = 0; i < jsonConfigs.length(); i++) {
                 JSONObject jsonConfig = jsonConfigs.getJSONObject(i);

                 wifiConfigs.add(getWifiConfiguration(jsonConfig));
             }
             return wifiConfigs;
         } catch (JSONException e) {
             throw new IllegalArgumentException(e);
         }
     }

     /**
      * Parse a {@link JSONObject} and return the wifi configuration.
      *
      * @throws IllegalArgumentException if any mandatory fields are missing.
      */
     private static WifiConfiguration getWifiConfiguration(JSONObject jsonConfig)
             throws JSONException {
         String ssid = jsonConfig.getString("ssid");
         String password = null;
         WifiConfiguration config;

         int securityType = getSecurityType(jsonConfig.getString("security"));
         switch (securityType) {
             case NONE:
                 config = createOpenConfig(ssid);
                 break;
             case WEP:
                 password = jsonConfig.getString("password");
                 config = createWepConfig(ssid, password);
                 break;
             case PSK:
                 password = jsonConfig.getString("password");
                 config = createPskConfig(ssid, password);
                 break;
             case EAP:
                 password = jsonConfig.getString("password");
                 int eapMethod = getEapMethod(jsonConfig.getString("eap"));
                 Integer phase2 = null;
                 if (jsonConfig.has("phase2")) {
                     phase2 = getPhase2(jsonConfig.getString("phase2"));
                 }
                 String identity = null;
                 if (jsonConfig.has("identity")) {
                     identity = jsonConfig.getString("identity");
                 }
                 String anonymousIdentity = null;
                 if (jsonConfig.has("anonymous_identity")) {
                     anonymousIdentity = jsonConfig.getString("anonymous_identity");
                 }
                 String caCert = null;
                 if (jsonConfig.has("ca_cert")) {
                     caCert = (jsonConfig.getString("ca_cert"));
                 }
                 String clientCert = null;
                 if (jsonConfig.has("client_cert")) {
                     clientCert = jsonConfig.getString("client_cert");
                 }
                 config = createEapConfig(ssid, password, eapMethod, phase2, identity,
                         anonymousIdentity, caCert, clientCert);
                 break;
             default:
                 // Should never reach here as getSecurityType will already throw an exception
                 throw new IllegalArgumentException();
         }

         if (jsonConfig.has("ip")) {
             StaticIpConfiguration staticIpConfig = new StaticIpConfiguration();

             InetAddress ipAddress = getInetAddress(jsonConfig.getString("ip"));
             int prefixLength = getPrefixLength(jsonConfig.getInt("prefix_length"));
             staticIpConfig.ipAddress = new LinkAddress(ipAddress, prefixLength);
             staticIpConfig.gateway = getInetAddress(jsonConfig.getString("gateway"));
             staticIpConfig.dnsServers.add(getInetAddress(jsonConfig.getString("dns1")));
             staticIpConfig.dnsServers.add(getInetAddress(jsonConfig.getString("dns2")));

             config.setIpAssignment(IpAssignment.STATIC);
             config.setStaticIpConfiguration(staticIpConfig);
         } else {
             config.setIpAssignment(IpAssignment.DHCP);
         }

         config.setProxySettings(ProxySettings.NONE);
         return config;
     }

     private static String quotedString(String s) {
         return String.format("\"%s\"", s);
     }

     /**
      * Get the security type from a string.
      *
      * @throws IllegalArgumentException if the string is not a supported security type.
      */
     private static int getSecurityType(String security) {
         if ("NONE".equalsIgnoreCase(security)) {
             return NONE;
         }
         if ("WEP".equalsIgnoreCase(security)) {
             return WEP;
         }
         if ("PSK".equalsIgnoreCase(security)) {
             return PSK;
         }
         if ("EAP".equalsIgnoreCase(security)) {
             return EAP;
         }
         throw new IllegalArgumentException("Security type must be one of NONE, WEP, PSK, or EAP");
     }

     /**
      * Get the EAP method from a string.
      *
      * @throws IllegalArgumentException if the string is not a supported EAP method.
      */
     private static int getEapMethod(String eapMethod) {
         if ("TLS".equalsIgnoreCase(eapMethod)) {
             return WifiEnterpriseConfig.Eap.TLS;
         }
         if ("TTLS".equalsIgnoreCase(eapMethod)) {
             return WifiEnterpriseConfig.Eap.TTLS;
         }
         if ("PEAP".equalsIgnoreCase(eapMethod)) {
             return WifiEnterpriseConfig.Eap.PEAP;
         }
         throw new IllegalArgumentException("EAP method must be one of TLS, TTLS, or PEAP");
     }

     /**
      * Get the phase 2 method from a string.
      *
      * @throws IllegalArgumentException if the string is not a supported phase 2 method.
      */
     private static int getPhase2(String phase2) {
         if ("PAP".equalsIgnoreCase(phase2)) {
             return WifiEnterpriseConfig.Phase2.PAP;
         }
         if ("MSCHAP".equalsIgnoreCase(phase2)) {
             return WifiEnterpriseConfig.Phase2.MSCHAP;
         }
         if ("MSCHAPV2".equalsIgnoreCase(phase2)) {
             return WifiEnterpriseConfig.Phase2.MSCHAPV2;
         }
         if ("GTC".equalsIgnoreCase(phase2)) {
             return WifiEnterpriseConfig.Phase2.GTC;
         }
         throw new IllegalArgumentException("Phase2 must be one of PAP, MSCHAP, MSCHAPV2, or GTC");
     }

     /**
      * Get an {@link InetAddress} from a string
      *
      * @throws IllegalArgumentException if the string is not a valid IP address.
      */
     private static InetAddress getInetAddress(String ipAddress) {
         if (!InetAddress.isNumeric(ipAddress)) {
             throw new IllegalArgumentException(
                     String.format("IP address %s is not numeric", ipAddress));
         }

         try {
             return InetAddress.getByName(ipAddress);
         } catch (UnknownHostException e) {
             throw new IllegalArgumentException(
                     String.format("IP address %s could not be resolved", ipAddress));
         }
     }

     /**
      * Get the prefix length from an int.
      *
      * @throws IllegalArgumentException if the prefix length is less than 0 or greater than 32.
      */
     private static int getPrefixLength(int prefixLength) {
         if (prefixLength < 0 || prefixLength > 32) {
             throw new IllegalArgumentException("Prefix length cannot be less than 0 or more than 32");
         }
         return prefixLength;
     }

     /**
      * Utility method to check if a given string is a hexadecimal string of given length
      */
     public static boolean isHex(String input, int length) {
         if (input == null || length < 0) {
             return false;
         }
         return input.matches(String.format("[0-9A-Fa-f]{%d}", length));
     }
 }
	/*
	* Copyright (C) 2010, The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.connectivitymanagertest;

	import android.net.IpConfiguration.IpAssignment;
	import android.net.IpConfiguration.ProxySettings;
	import android.net.LinkAddress;
	import android.net.StaticIpConfiguration;
	import android.net.wifi.WifiConfiguration;
	import android.net.wifi.WifiConfiguration.AuthAlgorithm;
	import android.net.wifi.WifiConfiguration.KeyMgmt;
	import android.net.wifi.WifiEnterpriseConfig;

	import org.json.JSONArray;
	import org.json.JSONException;
	import org.json.JSONObject;

	import java.net.InetAddress;
	import java.net.UnknownHostException;
	import java.util.ArrayList;
	import java.util.List;

	/**
	* Helper for dealing with creating {@link WifiConfiguration} objects.
	*/
	public class WifiConfigurationHelper {
	private static final int NONE = 0;
	private static final int WEP = 1;
	private static final int PSK = 2;
	private static final int EAP = 3;

	/**
	* Private constructor since this a static class.
	*/
	private WifiConfigurationHelper() {}

	/**
	* Create a {@link WifiConfiguration} for an open network
	*
	* @param ssid The SSID of the wifi network
	* @return The {@link WifiConfiguration}
	*/
	public static WifiConfiguration createOpenConfig(String ssid) {
	WifiConfiguration config = createGenericConfig(ssid);

	config.allowedKeyManagement.set(KeyMgmt.NONE);
	return config;
	}

	/**
	* Create a {@link WifiConfiguration} for a WEP secured network
	*
	* @param ssid The SSID of the wifi network
	* @param password Either a 10, 26, or 58 character hex string or the plain text password
	* @return The {@link WifiConfiguration}
	*/
	public static WifiConfiguration createWepConfig(String ssid, String password) {
	WifiConfiguration config = createGenericConfig(ssid);

	if (isHex(password, 10) \|\| isHex(password, 26) \|\| isHex(password, 58)) {
	config.wepKeys[0] = password;
	} else {
	config.wepKeys[0] = quotedString(password);
	}

	config.allowedKeyManagement.set(KeyMgmt.NONE);
	config.allowedAuthAlgorithms.set(AuthAlgorithm.OPEN);
	config.allowedAuthAlgorithms.set(AuthAlgorithm.SHARED);
	return config;
	}

	/**
	* Create a {@link WifiConfiguration} for a PSK secured network
	*
	* @param ssid The SSID of the wifi network
	* @param password Either a 64 character hex string or the plain text password
	* @return The {@link WifiConfiguration}
	*/
	public static WifiConfiguration createPskConfig(String ssid, String password) {
	WifiConfiguration config = createGenericConfig(ssid);

	if (isHex(password, 64)) {
	config.preSharedKey = password;
	} else {
	config.preSharedKey = quotedString(password);
	}
	config.allowedKeyManagement.set(KeyMgmt.WPA_PSK);
	return config;
	}

	/**
	* Create a {@link WifiConfiguration} for an EAP secured network
	*
	* @param ssid The SSID of the wifi network
	* @param password The password
	* @param eapMethod The EAP method
	* @param phase2 The phase 2 method or null
	* @param identity The identity or null
	* @param anonymousIdentity The anonymous identity or null
	* @param caCert The CA certificate or null
	* @param clientCert The client certificate or null
	* @return The {@link WifiConfiguration}
	*/
	public static WifiConfiguration createEapConfig(String ssid, String password, int eapMethod,
	Integer phase2, String identity, String anonymousIdentity, String caCert,
	String clientCert) {
	WifiConfiguration config = new WifiConfiguration();
	config.SSID = quotedString(ssid);

	config.allowedKeyManagement.set(KeyMgmt.WPA_EAP);
	config.allowedKeyManagement.set(KeyMgmt.IEEE8021X);

	// Set defaults
	if (phase2 == null) phase2 = WifiEnterpriseConfig.Phase2.NONE;
	if (identity == null) identity = "";
	if (anonymousIdentity == null) anonymousIdentity = "";
	if (caCert == null) caCert = "";
	if (clientCert == null) clientCert = "";

	config.enterpriseConfig.setPassword(password);
	config.enterpriseConfig.setEapMethod(eapMethod);
	config.enterpriseConfig.setPhase2Method(phase2);
	config.enterpriseConfig.setIdentity(identity);
	config.enterpriseConfig.setAnonymousIdentity(anonymousIdentity);
	config.enterpriseConfig.setCaCertificateAlias(caCert);
	config.enterpriseConfig.setClientCertificateAlias(clientCert);
	return config;
	}

	/**
	* Create a generic {@link WifiConfiguration} used by the other create methods.
	*/
	private static WifiConfiguration createGenericConfig(String ssid) {
	WifiConfiguration config = new WifiConfiguration();
	config.SSID = quotedString(ssid);
	config.setIpAssignment(IpAssignment.DHCP);
	config.setProxySettings(ProxySettings.NONE);
	return config;
	}

	/**
	* Parse a JSON string for WiFi configurations stored as a JSON string.
	* <p>
	* This json string should be a list of dictionaries, with each dictionary containing a single
	* wifi configuration. The wifi configuration requires the fields "ssid" and "security" with
	* security being one of NONE, WEP, PSK, or EAP. If WEP, PSK, or EAP are selected, the field
	* "password" must also be provided. If EAP is selected, then the fiels "eap", "phase2",
	* "identity", "ananymous_identity", "ca_cert", and "client_cert" are also required. Lastly,
	* static IP settings are also supported. If the field "ip" is set, then the fields "gateway",
	* "prefix_length", "dns1", and "dns2" are required.
	* </p>
	* @throws IllegalArgumentException if the input string was not valid JSON or if any mandatory
	* fields are missing.
	*/
	public static List<WifiConfiguration> parseJson(String in) {
	try {
	JSONArray jsonConfigs = new JSONArray(in);
	List<WifiConfiguration> wifiConfigs = new ArrayList<>(jsonConfigs.length());

	for (int i = 0; i < jsonConfigs.length(); i++) {
	JSONObject jsonConfig = jsonConfigs.getJSONObject(i);

	wifiConfigs.add(getWifiConfiguration(jsonConfig));
	}
	return wifiConfigs;
	} catch (JSONException e) {
	throw new IllegalArgumentException(e);
	}
	}

	/**
	* Parse a {@link JSONObject} and return the wifi configuration.
	*
	* @throws IllegalArgumentException if any mandatory fields are missing.
	*/
	private static WifiConfiguration getWifiConfiguration(JSONObject jsonConfig)
	throws JSONException {
	String ssid = jsonConfig.getString("ssid");
	String password = null;
	WifiConfiguration config;

	int securityType = getSecurityType(jsonConfig.getString("security"));
	switch (securityType) {
	case NONE:
	config = createOpenConfig(ssid);
	break;
	case WEP:
	password = jsonConfig.getString("password");
	config = createWepConfig(ssid, password);
	break;
	case PSK:
	password = jsonConfig.getString("password");
	config = createPskConfig(ssid, password);
	break;
	case EAP:
	password = jsonConfig.getString("password");
	int eapMethod = getEapMethod(jsonConfig.getString("eap"));
	Integer phase2 = null;
	if (jsonConfig.has("phase2")) {
	phase2 = getPhase2(jsonConfig.getString("phase2"));
	}
	String identity = null;
	if (jsonConfig.has("identity")) {
	identity = jsonConfig.getString("identity");
	}
	String anonymousIdentity = null;
	if (jsonConfig.has("anonymous_identity")) {
	anonymousIdentity = jsonConfig.getString("anonymous_identity");
	}
	String caCert = null;
	if (jsonConfig.has("ca_cert")) {
	caCert = (jsonConfig.getString("ca_cert"));
	}
	String clientCert = null;
	if (jsonConfig.has("client_cert")) {
	clientCert = jsonConfig.getString("client_cert");
	}
	config = createEapConfig(ssid, password, eapMethod, phase2, identity,
	anonymousIdentity, caCert, clientCert);
	break;
	default:
	// Should never reach here as getSecurityType will already throw an exception
	throw new IllegalArgumentException();
	}

	if (jsonConfig.has("ip")) {
	StaticIpConfiguration staticIpConfig = new StaticIpConfiguration();

	InetAddress ipAddress = getInetAddress(jsonConfig.getString("ip"));
	int prefixLength = getPrefixLength(jsonConfig.getInt("prefix_length"));
	staticIpConfig.ipAddress = new LinkAddress(ipAddress, prefixLength);
	staticIpConfig.gateway = getInetAddress(jsonConfig.getString("gateway"));
	staticIpConfig.dnsServers.add(getInetAddress(jsonConfig.getString("dns1")));
	staticIpConfig.dnsServers.add(getInetAddress(jsonConfig.getString("dns2")));

	config.setIpAssignment(IpAssignment.STATIC);
	config.setStaticIpConfiguration(staticIpConfig);
	} else {
	config.setIpAssignment(IpAssignment.DHCP);
	}

	config.setProxySettings(ProxySettings.NONE);
	return config;
	}

	private static String quotedString(String s) {
	return String.format("\"%s\"", s);
	}

	/**
	* Get the security type from a string.
	*
	* @throws IllegalArgumentException if the string is not a supported security type.
	*/
	private static int getSecurityType(String security) {
	if ("NONE".equalsIgnoreCase(security)) {
	return NONE;
	}
	if ("WEP".equalsIgnoreCase(security)) {
	return WEP;
	}
	if ("PSK".equalsIgnoreCase(security)) {
	return PSK;
	}
	if ("EAP".equalsIgnoreCase(security)) {
	return EAP;
	}
	throw new IllegalArgumentException("Security type must be one of NONE, WEP, PSK, or EAP");
	}

	/**
	* Get the EAP method from a string.
	*
	* @throws IllegalArgumentException if the string is not a supported EAP method.
	*/
	private static int getEapMethod(String eapMethod) {
	if ("TLS".equalsIgnoreCase(eapMethod)) {
	return WifiEnterpriseConfig.Eap.TLS;
	}
	if ("TTLS".equalsIgnoreCase(eapMethod)) {
	return WifiEnterpriseConfig.Eap.TTLS;
	}
	if ("PEAP".equalsIgnoreCase(eapMethod)) {
	return WifiEnterpriseConfig.Eap.PEAP;
	}
	throw new IllegalArgumentException("EAP method must be one of TLS, TTLS, or PEAP");
	}

	/**
	* Get the phase 2 method from a string.
	*
	* @throws IllegalArgumentException if the string is not a supported phase 2 method.
	*/
	private static int getPhase2(String phase2) {
	if ("PAP".equalsIgnoreCase(phase2)) {
	return WifiEnterpriseConfig.Phase2.PAP;
	}
	if ("MSCHAP".equalsIgnoreCase(phase2)) {
	return WifiEnterpriseConfig.Phase2.MSCHAP;
	}
	if ("MSCHAPV2".equalsIgnoreCase(phase2)) {
	return WifiEnterpriseConfig.Phase2.MSCHAPV2;
	}
	if ("GTC".equalsIgnoreCase(phase2)) {
	return WifiEnterpriseConfig.Phase2.GTC;
	}
	throw new IllegalArgumentException("Phase2 must be one of PAP, MSCHAP, MSCHAPV2, or GTC");
	}

	/**
	* Get an {@link InetAddress} from a string
	*
	* @throws IllegalArgumentException if the string is not a valid IP address.
	*/
	private static InetAddress getInetAddress(String ipAddress) {
	if (!InetAddress.isNumeric(ipAddress)) {
	throw new IllegalArgumentException(
	String.format("IP address %s is not numeric", ipAddress));
	}

	try {
	return InetAddress.getByName(ipAddress);
	} catch (UnknownHostException e) {
	throw new IllegalArgumentException(
	String.format("IP address %s could not be resolved", ipAddress));
	}
	}

	/**
	* Get the prefix length from an int.
	*
	* @throws IllegalArgumentException if the prefix length is less than 0 or greater than 32.
	*/
	private static int getPrefixLength(int prefixLength) {
	if (prefixLength < 0 \|\| prefixLength > 32) {
	throw new IllegalArgumentException("Prefix length cannot be less than 0 or more than 32");
	}
	return prefixLength;
	}

	/**
	* Utility method to check if a given string is a hexadecimal string of given length
	*/
	public static boolean isHex(String input, int length) {
	if (input == null \|\| length < 0) {
	return false;
	}
	return input.matches(String.format("[0-9A-Fa-f]{%d}", length));
	}
	}