IPUtils

package com.zte.anyservice.iecs.ros.virtual.zxve.ippool.util;

import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import com.zte.anyservice.iecs.ros.virtual.domain.ippool.IpRangeInfo;

public class IpAddressUtil
{
    /**
     * 
     * [简要描述]:ipAdd [详细描述]:ip地址加1，如1.2.3.4加1之后为1.2.3.5
     * 
     * @param ip
     *            ip地址
     * @return e 加1之后的ip地址
     */
    public static String ipAdd(String ip)
    {
        String[] tempArray = ip.split("[.]");
        int[] ipArray = new int[4];
        // 把ip地址的各个子段转换为数字
        for (int i = 0; i < 4; i++)
        {
            ipArray[i] = Integer.parseInt(tempArray[i]);
        }
        // 如果第四段小于255，那么最后一段直接加1
        if (ipArray[3] < 255)
        {
            ipArray[3] = ipArray[3] + 1;
        }
        else
        {
            // 如果第四段等于255，第三段小于255，那么第三段加1，第四段修改成0；
            if (ipArray[2] < 255)
            {
                ipArray[2] = ipArray[2] + 1;
                ipArray[3] = 0;
            }
            else
            {
                // 如果第三段和第四段都是255，第二段小于255，那么第二段加1，第三段和第四段修改为0
                if (ipArray[1] < 255)
                {
                    ipArray[1] = ipArray[1] + 1;
                    ipArray[2] = 0;
                    ipArray[3] = 0;
                }
                else
                {
                    // 如果最后三段都是255，第一段小于255，那么第一段加1，后三段修改为0
                    if (ipArray[0] < 255)
                    {
                        ipArray[0] = ipArray[0] + 1;
                        ipArray[1] = 0;
                        ipArray[2] = 0;
                        ipArray[3] = 0;
                    }
                }
            }
        }
        // 输出ip地址串
        return ipArrayToString(ipArray);
    }

    /**
     * 
     * [简要描述]:ipArrayToString [详细描述]:输出ip地址串
     * 
     * @param ipArray
     *            ip各个子段组成的数组
     * @return e
     */
    private static String ipArrayToString(int[] ipArray)
    {
        return ipArray[0] + "." + ipArray[1] + "." + ipArray[2] + "." + ipArray[3];
    }

    /**
     * 
     * [简要描述]:formatNumStrToBinary [详细描述]:将一个数字串转换为8位二进制字符串返回
     * 
     * @param numStr
     *            数字字符串
     * @return e 对应的8位二进制串，如传参255，返回11111111
     */
    public static String formatNumStrToBinary(String numStr)
    {
        // 转换为二进制串
        String binaryStr = Integer.toBinaryString(Integer.parseInt(numStr));
        // 不足8位，前面补0
        String tempStr = "00000000" + binaryStr;
        // 返回后面的8位字符串
        return tempStr.substring(tempStr.length() - 8, tempStr.length());
    }

    /**
     * 
     * [简要描述]:validateSubnetMask [详细描述]:校验子网掩码是否正确
     * 
     * @param ipMask
     *            子网掩码
     * @return e 是否是正确的子网掩码
     */
    public static Boolean validateSubnetMask(String subnetmask)
    {
        String[] tempArray = subnetmask.split("[.]");
        // 获取子网掩码32位二进制串
        String toBinaryStr = formatNumStrToBinary(tempArray[0]) + formatNumStrToBinary(tempArray[1])
                + formatNumStrToBinary(tempArray[2]) + formatNumStrToBinary(tempArray[3]);
        if (toBinaryStr.indexOf("01") != -1)
        {
            // 如果二进制串中包含有"01"子串，就不是正确的子网掩码
            return false;
        }
        return true;
    }

    /**
     * 
     * [简要描述]:validateIsSameSubnet [详细描述]:验证两个ip地址是否同属于一个子网：两个ip地址分别与子网掩码进行按位与操作，如果结果相同，则同属于一个子网，否则不是
     * 
     * @param ipstart
     *            开始ip
     * @param ipend
     *            结束ip
     * @param subnetmask
     *            子网掩码
     * @return e 开始ip和结束ip是否属于同一子网
     */
    public static Boolean validateIsSameSubnet(String ipstart, String ipend, String subnetmask)
    {
        // 获取每个ip地址的各个段
        String[] ipstartArray = ipstart.split("[.]");
        String[] ipendArray = ipend.split("[.]");
        String[] subnetmaskArray = subnetmask.split("[.]");

        int i;
        for (i = 0; i < 4; i++)
        {
            // 使两个ip地址的对应段分别与子网掩码的对应进行按位与操作
            if ((Integer.parseInt(ipstartArray[i]) & Integer.parseInt(subnetmaskArray[i])) == (Integer
                    .parseInt(ipendArray[i]) & Integer.parseInt(subnetmaskArray[i])))
            {
                // 如果相与的结果相等，进行下一段与操作
                continue;
            }
            // 如果有某个段相与结果不相同，则不是同一子网
            return false;
        }
        if (i == 4)
        {
            // 如果每段的与结果相同，则同属一个子网
            return true;
        }
        return false;
    }
    
  
    
    public static boolean validateIpRange(String ipstart, String ipend, List<IpRangeInfo> ipRangeInfoList){
        int i = 0;
        boolean flag = true;//ip冲突
        while(i < ipRangeInfoList.size()){
            IpRangeInfo record = ipRangeInfoList.get(i);
            if(checkIpRangeIsConflict(ipstart,ipend, record.getIpstart(),record.getIpend())){
                flag = false;//ip不冲突
            }
            if(!checkIpRangeIsConflict(ipstart,ipend, record.getIpstart(),record.getIpend())){
                flag = true;//ip冲突
                break;
            }
            i++;
            
        }
        return flag;
    }

    public static boolean validateFloatIpRange(String floatipstart, String floatipend, List<IpRangeInfo> ipRangeInfoList){
        int i = 0;
        boolean flag = true;
        while(i < ipRangeInfoList.size()){
            IpRangeInfo record = ipRangeInfoList.get(i);
            if(checkIpRangeIsConflict(floatipstart,floatipend, record.getFloatipstart(),record.getFloatipend())){
                flag = false;
            }
            if(!checkIpRangeIsConflict(floatipstart,floatipend, record.getFloatipstart(),record.getFloatipend())){
                flag = true;//ip冲突
                break;
            }
            i++;
        }
        return flag;
    }
    
   
    public static boolean checkIpRangeIsConflict(String inputipstart,
            String inputipend, String targetipstart, String targetipend) {
        if (ipCompare(inputipstart, targetipstart) > 0 
                && ipCompare(inputipstart, targetipend) < 0) {
            return false;//ip范围冲突
        }
        if (ipCompare(inputipend, targetipstart) > 0
                && ipCompare(inputipend, targetipend) < 0) {
            return false;
        }
        if (ipCompare(targetipstart, inputipstart) > 0
                && ipCompare(targetipstart, inputipend) < 0) {
            return false;
        }
        if (ipCompare(targetipend, inputipstart) > 0
                && ipCompare(targetipend, inputipend) < 0) {
            return false;
        }
        if (ipCompare(inputipstart, targetipstart) == 0
                || ipCompare(inputipstart, targetipend) == 0
                || ipCompare(inputipend, targetipstart) == 0
                || ipCompare(inputipend, targetipend) == 0) {
            return false;
        }
        return true;//ip范围不冲突
    }
    
    
    public static int ipCompare(String ip1, String ip2){
        String[] ip1Array = ip1.split("[.]");
        String[] ip2Array = ip2.split("[.]");
        int i =0;
        while( i< ip1Array.length )
        {
            if(Integer.parseInt(ip1Array[i]) > Integer.parseInt(ip2Array[i]))  return 1;
            if(Integer.parseInt(ip1Array[i]) < Integer.parseInt(ip2Array[i]))  return -1;
            i++;
        }
        return 0;
    }
    
    private static boolean match(String regex, String str) {
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);
        return matcher.matches();
    }
    
    public static boolean IsCIDRAddress(String ip){
        String  regex = "^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])(\\/([0-9]|[1-2][0-9]|3[0-2]))$";
        return match(regex, ip);
    }
    
    public static  boolean isIpAddress(String ip)
    {
        String regex = "^(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|[1-9])\\."  
                + "(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\."  
                + "(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\."  
                + "(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)$";
        
        return match(regex, ip);
    }

    /**
     * 验证邮箱
     *
     * @param 待验证的字符串
     * @return 如果是符合的字符串,返回 <b>true </b>,否则为 <b>false </b>
     */
    public static boolean isEmail(String str) {
        String regex = "^([\\w-\\.]+)@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.)|(([\\w-]+\\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\\]?)$";
        return match(regex, str);
    }

    /**
     * 验证IP地址
     *
     * @param 待验证的字符串
     * @return 如果是符合格式的字符串,返回 <b>true </b>,否则为 <b>false </b>
     */
    public static boolean isIP(String str) {
        String num = "(25[0-5]|2[0-4]\\d|[0-1]\\d{2}|[1-9]?\\d)";
        String regex = "^" + num + "\\." + num + "\\." + num + "\\." + num + "$";
        return match(regex, str);
    }

    /**
     * 验证网址Url
     *
     * @param 待验证的字符串
     * @return 如果是符合格式的字符串,返回 <b>true </b>,否则为 <b>false </b>
     */
    public static boolean IsUrl(String str) {
        String regex = "http(s)?://([\\w-]+\\.)+[\\w-]+(/[\\w- ./?%&=]*)?";
        return match(regex, str);
    }
}