Java IPv6地址验证和规范化

你用了什么样的LIB？它们之间的兼容性如何？或者你写了自己的解析例程

<>我特别感兴趣的是java、C++、python和javascript的相互兼容的实现，它们支持：

• 零压缩（“

  ：

  ”）
• IPv4映射地址（“

  ：：ffff:123.45.67.89

  ”）
• 规范化（包括简写形式，以便于人类阅读）
• CIDR样式的网络掩码（如结尾处的“

  /64

  ”）

---

据我所知，您应该在拥有它的系统上使用

，即Linux和POSIX位置。应该不需要编写自己的低级解析器

---

Windows

getaddrinfo（）

，在XP和更高版本上。

在Java中，您可以使用

InetAddress.getByName(IP)

然后检查由此引发的异常以验证IPv6地址

如果您觉得合适的话，也可以使用Sun专有API。这将不会执行DNS查找。（他们可能会在没有通知的情况下更改/删除它，因为它是他们的专有API。这是使用此API编译代码时会出现的警告）

---

在POSIX系统上，您可以结合使用

inet\u pton

和

inet\u ntop

进行规范化。您仍然需要自己进行CIDR解析。幸运的是，我相信IPv6唯一有效的CIDR语法是/numberofbits表示法，所以这相当简单

您将遇到的另一个问题是缺乏对接口规范的支持。对于链接本地地址，您将在末尾看到类似

%eth0

的内容，以指定它们也是本地的链接

getaddrinfo

将对其进行解析，但

inet\u pton

不会

您可以采用的一种策略是使用

getaddrinfo

进行解析，并使用

inet\u ntop

进行规范化

getaddrinfo

适用于Windows

inet\u pton

和

inet\u ntop

不是。幸运的是，编写代码生成规范形式的IPv6地址并不难。但它需要两次传递，因为0压缩规则是首先出现的最大0字符串。另外，IPv4格式（即

：：127.0.0.1

）仅用于

：：IPv4

或

：：ffff:IPv4

我没有可以测试的Windows机器，但从文档中可以看出，Windows上的Python在其套接字模块中支持

inet\u pton

和

inet\u ntop

编写自己的例程来生成规范形式可能不是一个坏主意，因为即使您的规范形式与其他人的不一样，只要它有效，其他人也可以解析它。但在任何情况下，我都不会编写自己的例程来解析IPv6地址

以上的建议对于Python、C和C++很有帮助。我对如何用Java或Javascript解决这个问题知之甚少或一无所知

---

编辑：我一直在检查getaddrinfo及其对应的getnameinfo。它们几乎在所有方面都优于

inet\u pton

和

inet\u ntop

。它们是线程安全的，您可以向它们传递选项（

getaddrinfo

案例中的

AI_numericost

，以及

getnameinfo

案例中的

NI_NUMERICHOST

），以防止它们执行任何类型的DNS查询。他们的界面有点复杂，在某些方面让我想起了一个丑陋的Windows界面，但要想得到你想要的东西，很容易就知道应该通过哪些选项。我衷心推荐它们。

对于Python，最好的解决方案可能是IPy（）

太糟糕了，Python 3.1丢失了ipaddr库

它仍然作为第三方库提供：在上提供

压缩 IPv4映射 苹果酒

---

getaddrinfo已经返回了最短的文本表单，因此如果您有较长的表单，可以通过再次运行getaddrinfo来规范化。例如Python

import sys, socket;
result = socket.getaddrinfo('0:0::0:1', None);
print "family:%i socktype:%i proto:%i canonname:%s sockaddr:%s"%result[0];

产出如下：

family:10 socktype:1 proto:6 canonname: sockaddr:('::1', 0, 0, 0)

IPv6 CIDR块似乎没有很好的文档记录或定义，所以我写了自己的来处理它（C99）。

我就是为了这个目的而写的。它目前正在运行

下面是API的一个简短示例：

var address = new v6.Address("::ffff:7b2d:4359/64");

if (address.isValid()) {
   // Do something if the address is valid
}

console.log(address.correctForm());         // "::ffff:7b2d:4359"
console.log(address.canonicalForm());       // "0000:0000:0000:0000:0000:ffff:7b2d:4359"
console.log(address.v4Form());              // "::ffff:123.45.67.89"
console.log(address.subnetMask);            // "64"
console.log(address.possibleAddresses(96)); // "4,294,967,296"

---

当操作系统支持可能不可用时，我使用正则表达式—RE在大多数语言中都可用，包括C/C++/Java/Python/Perl/bash/。。。。下面的python代码在启动时构建RE，生成的RE源代码是一个humdinger，但一旦由RE引擎编译，其速度就和本机代码一样快

PAT_IP4 = r'\.'.join([r'(?:\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])']*4)
RE_IP4 = re.compile(PAT_IP4+'$')
RE_IP6 = re.compile(                 '(?:%(hex4)s:){6}%(ls32)s$'
               '|::(?:%(hex4)s:){5}%(ls32)s$'
              '|(?:%(hex4)s)?::(?:%(hex4)s:){4}%(ls32)s$'
'|(?:(?:%(hex4)s:){0,1}%(hex4)s)?::(?:%(hex4)s:){3}%(ls32)s$'
'|(?:(?:%(hex4)s:){0,2}%(hex4)s)?::(?:%(hex4)s:){2}%(ls32)s$'
'|(?:(?:%(hex4)s:){0,3}%(hex4)s)?::%(hex4)s:%(ls32)s$'
'|(?:(?:%(hex4)s:){0,4}%(hex4)s)?::%(ls32)s$'
'|(?:(?:%(hex4)s:){0,5}%(hex4)s)?::%(hex4)s$'
'|(?:(?:%(hex4)s:){0,6}%(hex4)s)?::$'
  % {
'ls32': r'(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|%s)'%PAT_IP4,
'hex4': r'[0-9a-f]{1,4}'
}, re.IGNORECASE)

---

在Java中，Guava库具有用于在com.google.common.net.InetAddresses类中验证IPv6（和IPv4）的实用程序函数

对于C#，我建议使用IPNetwork库。 从版本2开始，它还支持IPv4和IPv6

IPv6

  IPNetwork ipnetwork = IPNetwork.Parse("2001:0db8::/64");

  Console.WriteLine("Network : {0}", ipnetwork.Network);
  Console.WriteLine("Netmask : {0}", ipnetwork.Netmask);
  Console.WriteLine("Broadcast : {0}", ipnetwork.Broadcast);
  Console.WriteLine("FirstUsable : {0}", ipnetwork.FirstUsable);
  Console.WriteLine("LastUsable : {0}", ipnetwork.LastUsable);
  Console.WriteLine("Usable : {0}", ipnetwork.Usable);
  Console.WriteLine("Cidr : {0}", ipnetwork.Cidr);

输出

Network : 2001:db8::
Netmask : ffff:ffff:ffff:ffff::
Broadcast : 
FirstUsable : 2001:db8::
LastUsable : 2001:db8::ffff:ffff:ffff:ffff
Usable : 18446744073709551616
Cidr : 64

---

玩得开心

我只是通过临时方法来检查IPV4和IPV6两种寻址方案的有效性：这是我的代码。。。我的代码中始终欢迎更正。如果我的解决方案错了，请原谅

#include <cstdio>
#include <iostream>
#include <vector>
#include <stack>
#include <algorithm>
#include <sstream>
#include <utility>
#include <cmath>
#include <cstring>
#include <map>
#include <queue>
#include <limits.h>
using namespace std;
bool check6(string s)
{
    for(int i=0;i<s.length();i++)
    {
       if((s[i] < '0' || s[i] > '9') && (s[i] < 'a' || s[i]> 'f') && 
           (s[i] < 'A' || s[i] > 'F'))                       
          return false;
    }
    return true;
}
   bool check4(string s)
   {
      for(int i=0; i< s.length(); i++)
      {
       if(!(s[i]>= '0' && s[i] <= '9'))
          return false;
      }
     stringstream ss(s);
      int e;
      ss >> e;
     if( e < 0 || e > 255 )
      return false;
     else
      return true;
   }

int main()
{
  string s;
  cin>>s;
  vector<string> v;
  int i=0;
  int d=0;
  if((s.find(":")!=std::string::npos || 
         s.find("::")!=std::string::npos)&&  
     s.find(".")==std::string::npos)     
   {
      int x=0;
      while(i< s.length())
      {
          string s1 ="";
          while(i< s.length() && s[i]!= ':')
          {
             s1+= s[i];
             i++;
          }
         if(s1!="")
         v.push_back(s1);
         if((i+1)< s.length() && s[i]==':' && s[i+1]==':')
            x++;
         i++;
         if(i< s.length())
         d++;
     }
      if(x > 1 || d > 7 || v.size() > 8 || (x==1 && d >6))
      {
         cout<<"Not Valid"<<endl;
         return 0;
      }
      else if(d > 2 && v.size() ==0)
      {

         cout<<"Not Valid"<<endl;
         return 0;
      }
      else
      {
         for(int i=0;i< v.size();i++)
         {
             if((v[i]).length() > 4)
             {
                    cout<<"Not Valid"<<endl;
                 return 0;
              }
             else
             {
                if(!check6(v[i]))
                {

                    cout<<"Not Valid"<<endl;
                    return 0;
                }
            }
         }
         cout<<"Valid Ipv6"<<endl;
          return 0;
      }
   }
else if(s.find(":")==std::string::npos && s.find(".")!=std::string::npos)
{
    while(i< s.length())
    {
        string s1="";
        while( i< s.length() && s[i]!='.')
        {
            s1+=s[i];
            i++;
        }
        i++;
        if(i< s.length())
        d++;
        v.push_back(s1);
    }
    if(d > 4 || v.size()> 4)
    {
        cout<<"Not Valid"<<endl;
        return 0;
    }
    else
    {
        for(int i=0;i<v.size();i++)
        {
            if((v[i]).length() > 3)
            {
                cout<<"Not Valid"<<endl;
                return 0;
            }
            if(!check4(v[i]))
            {
                cout<<"Not Valid"<<endl;
                return 0;
            }
        }   
    }
    cout<<"Valid Ipv4"<<endl;
    return 0;
}

        cout<<"Not Valid"<<endl;

return 0;

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
使用名称空间std；
布尔校验6（字符串s）
{
对于（int i=0；i'9'）&&（s[i]<'a'|s[i]>'f'）&&
（s[i]<'A'| | s[i]>'F'））
返回false；
}
返回true；
}
布尔校验4（字符串s）
{
对于（int i=0；i='0'和&s[i]>e；
如果（e<0 | | e>255）
返回false；
其他的
返回true；
}
int main（）
{
字符串s；
cin>>s；
向量v；
int i=0；
int d=0；
如果（（s.find（“：”）=std:：string:：npos |
s、 查找（“：：”）=std:：string:：npos）和
s、 查找（“.”==std:：string:：npos）
{
int x=0；
而（iPAT_IP4 = r'\.'.join([r'(?:\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])']*4)
RE_IP4 = re.compile(PAT_IP4+'$')
RE_IP6 = re.compile(                 '(?:%(hex4)s:){6}%(ls32)s$'
               '|::(?:%(hex4)s:){5}%(ls32)s$'
              '|(?:%(hex4)s)?::(?:%(hex4)s:){4}%(ls32)s$'
'|(?:(?:%(hex4)s:){0,1}%(hex4)s)?::(?:%(hex4)s:){3}%(ls32)s$'
'|(?:(?:%(hex4)s:){0,2}%(hex4)s)?::(?:%(hex4)s:){2}%(ls32)s$'
'|(?:(?:%(hex4)s:){0,3}%(hex4)s)?::%(hex4)s:%(ls32)s$'
'|(?:(?:%(hex4)s:){0,4}%(hex4)s)?::%(ls32)s$'
'|(?:(?:%(hex4)s:){0,5}%(hex4)s)?::%(hex4)s$'
'|(?:(?:%(hex4)s:){0,6}%(hex4)s)?::$'
  % {
'ls32': r'(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|%s)'%PAT_IP4,
'hex4': r'[0-9a-f]{1,4}'
}, re.IGNORECASE)

  IPNetwork ipnetwork = IPNetwork.Parse("2001:0db8::/64");

  Console.WriteLine("Network : {0}", ipnetwork.Network);
  Console.WriteLine("Netmask : {0}", ipnetwork.Netmask);
  Console.WriteLine("Broadcast : {0}", ipnetwork.Broadcast);
  Console.WriteLine("FirstUsable : {0}", ipnetwork.FirstUsable);
  Console.WriteLine("LastUsable : {0}", ipnetwork.LastUsable);
  Console.WriteLine("Usable : {0}", ipnetwork.Usable);
  Console.WriteLine("Cidr : {0}", ipnetwork.Cidr);

Network : 2001:db8::
Netmask : ffff:ffff:ffff:ffff::
Broadcast : 
FirstUsable : 2001:db8::
LastUsable : 2001:db8::ffff:ffff:ffff:ffff
Usable : 18446744073709551616
Cidr : 64

#include <cstdio>
#include <iostream>
#include <vector>
#include <stack>
#include <algorithm>
#include <sstream>
#include <utility>
#include <cmath>
#include <cstring>
#include <map>
#include <queue>
#include <limits.h>
using namespace std;
bool check6(string s)
{
    for(int i=0;i<s.length();i++)
    {
       if((s[i] < '0' || s[i] > '9') && (s[i] < 'a' || s[i]> 'f') && 
           (s[i] < 'A' || s[i] > 'F'))                       
          return false;
    }
    return true;
}
   bool check4(string s)
   {
      for(int i=0; i< s.length(); i++)
      {
       if(!(s[i]>= '0' && s[i] <= '9'))
          return false;
      }
     stringstream ss(s);
      int e;
      ss >> e;
     if( e < 0 || e > 255 )
      return false;
     else
      return true;
   }

int main()
{
  string s;
  cin>>s;
  vector<string> v;
  int i=0;
  int d=0;
  if((s.find(":")!=std::string::npos || 
         s.find("::")!=std::string::npos)&&  
     s.find(".")==std::string::npos)     
   {
      int x=0;
      while(i< s.length())
      {
          string s1 ="";
          while(i< s.length() && s[i]!= ':')
          {
             s1+= s[i];
             i++;
          }
         if(s1!="")
         v.push_back(s1);
         if((i+1)< s.length() && s[i]==':' && s[i+1]==':')
            x++;
         i++;
         if(i< s.length())
         d++;
     }
      if(x > 1 || d > 7 || v.size() > 8 || (x==1 && d >6))
      {
         cout<<"Not Valid"<<endl;
         return 0;
      }
      else if(d > 2 && v.size() ==0)
      {

         cout<<"Not Valid"<<endl;
         return 0;
      }
      else
      {
         for(int i=0;i< v.size();i++)
         {
             if((v[i]).length() > 4)
             {
                    cout<<"Not Valid"<<endl;
                 return 0;
              }
             else
             {
                if(!check6(v[i]))
                {

                    cout<<"Not Valid"<<endl;
                    return 0;
                }
            }
         }
         cout<<"Valid Ipv6"<<endl;
          return 0;
      }
   }
else if(s.find(":")==std::string::npos && s.find(".")!=std::string::npos)
{
    while(i< s.length())
    {
        string s1="";
        while( i< s.length() && s[i]!='.')
        {
            s1+=s[i];
            i++;
        }
        i++;
        if(i< s.length())
        d++;
        v.push_back(s1);
    }
    if(d > 4 || v.size()> 4)
    {
        cout<<"Not Valid"<<endl;
        return 0;
    }
    else
    {
        for(int i=0;i<v.size();i++)
        {
            if((v[i]).length() > 3)
            {
                cout<<"Not Valid"<<endl;
                return 0;
            }
            if(!check4(v[i]))
            {
                cout<<"Not Valid"<<endl;
                return 0;
            }
        }   
    }
    cout<<"Valid Ipv4"<<endl;
    return 0;
}

        cout<<"Not Valid"<<endl;

return 0;