#region Using
using System;
using System.Collections;
using System.Diagnostics;
using System.IO;
using System.Runtime.InteropServices;
using System.Text;
#endregion
namespace IPv6LeakTest
{
    public class Program
    {
        #region Enums
        public enum ADDRESS_FAMILIES : uint
        {
            AF_UNSPEC = 0,
            AF_UNIX = 1,
            AF_INET = 2,
            AF_IMPLINK = 3,
            AF_PUP = 4,
            AF_CHAOS = 5,
            AF_NS = 6,
            AF_IPX = 6,
            AF_ISO = 7,
            AF_OSI = 7,
            AF_ECMA = 8,
            AF_DATAKIT = 9,
            AF_CCITT = 10,
            AF_SNA = 11,
            AF_DECnet = 12,
            AF_DLI = 13,
            AF_LAT = 14,
            AF_HYLINK = 15,
            AF_APPLETALK = 16,
            AF_NETBIOS = 17,
            AF_VOICEVIEW = 18,
            AF_FIREFOX = 19,
            AF_UNKNOWN1 = 20,
            AF_BAN = 21,
            AF_ATM = 22,
            AF_INET6 = 23,
            AF_CLUSTER = 24,
            AF_12844 = 25,
            AF_IRDA = 26,
            AF_NETDES = 28,
            AF_TCNPROCESS = 29,
            AF_TCNMESSAGE = 30,
            AF_ICLFXBM = 31
        }

        public enum ERROR : uint
        {
            ERROR_SUCCESS = 0,
            ERROR_NO_DATA = 232,
            ERROR_BUFFER_OVERFLOW = 111,
            ERROR_INVALID_PARAMETER = 87
        }

        public enum FLAGS : uint
        {
            GAA_FLAG_SKIP_UNICAST = 0x0001,
            GAA_FLAG_SKIP_ANYCAST = 0x0002,
            GAA_FLAG_SKIP_MULTICAST = 0x0004,
            GAA_FLAG_SKIP_DNS_SERVER = 0x0008,
            GAA_FLAG_INCLUDE_PREFIX = 0x0010,
            GAA_FLAG_SKIP_FRIENDLY_NAME = 0x0020
        }

        public enum IF_OPER_STATUS : uint
        {
            IfOperStatusUp = 1,
            IfOperStatusDown,
            IfOperStatusTesting,
            IfOperStatusUnknown,
            IfOperStatusDormant,
            IfOperStatusNotPresent,
            IfOperStatusLowerLayerDown,
        }

        public enum IF_TYPE : uint
        {
            IF_TYPE_OTHER = 1,
            IF_TYPE_REGULAR_1822 = 2,
            IF_TYPE_HDH_1822 = 3,
            IF_TYPE_DDN_X25 = 4,
            IF_TYPE_RFC877_X25 = 5,
            IF_TYPE_ETHERNET_CSMACD = 6,
            IF_TYPE_IS088023_CSMACD = 7,
            IF_TYPE_ISO88024_TOKENBUS = 8,
            IF_TYPE_ISO88025_TOKENRING = 9,
            IF_TYPE_ISO88026_MAN = 10,
            IF_TYPE_STARLAN = 11,
            IF_TYPE_PROTEON_10MBIT = 12,
            IF_TYPE_PROTEON_80MBIT = 13,
            IF_TYPE_HYPERCHANNEL = 14,
            IF_TYPE_FDDI = 15,
            IF_TYPE_LAP_B = 16,
            IF_TYPE_SDLC = 17,
            IF_TYPE_DS1 = 18,
            IF_TYPE_E1 = 19,
            IF_TYPE_BASIC_ISDN = 20,
            IF_TYPE_PRIMARY_ISDN = 21,
            IF_TYPE_PROP_POINT2POINT_SERIAL = 22,
            IF_TYPE_PPP = 23,
            IF_TYPE_SOFTWARE_LOOPBACK = 24,
            IF_TYPE_EON = 25,
            IF_TYPE_ETHERNET_3MBIT = 26,
            IF_TYPE_NSIP = 27,
            IF_TYPE_SLIP = 28,
            IF_TYPE_ULTRA = 29,
            IF_TYPE_DS3 = 30,
            IF_TYPE_SIP = 31,
            IF_TYPE_FRAMERELAY = 32,
            IF_TYPE_RS232 = 33,
            IF_TYPE_PARA = 34,
            IF_TYPE_ARCNET = 35,
            IF_TYPE_ARCNET_PLUS = 36,
            IF_TYPE_ATM = 37,
            IF_TYPE_MIO_X25 = 38,
            IF_TYPE_SONET = 39,
            IF_TYPE_X25_PLE = 40,
            IF_TYPE_ISO88022_LLC = 41,
            IF_TYPE_LOCALTALK = 42,
            IF_TYPE_SMDS_DXI = 43,
            IF_TYPE_FRAMERELAY_SERVICE = 44,
            IF_TYPE_V35 = 45,
            IF_TYPE_HSSI = 46,
            IF_TYPE_HIPPI = 47,
            IF_TYPE_MODEM = 48,
            IF_TYPE_AAL5 = 49,
            IF_TYPE_SONET_PATH = 50,
            IF_TYPE_SONET_VT = 51,
            IF_TYPE_SMDS_ICIP = 52,
            IF_TYPE_PROP_VIRTUAL = 53,
            IF_TYPE_PROP_MULTIPLEXOR = 54,
            IF_TYPE_IEEE80212 = 55,
            IF_TYPE_FIBRECHANNEL = 56,
            IF_TYPE_HIPPIINTERFACE = 57,
            IF_TYPE_FRAMERELAY_INTERCONNECT = 58,
            IF_TYPE_AFLANE_8023 = 59,
            IF_TYPE_AFLANE_8025 = 60,
            IF_TYPE_CCTEMUL = 61,
            IF_TYPE_FASTETHER = 62,
            IF_TYPE_ISDN = 63,
            IF_TYPE_V11 = 64,
            IF_TYPE_V36 = 65,
            IF_TYPE_G703_64K = 66,
            IF_TYPE_G703_2MB = 67,
            IF_TYPE_QLLC = 68,
            IF_TYPE_FASTETHER_FX = 69,
            IF_TYPE_CHANNEL = 70,
            IF_TYPE_IEEE80211 = 71,
            IF_TYPE_IBM370PARCHAN = 72,
            IF_TYPE_ESCON = 73,
            IF_TYPE_DLSW = 74,
            IF_TYPE_ISDN_S = 75,
            IF_TYPE_ISDN_U = 76,
            IF_TYPE_LAP_D = 77,
            IF_TYPE_IPSWITCH = 78,
            IF_TYPE_RSRB = 79,
            IF_TYPE_ATM_LOGICAL = 80,
            IF_TYPE_DS0 = 81,
            IF_TYPE_DS0_BUNDLE = 82,
            IF_TYPE_BSC = 83,
            IF_TYPE_ASYNC = 84,
            IF_TYPE_CNR = 85,
            IF_TYPE_ISO88025R_DTR = 86,
            IF_TYPE_EPLRS = 87,
            IF_TYPE_ARAP = 88,
            IF_TYPE_PROP_CNLS = 89,
            IF_TYPE_HOSTPAD = 90,
            IF_TYPE_TERMPAD = 91,
            IF_TYPE_FRAMERELAY_MPI = 92,
            IF_TYPE_X213 = 93,
            IF_TYPE_ADSL = 94,
            IF_TYPE_RADSL = 95,
            IF_TYPE_SDSL = 96,
            IF_TYPE_VDSL = 97,
            IF_TYPE_ISO88025_CRFPRINT = 98,
            IF_TYPE_MYRINET = 99,
            IF_TYPE_VOICE_EM = 100,
            IF_TYPE_VOICE_FXO = 101,
            IF_TYPE_VOICE_FXS = 102,
            IF_TYPE_VOICE_ENCAP = 103,
            IF_TYPE_VOICE_OVERIP = 104,
            IF_TYPE_ATM_DXI = 105,
            IF_TYPE_ATM_FUNI = 106,
            IF_TYPE_ATM_IMA = 107,
            IF_TYPE_PPPMULTILINKBUNDLE = 108,
            IF_TYPE_IPOVER_CDLC = 109,
            IF_TYPE_IPOVER_CLAW = 110,
            IF_TYPE_STACKTOSTACK = 111,
            IF_TYPE_VIRTUALIPADDRESS = 112,
            IF_TYPE_MPC = 113,
            IF_TYPE_IPOVER_ATM = 114,
            IF_TYPE_ISO88025_FIBER = 115,
            IF_TYPE_TDLC = 116,
            IF_TYPE_GIGABITETHERNET = 117,
            IF_TYPE_HDLC = 118,
            IF_TYPE_LAP_F = 119,
            IF_TYPE_V37 = 120,
            IF_TYPE_X25_MLP = 121,
            IF_TYPE_X25_HUNTGROUP = 122,
            IF_TYPE_TRANSPHDLC = 123,
            IF_TYPE_INTERLEAVE = 124,
            IF_TYPE_FAST = 125,
            IF_TYPE_IP = 126,
            IF_TYPE_DOCSCABLE_MACLAYER = 127,
            IF_TYPE_DOCSCABLE_DOWNSTREAM = 128,
            IF_TYPE_DOCSCABLE_UPSTREAM = 129,
            IF_TYPE_A12MPPSWITCH = 130,
            IF_TYPE_TUNNEL = 131,
            IF_TYPE_COFFEE = 132,
            IF_TYPE_CES = 133,
            IF_TYPE_ATM_SUBINTERFACE = 134,
            IF_TYPE_L2_VLAN = 135,
            IF_TYPE_L3_IPVLAN = 136,
            IF_TYPE_L3_IPXVLAN = 137,
            IF_TYPE_DIGITALPOWERLINE = 138,
            IF_TYPE_MEDIAMAILOVERIP = 139,
            IF_TYPE_DTM = 140,
            IF_TYPE_DCN = 141,
            IF_TYPE_IPFORWARD = 142,
            IF_TYPE_MSDSL = 143,
            IF_TYPE_IEEE1394 = 144,
            IF_TYPE_RECEIVE_ONLY = 145,
        }

        public enum IP_DAD_STATE : uint
        {
            IpDadStateInvalid = 0,
            IpDadStateTentative,
            IpDadStateDuplicate,
            IpDadStateDeprecated,
            IpDadStatePreferred,
        }

        public enum IP_PREFIX_ORIGIN : uint
        {
            IpPrefixOriginOther = 0,
            IpPrefixOriginManual,
            IpPrefixOriginWellKnown,
            IpPrefixOriginDhcp,
            IpPrefixOriginRouterAdvertisement,
        }

        public enum IP_SUFFIX_ORIGIN : uint
        {
            IpSuffixOriginOther = 0,
            IpSuffixOriginManual,
            IpSuffixOriginWellKnown,
            IpSuffixOriginDhcp,
            IpSuffixOriginLinkLayerAddress,
            IpSuffixOriginRandom,
        }

        public enum NET_IF_CONNECTION_TYPE : uint
        {
            NET_IF_CONNECTION_DEDICATED = 1,
            NET_IF_CONNECTION_PASSIVE = 2,
            NET_IF_CONNECTION_DEMAND = 3,
            NET_IF_CONNECTION_MAXIMUM = 4
        }

        public enum TUNNEL_TYPE : uint
        {
            TUNNEL_TYPE_NONE = 0,
            TUNNEL_TYPE_OTHER = 1,
            TUNNEL_TYPE_DIRECT = 2,
            TUNNEL_TYPE_6TO4 = 11,
            TUNNEL_TYPE_ISATAP = 13,
            TUNNEL_TYPE_TEREDO = 14,
            TUNNEL_TYPE_IPHTTPS = 15
        }
        #endregion
        #region Constants
        const string IPV6_BLACKHOLE_ROUTE_ADDR = "fe80::8";
        const string IPV6_LINK_LOCAL_PREFIX = "fe80::";
        const string TUN_BLACKHOLE_IPV6_ADDR = "fd00::1";

        const int MAX_ADAPTER_NAME_LENGTH = 256;
        const int MAX_ADAPTER_DESCRIPTION_LENGTH = 128;
        const int MAX_ADAPTER_ADDRESS_LENGTH = 8;
        const int MAX_DHCPV6_DUID_LENGTH = 130;
        const int MAX_TRIES = 3;

        const int INET6_ADDRSTRLEN = 65;
        const uint WORKING_BUFFER_SIZE = 15000;
        #endregion
        #region Structures
        [StructLayout(LayoutKind.Sequential)]
        public struct GUID
        {
            uint Data1;
            ushort Data2;
            ushort Data3;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
            byte[] Data4;
        }

        [StructLayout(LayoutKind.Explicit, Size = 4)]
        public struct in_addr
        {
            [FieldOffset(0)]
            internal byte s_b1;
            [FieldOffset(1)]
            internal byte s_b2;
            [FieldOffset(2)]
            internal byte s_b3;
            [FieldOffset(3)]
            internal byte s_b4;

            [FieldOffset(0)]
            internal ushort s_w1;
            [FieldOffset(2)]
            internal ushort s_w2;

            [FieldOffset(0)]
            internal uint S_addr;

            internal uint s_addr
            {
                get { return S_addr; }
            }

            internal byte s_host
            {
                get { return s_b2; }
            }

            internal byte s_net
            {
                get { return s_b1; }
            }

            internal ushort s_imp
            {
                get { return s_w2; }
            }

            internal byte s_impno
            {
                get { return s_b4; }
            }

            internal byte s_lh
            {
                get { return s_b3; }
            }
        }

        [StructLayout(LayoutKind.Explicit, Size = 16)]
        public struct in6_addr
        {
            [FieldOffset(0)]
            internal byte Byte_0;
            [FieldOffset(1)]
            internal byte Byte_1;
            [FieldOffset(2)]
            internal byte Byte_2;
            [FieldOffset(3)]
            internal byte Byte_3;

            [FieldOffset(4)]
            internal byte Byte_4;
            [FieldOffset(5)]
            internal byte Byte_5;
            [FieldOffset(6)]
            internal byte Byte_6;
            [FieldOffset(7)]
            internal byte Byte_7;

            [FieldOffset(8)]
            internal byte Byte_8;
            [FieldOffset(9)]
            internal byte Byte_9;
            [FieldOffset(10)]
            internal byte Byte_10;
            [FieldOffset(11)]
            internal byte Byte_11;

            [FieldOffset(12)]
            internal byte Byte_12;
            [FieldOffset(13)]
            internal byte Byte_13;
            [FieldOffset(14)]
            internal byte Byte_14;
            [FieldOffset(15)]
            internal byte Byte_16;

            [FieldOffset(0)]
            internal short Word_0;
            [FieldOffset(2)]
            internal short Word_1;
            [FieldOffset(4)]
            internal short Word_2;
            [FieldOffset(6)]
            internal short Word_3;

            [FieldOffset(8)]
            internal short Word_4;
            [FieldOffset(10)]
            internal short Word_5;
            [FieldOffset(12)]
            internal short Word_6;
            [FieldOffset(14)]
            internal short Word_7;
        }

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
        public struct IP_ADDRESS_STRING
        {
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 16)]
            public string Address;
        }

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
        public struct IP_ADDR_STRING
        {
            public IntPtr Next;
            public IP_ADDRESS_STRING IpAddress;
            public IP_ADDRESS_STRING Mask;
            public Int32 Context;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct IP_ADAPTER_ADDRESSES
        {
            public UInt64 Alignment;
            public IntPtr Next;
            public IntPtr AdapterName;
            public IntPtr FirstUnicastAddress;
            public IntPtr FirstAnycastAddress;
            public IntPtr FirstMulticastAddress;
            public IntPtr FirstDnsServerAddress;
            [MarshalAs(UnmanagedType.LPWStr)]
            public string DnsSuffix;
            [MarshalAs(UnmanagedType.LPWStr)]
            public string Description;
            [MarshalAs(UnmanagedType.LPWStr)]
            public string FriendlyName;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = MAX_ADAPTER_ADDRESS_LENGTH)]
            public byte[] PhysicalAddress;
            public uint PhysicalAddressLength;
            public uint Flags;
            public uint Mtu;
            public IF_TYPE IfType;
            public IF_OPER_STATUS OperStatus;
            uint Ipv6IfIndex;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
            public uint[] ZoneIndices;
            public IntPtr FirstPrefix;

            // Items added for Vista
            // May need to be removed on Windows versions below Vista to work properly (?)
            public UInt64 TrasmitLinkSpeed;
            public UInt64 ReceiveLinkSpeed;
            public IntPtr FirstWinsServerAddress;
            public IntPtr FirstGatewayAddress;
            public uint Ipv4Metric;
            public uint Ipv6Metric;
            public UInt64 Luid;
            public SOCKET_ADDRESS Dhcpv4Server;
            public uint CompartmentId;
            public GUID NetworkGuid;
            public NET_IF_CONNECTION_TYPE ConnectionType;
            public TUNNEL_TYPE TunnelType;
            public SOCKET_ADDRESS Dhcpv6Server;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = MAX_DHCPV6_DUID_LENGTH)]
            public byte[] Dhcpv6ClientDuid;
            public uint Dhcpv6ClientDuidLength;
            public uint Dhcpv6Iaid;
            public uint FirstDnsSuffix;
        }

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
        public struct IP_ADAPTER_INFO
        {
            public IntPtr Next;
            public Int32 ComboIndex;
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_ADAPTER_NAME_LENGTH + 4)]
            public string AdapterName;
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_ADAPTER_DESCRIPTION_LENGTH + 4)]
            public string AdapterDescription;
            public UInt32 AddressLength;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = MAX_ADAPTER_ADDRESS_LENGTH)]
            public byte[] Address;
            public Int32 Index;
            public UInt32 Type;
            public UInt32 DhcpEnabled;
            public IntPtr CurrentIpAddress;
            public IP_ADDR_STRING IpAddressList;
            public IP_ADDR_STRING GatewayList;
            public IP_ADDR_STRING DhcpServer;
            public bool HaveWins;
            public IP_ADDR_STRING PrimaryWinsServer;
            public IP_ADDR_STRING SecondaryWinsServer;
            public Int32 LeaseObtained;
            public Int32 LeaseExpires;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct IP_ADAPTER_UNICAST_ADDRESS
        {
            public UInt64 Alignment;
            public IntPtr Next;
            public SOCKET_ADDRESS Address;
            public IP_PREFIX_ORIGIN PrefixOrigin;
            public IP_SUFFIX_ORIGIN SuffixOrigin;
            public IP_DAD_STATE DadState;
            public uint ValidLifetime;
            public uint PreferredLifetime;
            public uint LeaseLifetime;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct SOCKADDR
        {
            public ushort sa_family;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 14)]
            public byte[] sa_data;
        }

        [StructLayout(LayoutKind.Explicit, Size = 28)]
        public struct sockaddr_in6
        {
            [FieldOffset(0)]
            internal ADDRESS_FAMILIES sin6_family;
            [FieldOffset(2)]
            internal ushort sin6_port;
            [FieldOffset(4)]
            internal uint sin6_flowinfo;
            [FieldOffset(8)]
            internal in6_addr sin6_addr;
            [FieldOffset(24)]
            internal uint sin6_scope_id;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct SOCKET_ADDRESS
        {
            public IntPtr lpSockAddr; //LPSOCKADDR
            public int iSockaddrLength;
        }
        #endregion
        #region External Methods
        [DllImport("iphlpapi.dll")]
        private static extern ERROR GetAdaptersAddresses(uint Family, uint Flags, IntPtr Reserved, IntPtr pAdapterAddresses, ref uint pOutBufLen);

        [DllImport("iphlpapi.dll", CharSet = CharSet.Ansi)]
        private static extern ERROR GetAdaptersInfo(IntPtr pAdapterInfo, ref Int64 pBufOutLen);

        [DllImport("Ws2_32.dll", CharSet = CharSet.Unicode, EntryPoint = "InetNtopW")]
        public static extern uint InetNtop(ADDRESS_FAMILIES Family, ref in_addr pAddr, StringBuilder pStringBuf, int StringBufSize);

        [DllImport("Ws2_32.dll", CharSet = CharSet.Unicode, EntryPoint = "InetNtopW")]
        public static extern uint InetNtop(ADDRESS_FAMILIES Family, ref in6_addr pAddr, StringBuilder pStringBuf, int StringBufSize);

        [DllImport("Ws2_32.dll", CharSet = CharSet.Unicode, EntryPoint = "InetPtonW")]
        public static extern uint InetPton(ADDRESS_FAMILIES Family, string pszAddrString, ref in_addr pAddrBuf);

        [DllImport("Ws2_32.dll", CharSet = CharSet.Unicode, EntryPoint = "InetPtonW")]
        public static extern uint InetPton(ADDRESS_FAMILIES Family, string pszAddrString, ref in6_addr pAddrBuf);
        #endregion
        #region Static Methods
        private static void Execute(string cmd)
        {
            Console.WriteLine("Executing command: " + cmd);

            Process p = new Process();
            p.StartInfo.FileName = Environment.GetFolderPath(Environment.SpecialFolder.System) + Path.DirectorySeparatorChar + "cmd.exe";
            p.StartInfo.WorkingDirectory = Environment.GetFolderPath(Environment.SpecialFolder.System);
            p.StartInfo.Arguments = cmd;
            p.StartInfo.UseShellExecute = false;
            p.StartInfo.Verb = "runas";
            p.Start();
        }

        // Get info for all network adapters
        private static Adapter[] GetAdaptersInfo()
        {
            Adapter[] adaptersList;
            ArrayList adapters = new ArrayList();
            long structSize = Marshal.SizeOf(typeof(IP_ADAPTER_INFO));
            IntPtr pArray = Marshal.AllocHGlobal((int)structSize);
            ERROR retVal = GetAdaptersInfo(pArray, ref structSize);

            if (retVal.Equals(ERROR.ERROR_BUFFER_OVERFLOW))
            {
                // Buffer was too small, reallocate the correct size for the buffer.
                pArray = Marshal.ReAllocHGlobal(pArray, new IntPtr(structSize));
                retVal = GetAdaptersInfo(pArray, ref structSize);
            }

            if (retVal.Equals(ERROR.ERROR_SUCCESS))
            {
                // Call Succeeded
                IntPtr pEntry = pArray;

                do
                {
                    // Retrieve the adapter info from the memory address
                    IP_ADAPTER_INFO entry = (IP_ADAPTER_INFO)Marshal.PtrToStructure(pEntry, typeof(IP_ADAPTER_INFO));

                    Adapter adapter = new Adapter();
                    adapter.Index = entry.Index;
                    adapter.Name = entry.AdapterName;
                    adapter.Description = entry.AdapterDescription;
                    adapter.IP = entry.IpAddressList.IpAddress.Address;

                    // MAC Address (data is in a byte[])
                    string tmpString = string.Empty;
                    for (int i = 0; i < entry.AddressLength; i++)
                    {
                        tmpString += string.Format("{0:X2}", entry.Address);
                    }

                    adapter.MacAddress = tmpString;
                    adapters.Add(adapter);

                    // Get next adapter (if any)
                    pEntry = entry.Next;
                }
                while (pEntry != IntPtr.Zero);

                Marshal.FreeHGlobal(pArray);

                adaptersList = new Adapter[adapters.Count];
                adapters.CopyTo(adaptersList);
            }
            else
            {
                adaptersList = new Adapter[0];

                Marshal.FreeHGlobal(pArray);

                throw new InvalidOperationException("GetAdaptersInfo failed with: " + retVal.ToString());
            }

            return adaptersList;
        }

        // Get TUN interface ID
        private static int GetTUNInterfaceID()
        {
            foreach (Adapter adapter in GetAdaptersInfo())
            {
                if (adapter.Description.Contains("TAP-Windows Adapter V9")) return adapter.Index;
            }

            return 0;
        }

        // set IPv6 IP address for TUN
        private static void SetIPv6AddrToTun(int tunIfIndex)
        {
            Execute("netsh interface ipv6 add address interface=" + tunIfIndex.ToString() + " " + TUN_BLACKHOLE_IPV6_ADDR);
        }

        // set IPv6 blockhole route
        private static void SetIPv6BlackHoleRoute(int tunIfIndex)
        {
            IntPtr addresses = IntPtr.Zero;
            ERROR retVal = ERROR.ERROR_SUCCESS;
            uint outBufLen = WORKING_BUFFER_SIZE;
            int iterations = 0;

            do
            {
                addresses = Marshal.AllocHGlobal((int)outBufLen);
                if (addresses.Equals(IntPtr.Zero))
                {
                    Console.WriteLine("Memory allocation failed for IP_ADAPTER_ADDRESSES struct");
                    return;
                }

                retVal = GetAdaptersAddresses((uint)ADDRESS_FAMILIES.AF_INET6, (uint)FLAGS.GAA_FLAG_INCLUDE_PREFIX, IntPtr.Zero, addresses, ref outBufLen);

                if (retVal.Equals(ERROR.ERROR_BUFFER_OVERFLOW))
                {
                    Marshal.FreeHGlobal(addresses);
                    addresses = IntPtr.Zero;
                }
                else break;

                iterations++;
            }
            while ((retVal.Equals(ERROR.ERROR_BUFFER_OVERFLOW)) && (iterations < MAX_TRIES));

            if (retVal.Equals(ERROR.ERROR_SUCCESS))
            {
                while (!addresses.Equals(IntPtr.Zero))
                {
                    // If successful, output some information from the data we received
                    IP_ADAPTER_ADDRESSES currAddresses = (IP_ADAPTER_ADDRESSES)Marshal.PtrToStructure(addresses, typeof(IP_ADAPTER_ADDRESSES));
                    IntPtr unicast = currAddresses.FirstUnicastAddress;

                    while (!unicast.Equals(IntPtr.Zero))
                    {
                        IP_ADAPTER_UNICAST_ADDRESS unicastAddresses = (IP_ADAPTER_UNICAST_ADDRESS)Marshal.PtrToStructure(unicast, typeof(IP_ADAPTER_UNICAST_ADDRESS));

                        SetBlackHoleRoute(unicastAddresses.Address, tunIfIndex);

                        unicast = unicastAddresses.Next;
                    }

                    addresses = currAddresses.Next;
                }
            }

            if (!addresses.Equals(IntPtr.Zero))
            {
                Marshal.FreeHGlobal(addresses);
                addresses = IntPtr.Zero;
            }
        }

        // set blackhole route per each IPv6 interface
        private static void SetBlackHoleRoute(SOCKET_ADDRESS sockAddr, int tunIfIndex)
        {
            sockaddr_in6 mask_addr6 = new sockaddr_in6();
            sockaddr_in6 subnet_addr6 = new sockaddr_in6();
            StringBuilder szIPv6Addr = new StringBuilder();
            StringBuilder szSubnetIPv6Addr = new StringBuilder();

            SOCKADDR socketAddr = (SOCKADDR)Marshal.PtrToStructure(sockAddr.lpSockAddr, typeof(SOCKADDR));

            if ((uint)socketAddr.sa_family != (uint)ADDRESS_FAMILIES.AF_INET6) return;

            sockaddr_in6 addr6 = (sockaddr_in6)Marshal.PtrToStructure(sockAddr.lpSockAddr, typeof(sockaddr_in6));

            InetNtop(ADDRESS_FAMILIES.AF_INET6, ref addr6.sin6_addr, szIPv6Addr, INET6_ADDRSTRLEN);

            string ipv6 = szIPv6Addr.ToString();

            if (ipv6.StartsWith(IPV6_LINK_LOCAL_PREFIX) ||
                ipv6.Equals(TUN_BLACKHOLE_IPV6_ADDR) ||
                ipv6.StartsWith("::"))
                return;

            // get subnet for ipv6 address
            InetPton(ADDRESS_FAMILIES.AF_INET6, "fff0::", ref mask_addr6.sin6_addr);

            subnet_addr6.sin6_addr.Byte_0 = (byte)(addr6.sin6_addr.Byte_0 & mask_addr6.sin6_addr.Byte_0);
            subnet_addr6.sin6_addr.Byte_1 = (byte)(addr6.sin6_addr.Byte_1 & mask_addr6.sin6_addr.Byte_1);
            subnet_addr6.sin6_addr.Byte_2 = (byte)(addr6.sin6_addr.Byte_2 & mask_addr6.sin6_addr.Byte_2);
            subnet_addr6.sin6_addr.Byte_3 = (byte)(addr6.sin6_addr.Byte_3 & mask_addr6.sin6_addr.Byte_3);
            subnet_addr6.sin6_addr.Byte_4 = (byte)(addr6.sin6_addr.Byte_4 & mask_addr6.sin6_addr.Byte_4);
            subnet_addr6.sin6_addr.Byte_5 = (byte)(addr6.sin6_addr.Byte_5 & mask_addr6.sin6_addr.Byte_5);
            subnet_addr6.sin6_addr.Byte_6 = (byte)(addr6.sin6_addr.Byte_6 & mask_addr6.sin6_addr.Byte_6);
            subnet_addr6.sin6_addr.Byte_7 = (byte)(addr6.sin6_addr.Byte_7 & mask_addr6.sin6_addr.Byte_7);
            subnet_addr6.sin6_addr.Byte_8 = (byte)(addr6.sin6_addr.Byte_8 & mask_addr6.sin6_addr.Byte_8);
            subnet_addr6.sin6_addr.Byte_9 = (byte)(addr6.sin6_addr.Byte_9 & mask_addr6.sin6_addr.Byte_9);
            subnet_addr6.sin6_addr.Byte_10 = (byte)(addr6.sin6_addr.Byte_10 & mask_addr6.sin6_addr.Byte_10);
            subnet_addr6.sin6_addr.Byte_11 = (byte)(addr6.sin6_addr.Byte_11 & mask_addr6.sin6_addr.Byte_11);
            subnet_addr6.sin6_addr.Byte_12 = (byte)(addr6.sin6_addr.Byte_12 & mask_addr6.sin6_addr.Byte_12);
            subnet_addr6.sin6_addr.Byte_13 = (byte)(addr6.sin6_addr.Byte_13 & mask_addr6.sin6_addr.Byte_13);
            subnet_addr6.sin6_addr.Byte_14 = (byte)(addr6.sin6_addr.Byte_14 & mask_addr6.sin6_addr.Byte_14);
            //subnet_addr6.sin6_addr.Byte_15 = (byte)(addr6.sin6_addr.Byte_15 & mask_addr6.sin6_addr.Byte_15);
            subnet_addr6.sin6_addr.Byte_16 = (byte)(addr6.sin6_addr.Byte_16 & mask_addr6.sin6_addr.Byte_16);

            InetNtop(ADDRESS_FAMILIES.AF_INET6, ref subnet_addr6.sin6_addr, szSubnetIPv6Addr, INET6_ADDRSTRLEN);

            // add route for ipv6 blackhole
            Execute("netsh interface ipv6 add route prefix=" + szSubnetIPv6Addr.ToString() + " interface=" + tunIfIndex.ToString() + " " + IPV6_BLACKHOLE_ROUTE_ADDR);
        }
        #endregion
        #region Entry Point
        static void Main(string[] args)
        {
            // get index of TUN interface
            int tunIfIndex = GetTUNInterfaceID();
            if (tunIfIndex.Equals(0))
            {
                Console.WriteLine("Couldn't find the TUN interface");
                return;
            }

            // set IPv6 address to TUN interface
            SetIPv6AddrToTun(tunIfIndex);

            // set blackhole route
            SetIPv6BlackHoleRoute(tunIfIndex);
        }
        #endregion
    }
}