← Back to branch summary

~ubuntu-branches/ubuntu/trusty/smuxi/trusty-proposed

« back to all changes in this revision

Viewing changes to lib/ServiceStack/src/ServiceStack.Common/IPAddressExtensions.cs

  • Committer: Package Import Robot
  • Author(s): Mirco Bauer
  • Date: 2013-05-25 22:11:31 UTC
  • mfrom: (1.2.12)
  • Revision ID: package-import@ubuntu.com-20130525221131-nd2mc0kzubuwyx20
Tags: 0.8.11-1
* [22d13d5] Imported Upstream version 0.8.11
* [6d2b95a] Refreshed patches
* [89eb66e] Added ServiceStack libraries to smuxi-engine package
* [848ab10] Enable Campfire engine
* [c6dbdc7] Always build db4o for predictable build result
* [13ec489] Exclude OS X specific libraries from dh_clideps

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/ServiceStack/src/ServiceStack.Common/IPAddressExtensions.cs
 
1
using System;
 
2
using System.Collections.Generic;
 
3
using System.Net;
 
4
using System.Net.NetworkInformation;
 
5
using System.Net.Sockets;
 
6
using ServiceStack.Logging;
 
7
 
 
8
namespace ServiceStack.Common.Extensions
 
9
{
 
10
    /// <summary>
 
11
    /// Useful IPAddressExtensions from: 
 
12
    /// http://blogs.msdn.com/knom/archive/2008/12/31/ip-address-calculations-with-c-subnetmasks-networks.aspx
 
13
    /// 
 
14
    /// </summary>
 
15
    public static class IPAddressExtensions
 
16
    {
 
17
        public static IPAddress GetBroadcastAddress(this IPAddress address, IPAddress subnetMask)
 
18
        {
 
19
            var ipAdressBytes = address.GetAddressBytes();
 
20
            var subnetMaskBytes = subnetMask.GetAddressBytes();
 
21
 
 
22
            if (ipAdressBytes.Length != subnetMaskBytes.Length)
 
23
                throw new ArgumentException("Lengths of IP address and subnet mask do not match.");
 
24
 
 
25
            var broadcastAddress = new byte[ipAdressBytes.Length];
 
26
            for (var i = 0; i < broadcastAddress.Length; i++)
 
27
            {
 
28
                broadcastAddress[i] = (byte)(ipAdressBytes[i] | (subnetMaskBytes[i] ^ 255));
 
29
            }
 
30
            return new IPAddress(broadcastAddress);
 
31
        }
 
32
        
 
33
        public static IPAddress GetNetworkAddress(this IPAddress address, IPAddress subnetMask)
 
34
        {
 
35
            var ipAdressBytes = address.GetAddressBytes();
 
36
            var subnetMaskBytes = subnetMask.GetAddressBytes();
 
37
 
 
38
            return new IPAddress(GetNetworkAddressBytes(ipAdressBytes, subnetMaskBytes));
 
39
        }
 
40
 
 
41
        public static byte[] GetNetworkAddressBytes(byte[] ipAdressBytes, byte[] subnetMaskBytes) 
 
42
        {
 
43
            if (ipAdressBytes.Length != subnetMaskBytes.Length)
 
44
                throw new ArgumentException("Lengths of IP address and subnet mask do not match.");
 
45
 
 
46
            var broadcastAddress = new byte[ipAdressBytes.Length];
 
47
            for (var i = 0; i < broadcastAddress.Length; i++)
 
48
            {
 
49
                broadcastAddress[i] = (byte)(ipAdressBytes[i] & (subnetMaskBytes[i]));
 
50
            }
 
51
            return broadcastAddress;
 
52
        }
 
53
 
 
54
        public static bool IsInSameIpv6Subnet(this IPAddress address2, IPAddress address)
 
55
        {
 
56
            if (address2.AddressFamily != AddressFamily.InterNetworkV6 || address.AddressFamily != AddressFamily.InterNetworkV6)
 
57
            {
 
58
                throw new ArgumentException("Both IPAddress must be IPV6 addresses");
 
59
            }
 
60
            var address1Bytes = address.GetAddressBytes();
 
61
            var address2Bytes = address2.GetAddressBytes();
 
62
 
 
63
            return IsInSameIpv6Subnet(address1Bytes, address2Bytes);
 
64
        }
 
65
 
 
66
        public static bool IsInSameIpv6Subnet(this byte[] address1Bytes, byte[] address2Bytes) 
 
67
        {
 
68
            if (address1Bytes.Length != address2Bytes.Length)
 
69
                throw new ArgumentException("Lengths of IP addresses do not match.");
 
70
 
 
71
            for (var i = 0; i < 8; i++)
 
72
            {
 
73
                if (address1Bytes[i] != address2Bytes[i])
 
74
                {
 
75
                    return false;
 
76
                }
 
77
            }
 
78
 
 
79
            return true;
 
80
        }
 
81
 
 
82
        public static bool IsInSameIpv4Subnet(this IPAddress address2, IPAddress address, IPAddress subnetMask)
 
83
        {
 
84
            if (address2.AddressFamily != AddressFamily.InterNetwork || address.AddressFamily != AddressFamily.InterNetwork)
 
85
            {
 
86
                throw new ArgumentException("Both IPAddress must be IPV4 addresses");
 
87
            }
 
88
            var network1 = address.GetNetworkAddress(subnetMask);
 
89
            var network2 = address2.GetNetworkAddress(subnetMask);
 
90
 
 
91
            return network1.Equals(network2);
 
92
        }
 
93
 
 
94
        public static bool IsInSameIpv4Subnet(this byte[] address1Bytes, byte[] address2Bytes, byte[] subnetMaskBytes)
 
95
        {
 
96
            if (address1Bytes.Length != address2Bytes.Length)
 
97
                throw new ArgumentException("Lengths of IP addresses do not match.");
 
98
 
 
99
            var network1Bytes = GetNetworkAddressBytes(address1Bytes, subnetMaskBytes);
 
100
            var network2Bytes = GetNetworkAddressBytes(address2Bytes, subnetMaskBytes);
 
101
 
 
102
            return network1Bytes.AreEqual(network2Bytes);
 
103
        }
 
104
 
 
105
 
 
106
        /// <summary>
 
107
        /// Gets the ipv4 addresses from all Network Interfaces that have Subnet masks.
 
108
        /// </summary>
 
109
        /// <returns></returns>
 
110
        public static Dictionary<IPAddress, IPAddress> GetAllNetworkInterfaceIpv4Addresses()
 
111
        {
 
112
            var map = new Dictionary<IPAddress, IPAddress>();
 
113
 
 
114
            try
 
115
            {
 
116
#if !SILVERLIGHT 
 
117
                foreach (var ni in NetworkInterface.GetAllNetworkInterfaces())
 
118
                {
 
119
                    foreach (var uipi in ni.GetIPProperties().UnicastAddresses)
 
120
                    {
 
121
                        if (uipi.Address.AddressFamily != AddressFamily.InterNetwork) continue;
 
122
 
 
123
                        if (uipi.IPv4Mask == null) continue; //ignore 127.0.0.1
 
124
                        map[uipi.Address] = uipi.IPv4Mask;
 
125
                    }
 
126
                }
 
127
#endif
 
128
            }
 
129
            catch /*(NotImplementedException ex)*/
 
130
            {
 
131
                //log.Warn("MONO does not support NetworkInterface.GetAllNetworkInterfaces(). Could not detect local ip subnets.", ex);
 
132
            } 
 
133
            return map;
 
134
        }
 
135
 
 
136
        /// <summary>
 
137
        /// Gets the ipv6 addresses from all Network Interfaces.
 
138
        /// </summary>
 
139
        /// <returns></returns>
 
140
        public static List<IPAddress> GetAllNetworkInterfaceIpv6Addresses()
 
141
        {
 
142
            var list = new List<IPAddress>();
 
143
 
 
144
            try
 
145
            {
 
146
#if !SILVERLIGHT 
 
147
                foreach (var ni in NetworkInterface.GetAllNetworkInterfaces())
 
148
                {
 
149
                    foreach (var uipi in ni.GetIPProperties().UnicastAddresses)
 
150
                    {
 
151
                        if (uipi.Address.AddressFamily != AddressFamily.InterNetworkV6) continue;
 
152
                        list.Add(uipi.Address);
 
153
                    }
 
154
                }
 
155
#endif
 
156
            }
 
157
            catch /*(NotImplementedException ex)*/
 
158
            {
 
159
                //log.Warn("MONO does not support NetworkInterface.GetAllNetworkInterfaces(). Could not detect local ip subnets.", ex);
 
160
            }
 
161
            
 
162
            return list;
 
163
        }
 
164
 
 
165
    }
 
166
}
 
 
b'\\ No newline at end of file'