आईपीवी 6

Question

के लिए सभी पतेों की गणना ... मैंने बहुत अच्छे C# examples को देखा है जो दर्शाता है कि सीआईडीआर नोटेशन (उदाहरण के लिए 1 9 2.168.0.1/25) में आईपीवी 4 पते को उनके प्रासंगिक श्रेणियों में कैसे परिवर्तित किया जाए (1 9 2.168.0.1 - 1 9 2.168 .0.126)। मेरे कार्यक्रम को ऐसा करने में सक्षम होना चाहिए (मेरे स्थानीय सबनेट के भीतर सभी पतों की गणना करने के लिए) लेकिन मैं आईपीवी 6 का भी समर्थन करना चाहता हूं।

यदि मेरे सी # प्रोग्राम में मेरी सभी सामान्य ipconfig जानकारी (आईपीवी 4 पता, सबनेट मास्क, आईपीवी 6 पता, लिंक-स्थानीय वी 6 पता, डिफ़ॉल्ट गेटवे) है - मैं सभी आईपीवी 6 पते की सूची कैसे उत्पन्न करूं मेरा स्थानीय सबनेट और उन्हें कंसोल में आउटपुट कर रहा है?

Answer 1

आप eExNetworkLibrary से eExNetworkLibrary.IP.IPAddressAnalysis क्लास का उपयोग कर सकते हैं।

निम्न कोड आईपीवी 4 और आईपीवी 6 (बस परीक्षण) के साथ काम करता है।

 string strIn = "2001:DB8::/120"; 

     //Split the string in parts for address and prefix 
     string strAddress = strIn.Substring(0, strIn.IndexOf('/')); 
     string strPrefix = strIn.Substring(strIn.IndexOf('/') + 1); 

     int iPrefix = Int32.Parse(strPrefix); 
     IPAddress ipAddress = IPAddress.Parse(strAddress); 

     //Convert the prefix length to a valid SubnetMask 

     int iMaskLength = 32; 

     if(ipAddress.AddressFamily == System.Net.Sockets.AddressFamily.InterNetworkV6) 
     { 
      iMaskLength = 128; 
     } 

     BitArray btArray = new BitArray(iMaskLength); 
     for (int iC1 = 0; iC1 < iMaskLength; iC1++) 
     { 
      //Index calculation is a bit strange, since you have to make your mind about byte order. 
      int iIndex = (int)((iMaskLength - iC1 - 1)/8) * 8 + (iC1 % 8); 

      if (iC1 < (iMaskLength - iPrefix)) 
      { 
       btArray.Set(iIndex, false); 
      } 
      else 
      { 
       btArray.Set(iIndex, true); 
      } 
     } 

     byte[] bMaskData = new byte[iMaskLength/8]; 

     btArray.CopyTo(bMaskData, 0); 

     //Create subnetmask 
     Subnetmask smMask = new Subnetmask(bMaskData); 

     //Get the IP range 
     IPAddress ipaStart = IPAddressAnalysis.GetClasslessNetworkAddress(ipAddress, smMask); 
     IPAddress ipaEnd = IPAddressAnalysis.GetClasslessBroadcastAddress(ipAddress, smMask); 

     //Omit the following lines if your network range is large 
     IPAddress[] ipaRange = IPAddressAnalysis.GetIPRange(ipaStart, ipaEnd); 

     //Debug output 
     foreach (IPAddress ipa in ipaRange) 
     { 
      Console.WriteLine(ipa.ToString()); 
     } 

     Console.ReadLine(); 

मैं पूरी तरह से यकीन है कि अगर मैं सबनेट मास्क सही युक्त एक बाइट सरणी के लिए उपसर्ग लंबाई से रूपांतरण किया है, लेकिन इस कोड को आप एक अच्छा प्रारंभिक बिंदु देना चाहिए नहीं कर रहा हूँ।

संपादित करें: कोड के बिट-झुकाव भाग को अपडेट किया गया। बदसूरत हो सकता है, लेकिन इस उदाहरण के लिए काम करता है। मुझे लगता है कि यदि आपको आवश्यकता हो तो बेहतर समाधान खोजने में सक्षम होंगे। उन बिट्स गर्दन में दर्द होता है।

ध्यान रखें कि आईपीवी 6 नेटवर्क रेंज उत्पन्न करना नेटवर्क बहुत बड़ा होने पर बहुत मेमोरी/सीपीयू थकाऊ कार्य हो सकता है।

Answer 2

exNetworkLibrary एक महान उपकरण है, लेकिन अगर आप अपनी परियोजना में उपयोग नहीं कर सकते तो आप इस लेख को देखने के लिए चाहते हो सकता है:

http://www.codeproject.com/Articles/112020/IP-Address-Extension

यह रूपरेखा का पता मास्क आईपीवी 4 में उपयोग के लिए गणना कैसे की जाती ।

आपका प्रश्न आईपीवी 6 से संबंधित है और मैं .NET 4.5 से संबंधित हूं IPAddress.MapToIPv6 विधि है।

https://msdn.microsoft.com/en-us/library/system.net.ipaddress.maptoipv6(v=vs.110).aspx

आप लेख में चेकों के साथ कि उपयोग के लिए इस कोड का उत्पादन करने के कर सकते हैं:

private static IPAddress empty = IPAddress.Parse("0.0.0.0"); 
    private static IPAddress intranetMask1 = IPAddress.Parse("10.255.255.255"); 
    private static IPAddress intranetMask2 = IPAddress.Parse("172.16.0.0"); 
    private static IPAddress intranetMask3 = IPAddress.Parse("172.31.255.255"); 
    private static IPAddress intranetMask4 = IPAddress.Parse("192.168.255.255"); 

    /// <summary> 
    /// Retuns true if the ip address is one of the following 
    /// IANA-reserved private IPv4 network ranges (from http://en.wikipedia.org/wiki/IP_address) 
    /// Start  End 
    /// 10.0.0.0  10.255.255.255 
    /// 172.16.0.0  172.31.255.255  
    /// 192.168.0.0 192.168.255.255 
    /// </summary> 
    /// <returns></returns> 
    public static bool IsOnIntranet(this IPAddress ipAddress) 
    { 
     if (empty.Equals(ipAddress)) 
     { 
      return false; 
     } 

     bool onIntranet = IPAddress.IsLoopback(ipAddress); 

     if (false == onIntranet) 
     { 
      //Handle IPv6 by getting the IPv4 Mapped Address. 
      if (ipAddress.AddressFamily == AddressFamily.InterNetworkV6) 
      { 
       onIntranet = ipAddress.Equals(ipAddress.And(intranetMask1.MapToIPv6())); //10.255.255.255 
       onIntranet = onIntranet || ipAddress.Equals(ipAddress.And(intranetMask4.MapToIPv6())); ////192.168.255.255 

       onIntranet = onIntranet || (intranetMask2.Equals(ipAddress.And(intranetMask2.MapToIPv6())) 
        && ipAddress.Equals(ipAddress.And(intranetMask3.MapToIPv6()))); 
      } 
      else 
      { 
       onIntranet = ipAddress.Equals(ipAddress.And(intranetMask1)); //10.255.255.255 
       onIntranet = onIntranet || ipAddress.Equals(ipAddress.And(intranetMask4)); ////192.168.255.255 

       onIntranet = onIntranet || (intranetMask2.Equals(ipAddress.And(intranetMask2)) 
        && ipAddress.Equals(ipAddress.And(intranetMask3))); 
      } 


     } 

     return onIntranet; 
    } 

private static void CheckIPVersion(IPAddress ipAddress, IPAddress mask, out byte[] addressBytes, out byte[] maskBytes) 
    { 
     if (mask == null) 
     { 
      throw new ArgumentException(); 
     } 

     addressBytes = ipAddress.GetAddressBytes(); 
     maskBytes = mask.GetAddressBytes(); 

     if (addressBytes.Length != maskBytes.Length) 
     { 
      throw new ArgumentException("The address and mask don't use the same IP standard"); 
     } 
    } 

    public static IPAddress And(this IPAddress ipAddress, IPAddress mask) 
    { 
     byte[] addressBytes; 
     byte[] maskBytes; 
     CheckIPVersion(ipAddress, mask, out addressBytes, out maskBytes); 

     byte[] resultBytes = new byte[addressBytes.Length]; 
     for (int i = 0, e = addressBytes.Length; i < e; ++i) 
     { 
      resultBytes[i] = (byte)(addressBytes[i] & maskBytes[i]); 
     } 

     return new IPAddress(resultBytes); 
    } 

Answer 3

मैं IPNetwork लाइब्रेरी https://github.com/lduchosal/ipnetwork के उपयोग की सिफारिश करेंगे। संस्करण 2 के रूप में, यह आईपीवी 4 और आईपीवी 6 का भी समर्थन करता है।

आईपीवी 6

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 

गणन

IPNetwork network = IPNetwork.Parse("::/124"); 
    IPNetworkCollection ips = IPNetwork.Subnet(network, 128); 

    foreach (IPNetwork ip in ips) { 
     Console.WriteLine("{0}", ip); 
    } 

आउटपुट

::/128 
::1/128 
::2/128 
::3/128 
::4/128 
::5/128 
::6/128 
::7/128 
::8/128 
::9/128 
::a/128 
::b/128 
::c/128 
::d/128 
::e/128 
::f/128 

मज़े करो!

Answer 4

मुझे पता है कि यह पोस्ट 5 वर्ष पुराना है, लेकिन Google क्षमताओं को देखते हुए इसे आज भी अपडेट किया जा सकता है। इसलिए, मैं नेटवर्क इंजीनियरिंग परिप्रेक्ष्य से थोड़ा सा स्पष्टीकरण जोड़ूंगा।

यह किस तरह के पते पर निर्भर करता है। यदि आप सीमा में हर पते का मतलब है, तो उपर्युक्त चर्चा सही है। यदि आपका मतलब है कि पते को सबनेट ("यूनिकास्ट" पते) में नोड को असाइन किया जा सकता है, तो ध्यान रखें कि आईपीवी 6 (ए) में कोई प्रसारण नहीं होता है, और (बी) एक पर्याप्त मल्टीकास्ट रेंज है।

मूल रूप से: [सबनेट]: एफएफ :: मल्टीकास्ट के लिए आरक्षित है। यदि आप एक सबनेट मास्क के लिए/64 का उपयोग नहीं कर रहे हैं, तो आप वास्तव में सावधान रहना चाहते हैं क्योंकि यह मौलिक धारणा के खिलाफ जाता है कई आईपीवी 6 से संबंधित आरएफसी है। अन्य आरएफसी सभी ऑल-शून्य होस्ट पते का उपयोग करने के खिलाफ सावधानी बरतते हैं (लेकिन मुझे उस प्रभाव के लिए विशिष्ट आवश्यकता की जानकारी नहीं है)।

तो, एक/64 सबनेट के लिए, इसका मतलब है कि यूनिकास्ट पते की सीमा :: 0: 0: 0: 1 के माध्यम से :: feff: ffff: ffff: ffff।

चर्चा के लिए यहाँ देखें: http://www.tcpipguide.com/free/t_IPv6MulticastandAnycastAddressing.htm

weylin