ipv6工具类

最新推荐文章于 2024-09-13 22:49:57 发布
最新推荐文章于 2024-09-13 22:49:57 发布
阅读量1.2k 收藏 2
点赞数 2
文章标签： java 大数据
原文链接：http://www.cnblogs.com/haojb/p/10343025.html
版权 
package mapreduce.nat;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import job.Utilities;

/**
 * 关于ip操作的工具类
 * 
 * @author hjb
 * 
 */
public class IPV6Util {
	

	 public static BigInteger ipv6ToBytesToBigInteger(String ipv6) {
	        byte[] ret = new byte[17];
	        ret[0] = 0;
	        int ib = 16;
	        boolean comFlag = false;// ipv4混合模式标记
	        if (ipv6.startsWith(":"))// 去掉开头的冒号
	            ipv6 = ipv6.substring(1);
	        if (ipv6.endsWith("::")) {
				ipv6 = ipv6+"0";
			}
	        String groups[] = ipv6.split(":");
	        for (int ig = groups.length - 1; ig > -1; ig--) {// 反向扫描
	            if (groups[ig].contains(".")) {
	                // 出现ipv4混合模式
	                byte[] temp = ipv4ToBytes(groups[ig]);
	                ret[ib--] = temp[4];
	                ret[ib--] = temp[3];
	                ret[ib--] = temp[2];
	                ret[ib--] = temp[1];
	                comFlag = true;
	            } else if ("".equals(groups[ig])) {
	                // 出现零长度压缩,计算缺少的组数
	                int zlg = 9 - (groups.length + (comFlag ? 1 : 0));
	                while (zlg-- > 0) {// 将这些组置0
	                    ret[ib--] = 0;
	                    ret[ib--] = 0;
	                }
	            } else {
	                int temp = Integer.parseInt(groups[ig], 16);
	                ret[ib--] = (byte) temp;
	                ret[ib--] = (byte) (temp >> 8);
	            }
	        }
	        return new BigInteger(ret);
	    }
	
	 private static byte[] ipv4ToBytes(String ipv4) {
	        byte[] ret = new byte[5];
	        ret[0] = 0;
	        // 先找到IP地址字符串中.的位置
	        int position1 = ipv4.indexOf(".");
	        int position2 = ipv4.indexOf(".", position1 + 1);
	        int position3 = ipv4.indexOf(".", position2 + 1);
	        // 将每个.之间的字符串转换成整型
	        ret[1] = (byte) Integer.parseInt(ipv4.substring(0, position1));
	        ret[2] = (byte) Integer.parseInt(ipv4.substring(position1 + 1,
	                position2));
	        ret[3] = (byte) Integer.parseInt(ipv4.substring(position2 + 1,
	                position3));
	        ret[4] = (byte) Integer.parseInt(ipv4.substring(position3 + 1));
	        return ret;
	    }
	
	public static BigInteger[] convertList(String ip) {
		BigInteger[] arr = new BigInteger[2];
		String tmpIp = ip.substring(0, ip.indexOf("/"));
		if (Utilities.isValidIP(tmpIp)) {
			Long[] ipToLong = Utilities.getIpLong(ip);
			arr[0] = BigInteger.valueOf(ipToLong[0]);
			arr[1] = BigInteger.valueOf(ipToLong[1]);
		} else if (Utilities.isValidIPv6(tmpIp)) {
			arr = IPV6Util.getIpv6Long(ip);
		}
		return arr;
	}

	public static BigInteger convertToBigInteger(String ip) throws Exception {
		BigInteger tmpBig = null;
		if (Utilities.isValidIP(ip)) {
			Long ipToLong1 = Utilities.ipToLong(ip);
			tmpBig = BigInteger.valueOf(ipToLong1);
		} else if (Utilities.isValidIPv6(ip)) {
			tmpBig = ipv6ToBytesToBigInteger(ip);
		}
		return tmpBig;
	}

	// 将ipv6地址转换为二进制分段（为了创造ip段写的）
	public static String fenduan(String ipv6) throws UnknownHostException {
		ipv6 = completIpv6(ipv6);
		String[] split = ipv6.split(":");
		String tmpString = "";
		if (split.length == 8) {
			for (int i = 0; i < split.length; i++) {
				String str = Long.toBinaryString(Long.valueOf(split[i], 16));
				tmpString += str + "    ";
			}
		}
		return tmpString;
	}

	public static String fenduan4(String ipv6) throws UnknownHostException {
		String[] split = ipv6.split("\\.");
		String tmpString = "";
		if (split.length == 4) {
			for (int i = 0; i < split.length; i++) {
				String str = Long.toBinaryString(Long.valueOf(split[i]));
				tmpString += str + "    ";
			}
		}
		return tmpString;
	}

	public static boolean isInRange(String ip, String cidr) {
		String[] ips = ip.split("\\.");
		int ipAddr = (Integer.parseInt(ips[0]) << 24) | (Integer.parseInt(ips[1]) << 16)
				| (Integer.parseInt(ips[2]) << 8) | Integer.parseInt(ips[3]);
		int type = Integer.parseInt(cidr.replaceAll(".*/", ""));
		int mask = 0xFFFFFFFF << (32 - type);
		String cidrIp = cidr.replaceAll("/.*", "");
		String[] cidrIps = cidrIp.split("\\.");
		int cidrIpAddr = (Integer.parseInt(cidrIps[0]) << 24) | (Integer.parseInt(cidrIps[1]) << 16)
				| (Integer.parseInt(cidrIps[2]) << 8) | Integer.parseInt(cidrIps[3]);

		return (ipAddr & mask) == (cidrIpAddr & mask);
	}

	public static boolean isBelongIpv6(String ipv6, String ipv6area) throws Exception {

//		ipv6 = completIpv6(ipv6);
		int suffix = 0;
		if (ipv6area.contains("/")) {
			suffix = Integer.parseInt(ipv6area.substring(ipv6area.indexOf("/") + 1));
			ipv6area = ipv6area.substring(0, ipv6area.indexOf("/"));
		}
		BigInteger ipv6Big = ipv6ToBytesToBigInteger(ipv6);
		BigInteger ipv6areaBig = ipv6ToBytesToBigInteger(ipv6area);

		BigDecimal ss = new BigDecimal(2);
		BigDecimal pow = ss.pow(128);
		BigInteger aa = new BigInteger(pow.toString());
		
		String str = aa.toString(2).replaceAll("0", "1").substring(1);
		BigInteger bb = new BigInteger(str, 2);
		String str1 = bb.shiftLeft(128 - suffix).toString(2);
		String str2 = str1.substring(128 - suffix, str1.length());

		BigInteger mask = new BigInteger(str2, 2);

		return ipv6Big.and(mask).compareTo(ipv6areaBig.and(mask)) == 0 ? true : false;
	}

	/**
	 * 将ipv6每段补齐4位
	 * 
	 * @return
	 * @throws UnknownHostException
	 */
	public static String completIpv6(String ipv6) throws UnknownHostException {
		StringBuffer str = new StringBuffer();
		if (isValidIPv6(ipv6)) {
			String ip = InetAddress.getByName(ipv6).toString().replace("/", "");
			String[] info = ip.split(":");
			for (int i = 0; i < info.length; i++) {
				switch (info[i].length()) {
				case 1:
					info[i] = "000" + info[i];
					break;
				case 2:
					info[i] = "00" + info[i];
					break;
				case 3:
					info[i] = "0" + info[i];
					break;
				default:
					break;
				}
				if (i < 7) {
					str.append(info[i] + ":");
				} else {
					str.append(info[i]);
				}
			}
		}
		return str.toString();
	}

	/**
	 * 将ipv6地址转换为10进制
	 * 
	 * @throws Exception
	 */

	public static BigInteger ipv6ToBigInt(String ipv6) throws Exception {
		BigInteger numip = BigInteger.ZERO;
		String completIpv6 = completIpv6(ipv6);
//		String completIpv6 = ipv6;
		if (completIpv6.endsWith(":") && completIpv6.contains(".")) {
			completIpv6 = completIpv6.replace(":", "");
		}
		if (isIpV4OrV6(completIpv6) == 4) {
			numip = BigInteger.valueOf(Utilities.ipToLong(completIpv6));
		} else if (isIpV4OrV6(completIpv6) == 6) {
			String[] split = completIpv6.split(":");
			for (int i = 0; i < split.length; i++) {
				numip = numip
						.add(BigInteger.valueOf(Long.parseLong(split[i], 16)).shiftLeft(16 * (split.length - i - 1)));
			}
		}
		return numip;
	}

	/**
	 * 将整数形式的ipv6地址转换为字符串形式
	 * 
	 */
	public static String int2ipv6(BigInteger big) {

		String str = "";
		BigInteger ff = BigInteger.valueOf(0xffff);
		for (int i = 0; i < 8; i++) {
			str = big.and(ff).toString(16) + ":" + str;

			big = big.shiftRight(16);
		}
		str = str.substring(0, str.length() - 1);

		return str.replaceFirst("(^|:)(0+(:|$)){2,8}", "::");
	}

	/**
	 * 将ipv6地址压缩为最简模式 IPv6简写规范： 1） 每个IPv6地址段起始的0可以被省略； 2） 如果一段为4个零，可以简写为一个0 3）
	 * 如果有连续的多个段全为0，则可以使用::表示 注：一个地址段中只能有一个::出现，不可以出现两个及以上
	 */

	public static String ipv6Shorted(String ipv6) {
		if (isValidIPv6(ipv6)) {
			ipv6 = ipv6.substring(0, ipv6.length() - 1);
		}
		return ipv6.replaceFirst("(^|:)(0+(:|$)){2,8}", "::");

	}

	/**
	 * ipv4或ipv6字符串
	 * 
	 * @return 4 ：ipv4, 6:ipv6, 0:地址不对
	 * @throws Exception
	 */

	public static int isIpV4OrV6(String ipAdress) throws Exception {
		InetAddress address = InetAddress.getByName(ipAdress);
		if (address instanceof Inet4Address)
			return 4;
		else if (address instanceof Inet6Address)
			return 6;
		return 0;
	}

	/**
	 * IPv4转换为IPv6
	 */

	public static String ipv4ToIpv6(String ipv6) {
		String[] octets = ipv6.split("\\.");
		byte[] octetBytes = new byte[4];
		for (int i = 0; i < 4; ++i) {
			octetBytes[i] = (byte) Integer.parseInt(octets[i]);
		}

		byte ipv4asIpV6addr[] = new byte[16];
		ipv4asIpV6addr[10] = (byte) 0xff;
		ipv4asIpV6addr[11] = (byte) 0xff;
		ipv4asIpV6addr[12] = octetBytes[0];
		ipv4asIpV6addr[13] = octetBytes[1];
		ipv4asIpV6addr[14] = octetBytes[2];
		ipv4asIpV6addr[15] = octetBytes[3];

		return "::" + (ipv4asIpV6addr[12] & 0xff) + "." + (ipv4asIpV6addr[13] & 0xff) + "."
				+ (ipv4asIpV6addr[14] & 0xff) + "." + (ipv4asIpV6addr[15] & 0xff);

	}

	/**
	 * 判断ipv6是否合法
	 *
	 * @param ip
	 * @return
	 */
	public static boolean isValidIPv6(String ip) {
		if (ip == null || ip.trim().length() == 0) {
			return false;
		}
		String t = "^\\s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:)))(%.+)?\\s*$";
		Pattern p = Pattern.compile(t);
		Matcher macher = p.matcher(ip);
		return macher.matches();
	}


	/**
	 * 判断IPv6是否属于某个IPv6段
	 * 
	 * @throws Exception
	 */

	public static boolean isBelongIpv6List(String ipv6, List<String> ipv6area) throws Exception {
		for (String iparea : ipv6area) {
			if (isBelongIpv6(ipv6, iparea)) {
				return true;
			}
		}
		return false;
	}

	/**
	 * 判断ip是否属于某个网段
	 *
	 * @param ip
	 * @return
	 */

	public static boolean isBelongIpareaData(BigInteger ipv6, List<BigInteger[]> data) {
		for (BigInteger[] tmp : data) {
			if ((ipv6.compareTo(tmp[0]) == 1 || ipv6.compareTo(tmp[0]) == 0)
					&& (ipv6.compareTo(tmp[1]) == -1 || ipv6.compareTo(tmp[1]) == 0)) {
				return true;
			}
		}
		return false;
	}

	public static BigInteger[] getIpv6Long(String iparea) {
		try {
			iparea = iparea.trim();
			BigInteger[] info = new BigInteger[2];
			// 判断是否是具体IP
			int index = iparea.indexOf("/");
			if (index < 0) {
				info[0] = ipv6ToBytesToBigInteger(iparea);
				info[1] = ipv6ToBytesToBigInteger(iparea);
				if (info[0] == null || info[1] == null) {
					return null;
				}
				return info;
			}
			String ipinfo = iparea.substring(0, index);
			Integer count = Integer.valueOf(iparea.substring(index + 1));
			BigInteger small = BigInteger.ZERO;
			BigInteger big = BigInteger.ZERO;
			StringBuffer mask = new StringBuffer();
			for (int i = 0; i < 128; i++) {
				if (i<count) {
					mask.append("1");
				}else {
					mask.append("0");
				}
			}
			String string = new BigInteger(mask.toString(),2).toString(10);
//			for (int i = 0; i < 128 - count; i++) {
//				double pow = Math.pow(2d, Double.valueOf(Integer.valueOf(i).toString()));
//				BigInteger tmp = BigDecimal.valueOf(pow).toBigInteger();
//				small = small.add(tmp);
//			}
//			big = BigDecimal.valueOf(Math.pow(2d, Double.valueOf("128"))).toBigInteger().subtract(small)
//					.subtract(BigInteger.valueOf(1));
			
			info[0] = areaIp.and(big);
			info[1] = areaIp.or(small);
			BigInteger areaIp = ipv6ToBytesToBigInteger(ipinfo);
			info[0] = areaIp.and(new BigInteger(string));
			String re = mask.substring(mask.lastIndexOf("1")+1).replace("0", "1");
			info[1] = areaIp.or(new BigInteger(new BigInteger(re.toString(),2).toString(10)).subtract(BigInteger.valueOf(1)));
			if (info[0] == null || info[1] == null) {
				return null;
			}
			return info;
		} catch (Exception e) {
			return null;
		}
	}

	/**
	 * 给定两个初始ip和结束ip，，计算求得CIDR IP段
	 * 
	 * @param startIp
	 * @param endIp
	 * @return
	 */
	public static List<String> range2cidrlist(String startIp, String endIp) {
		long start = ipToLong(startIp);
		long end = ipToLong(endIp);

		ArrayList<String> pairs = new ArrayList<String>();
		while (end >= start) {
			byte maxsize = 32;
			while (maxsize > 0) {
				long mask = CIDR2MASK[maxsize - 1];
				long maskedBase = start & mask;

				if (maskedBase != start) {
					break;
				}

				maxsize--;
			}
			double x = Math.log(end - start + 1) / Math.log(2);
			byte maxdiff = (byte) (32 - Math.floor(x));
			if (maxsize < maxdiff) {
				maxsize = maxdiff;
			}
			String ip = Utilities.longToIP(start);
			pairs.add(ip + "/" + maxsize);
			start += Math.pow(2, (32 - maxsize));
		}
		return pairs;
	}

	public static final int[] CIDR2MASK = new int[] { 0x00000000, 0x80000000, 0xC0000000, 0xE0000000, 0xF0000000,
			0xF8000000, 0xFC000000, 0xFE000000, 0xFF000000, 0xFF800000, 0xFFC00000, 0xFFE00000, 0xFFF00000, 0xFFF80000,
			0xFFFC0000, 0xFFFE0000, 0xFFFF0000, 0xFFFF8000, 0xFFFFC000, 0xFFFFE000, 0xFFFFF000, 0xFFFFF800, 0xFFFFFC00,
			0xFFFFFE00, 0xFFFFFF00, 0xFFFFFF80, 0xFFFFFFC0, 0xFFFFFFE0, 0xFFFFFFF0, 0xFFFFFFF8, 0xFFFFFFFC, 0xFFFFFFFE,
			0xFFFFFFFF };

	private static long ipToLong(String strIP) {
		long[] ip = new long[4];
		String[] ipSec = strIP.split("\\.");
		for (int k = 0; k < 4; k++) {
			ip[k] = Long.valueOf(ipSec[k]);
		}

		return (ip[0] << 24) + (ip[1] << 16) + (ip[2] << 8) + ip[3];
	}
}

　　

转载于:https://www.cnblogs.com/haojb/p/10343025.html

weixin_30399155
关注
IPv6实用工具
10-16
IPv6实用工具IPv6实用工具IPv6实用工具IPv6实用工具IPv6实用工具
IPv6地址工具
03-05
IPv6地址工具 ipv4即将退出，这个IPv6工具可有一定作为 网络工具，一般人用不到
IPv6 Toolkit 安装和配置指南
最新发布
gitblog_07216的博客
09-13 387
IPv6 Toolkit 安装和配置指南 ipv6toolkit SI6 Networks' IPv6 Toolkit 项目地址: https://gitcode.com/gh_mirrors/ip/ipv6toolkit ...
IPV6工具类 java
wdd668的专栏
08-19 1500
import com.hdlh.network.common.Constatnts; import org.apache.commons.lang.StringUtils; import java.math.BigInteger; import java.net.InetAddress; import java.net.UnknownHostException; import java.util.*; import java.util.regex.Pattern; /** * * ipv6工具.
Java实现IPV6地址查询
11-30
Java实现IPV6地址查询 Java IP V6 ipv6 地域 地址 查询 地址查询 使用ZX公网IPv6库 20120916版
马上6ipv6上网工具
06-06
对于使用ipv6上网的同学可以选择用马上6这个软件，网速正常。
IPV6Util.rar
08-07
ipv6段或范围拆分和补全，支持xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx/123 格式ipv6段或范围拆分和补全，ipv6段或范围拆分和补全
java IPv6缩写和非缩写转化方法类
06-01
类中completionIpV6（）为补全缩写ipv6，simplifyIpV6（）为将全ipv6转化为缩写
微软官网修复IPv6的工具包合集
08-21
修复ipv6的工具类，资源下载自https://support.microsoft.com/en-us/help/929852/guidance-for-configuring-ipv6-in-windows-for-advanced-users，如有侵权，请告知。会立即删除，鉴于一些人打不开，所以就把这些...
java对ipv6格式的压缩简化以及解析
09-30
这是本人参照如下http://www.gestioip.net/cgi-bin/subnet_calculator.cgi的IPV6解析网站，自己做java的工具类。可以对各种IPV6的格式进行解析。校验。以及对IPV6格式的压缩、以及补全。总之是全网最好用的工具类
Java实现IPv6格式压缩与解析：最强工具类
Java工具类"IPV6Util"专注于IPv6地址的处理，它是在参考了"http://www.gestioip.net/cgi-bin/subnet_calculator.cgi"这个IPv6解析网站的基础上开发的。该类提供了对IPv6地址的多种功能操作，包括格式校验、格式压缩...
飞六软件分配ipv6地址
02-03
安装软件后能给电脑分配一个ipv6地址。
IPV6子网划分工具
05-30
子网掩码计算器：保证是你见过的最好的支持IPV6，功能最强大.网络上几乎找不到，最新版的支持IPV6，子网划分最好的工具
ipv6地址计算器202010
10-14
ipv6地址计算器 版本202010 无需安装，支持win7,win10系统； 界面简单直观，支持单个地址计算、批量计算和EUI-64地址转换； 单个地址计算结果显示为地址范围及地址总数，支持子网计算并给出起始和结束子网地址和子网地址总数； 批量计算结果可保存为TXT文件； EUI-64转换支持将MAC和64位缀转换为EUI-64地址，也支持将EUI-64地址转换为MAC和64位前缀； 输入栏支持复制粘贴操作，计算结果可一键复制到粘贴板。
一款IPv4下访问IPv6软件
04-21
一款IPv4下访问IPv6软件
IPAddress：Java库，用于处理IPv4和IPv6的IP地址和子网
02-04
IP地址 用于处理IPv4和IPv6的IP地址和子网的库 ，打包为OSGI软件包，打包为和 Maven组ID：com.github.seancfoley Maven工件ID： Maven的版本： ， ， ， 自5.3.1版起的OSGI捆绑包：com.github.seancfoley.ipaddress 作为库，它还可以与 ， ， 和互操作。 版 笔记 需要Java 6或更高版本 需要Java 8或更高版本 需要Java 8或更高版本，具有MAC地址支持，与IPv6的EUI-48和EUI-64 MAC集成，新地址框架，新的IP字符串格式已解析和生成以及其他附加功能 需要
ipv6地址计算工具_超实用的IP地址计算工具
热门推荐
weixin_36207483的博客
12-02 1万+
本文首发于微信公众号“电脑网络一点通”(dnwlydt)喜欢我就请多多关注大家在平时的使用中，在输入IP地址时，是不是发现有很多要填的，比如IP地址、子网掩码、网关、DNS，一大串的数字，还不容易记。今天我给大家介绍个实用的网络工具-IP地址计算工具。首先用浏览器打开百度，搜索“IP地址计算”，有很多类似的小工具，选择其中一个，如下图所示：1. 如：192.168.101.2/22的子网地址、广播...
ipv6地址分配工具_家庭路由器设备IPv6支持度如何？测评报告来了
weixin_32074113的博客
12-31 409
随着我国推进IPv6规模部署工作的不断深入，IPv6接入的“最后一公里”已经成为决定IPv6用户和流量规模的重要环节，为此，中国信息通信研究院技术与标准研究所于2019年4月份开展了对市面主流家庭路由器设备的测试验证工作，旨在全面客观地反映和评价当前市场上主流家庭路由器设备对IPv6协议栈的支持情况，并引导家庭用户选择合适的家庭路由器设备以获得IPv6网络接入能力，加快推进“最后一公里”...
IPv6 Toolkit: 一款强大的IPv6工具包
gitblog_00044的博客
03-16 1153
IPv6 Toolkit: 一款强大的IPv6工具包 项目地址:https://gitcode.com/gh_mirrors/ip/ipv6toolkit IPv6 Toolkit是一款用于处理IPv6地址的开源Python库，可以帮助开发者进行IP地址的生成、解析、校验等操作。 项目简介 IPv6 Toolkit是一个功能丰富的库，可以帮助开发人员执行IPv6地址的相关操作。该项目由创建并维护，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值