public Server (string defaultLocation, NetworkInterface networkInterface)
 {
     default_location = defaultLocation;
     network_interface_info = NetworkInterfaceInfo.GetNetworkInterfaceInfo (networkInterface);
     request_listener = new RequestListener (this);
     announcers = new Dictionary<string, Announcer> ();
 }

        public static UpdateType GetUpdateType(NetworkInterface oldInterface, NetworkInterface newInterface)
        {
            if (oldInterface.Id != newInterface.Id)
                return UpdateType.Name;

            IPInterfaceProperties oldIPProps = oldInterface.GetIPProperties();
            IPInterfaceProperties newIPProps = newInterface.GetIPProperties();

            if (HasIPChanged(oldIPProps, newIPProps))
                return UpdateType.IP;

            if (HasNetmaskChanged(oldIPProps, newIPProps))
                return UpdateType.Netmask;

            if (HasGatewayChanged(oldIPProps, newIPProps))
                return UpdateType.Gateway;

            if (HasDHCPChanged(oldIPProps, newIPProps))
                return UpdateType.DHCP;

            if (HasDNSChanged(oldIPProps, newIPProps))
                return UpdateType.DNS;

            if (!oldIPProps.Equals(newIPProps))
                return UpdateType.Other;

            return UpdateType.None;
        }

 public Client (NetworkInterface networkInterface)
 {
     network_interface_info = NetworkInterfaceInfo.GetNetworkInterfaceInfo (networkInterface);
     service_cache = new ServiceCache (this);
     notify_listener = new NotifyListener (this);
     browsers = new Dictionary<string, Browser> ();
 }

 /// <summary>
 /// Creates a new unicast network address information instance.
 /// </summary>
 /// <param name="iface">The network interface.</param>
 /// <param name="information">The address information.</param>
 public UnicastNetworkAddressInformation(NetworkInterface iface, UnicastIPAddressInformation information)
     : base(iface)
 {
     this.UnicastInformation = information;
     this.Stale = false;
     this.Selected = true;
 }

 public static NetworkInterfaceInfo GetNetworkInterfaceInfo (NetworkInterface networkInterface)
 {
     if (networkInterface == null) {
         return new NetworkInterfaceInfo (IPAddress.Any, 0);
     }
     var properties = networkInterface.GetIPProperties ();
     var ipv4_properties = properties.GetIPv4Properties ();
     if (ipv4_properties == null) {
         throw new ArgumentException ("The specified network interface does not support IPv4.", "networkInterface");
     }
     var host_name = Dns.GetHostName ();
     foreach (var address in properties.UnicastAddresses)
     {
         string addressHostname = null;
         try
         {
             addressHostname = Dns.GetHostEntry(address.Address).HostName;
         }
         catch(SocketException)
         {
             
         }
         if (address.Address.AddressFamily == AddressFamily.InterNetwork && addressHostname == host_name) {
             return new NetworkInterfaceInfo (address.Address, ipv4_properties.Index);
         }
     }
     throw new ArgumentException (string.Format (
         "The specified network interface does not have a suitable address for the local hostname: {0}.", host_name), "networkInterface");
 }

		private Nic(NetworkInterface ni)
		{
			_isInitializing = true;
			Reload(ni);
			_isInitializing = false;
			ConnectivityCheckRequired(this);
		}

        public long getSentPackets( NetworkInterface conn )
        {
            IPInterfaceProperties properties = conn.GetIPProperties();
              IPv4InterfaceStatistics ipstat = conn.GetIPv4Statistics();

             return ipstat.BytesSent;
        }

 public ChatServer(int portNumber, object networkInterface, string serverName)
 {
     this.serverName = serverName;
     this.portNumber = portNumber;
     this.networkInterface = networkInterface as NetworkInterface;
     CreateEventLog();
 }

        /*
           * Get received traffic
           * returns String[] array
          */
        public long getReceivedTraffic( NetworkInterface conn )
        {
            IPInterfaceProperties properties = conn.GetIPProperties();
             IPv4InterfaceStatistics ipstat = conn.GetIPv4Statistics();

             return ipstat.BytesReceived;
        }

 public NetInterface(int id, string name, NetInterfaceType type, NetworkInterface netIface)
 {
     NetshId = id;
     Name = name;
     Type = type;
     networkInterface = netIface;
 }

 public static IPAddress GetGatewayAddressFromNetInterface(NetworkInterface intf)
 {
     IPInterfaceProperties ipProps = intf.GetIPProperties();
     if (ipProps == null)
         return IPAddress.Any;
     if (ipProps.GatewayAddresses == null || ipProps.GatewayAddresses.Count == 0)
         return IPAddress.Any;
     return ipProps.GatewayAddresses[0].Address;
 }

        public NetworkAdapter(NetworkInterface networkInterface)
        {
            _networkInterface = networkInterface;

            Thread timer = new Thread(UpdateNetworkInterface);

            timer.IsBackground = true;
            timer.Start();
        }

 public UploadSpeedEvent(NetworkInterface inter, int sent, int seconds, int comp)
 {
     _Interface = inter;
     _Sent = sent;
     _ToBeFor = seconds;
     _Comparator = comp;
     _LastValue = inter.GetIPv4Statistics().BytesSent;
     _Name = "Upload Speed Usage Event";
 }

 public DownloadSpeedEvent(NetworkInterface inter, int received, int seconds, int comp)
 {
     _Interface = inter;
     _Received = received;
     _ToBeFor = seconds;
     _Comparator = comp;
     _LastValue = inter.GetIPv4Statistics().BytesReceived;
     _Name = "Download Speed Usage Event";
 }

 public NetworkConfigModel(NetworkInterface ni)
 {
     var ip = ni.GetIPProperties();
     this.IpAddress = ip.UnicastAddresses.Count > 0 ? ip.UnicastAddresses[0].Address.ToString() : "";
     this.Gateway = ip.GatewayAddresses.Count > 0 ? ip.GatewayAddresses[0].Address.ToString() : "";
     this.Subnet = ip.UnicastAddresses.Count > 0 ? ip.UnicastAddresses[0].IPv4Mask.ToString() : "";
     this.DNSList = ip.DnsAddresses.Count > 0 ? string.Join(";", ip.DnsAddresses.Select(dn => dn.ToString())) : "";
     this.NetworkName = ni.Name;
     this.InterfaceName = ni.Description;
     this.UseDHCP = string.IsNullOrEmpty(this.IpAddress) && string.IsNullOrEmpty(this.Gateway);
 }

        public Boolean isNetworkConnected(NetworkInterface net)
        {
            Boolean bReturn = false;
            if (net != null && net.OperationalStatus == OperationalStatus.Up && net.GetIPProperties() != null && net.Description != null && net.NetworkInterfaceType != NetworkInterfaceType.Loopback) {
                bReturn =  true;
            }

            Helper.doLog("isNetworkConnected " + net.Id + " = " + bReturn, Properties.Settings.Default.DebugMode);

            return bReturn;
        }

        /// <summary>
        /// Shows the form as a dialog and the specified network interface.
        /// </summary>
        /// <param name="owner">The owner window.</param>
        /// <param name="iface">The network interface.</param>
        /// <returns>The dialog result.</returns>
        public DialogResult ShowDialog(IWin32Window owner, NetworkInterface iface)
        {
            // If the comment is null, do nothing.
            if (null == iface) return DialogResult.Abort;

            // Set the comment.
            this.control.Interface = iface;

            // Open the dialog.
            return base.ShowDialog(owner);
        }

		private void SetSocketOptionsForNic(NetworkInterface nic)
		{
			nic.GetIPProperties()
				.UnicastAddresses
				.Where(unicast => unicast.Address.AddressFamily == AddressFamily.InterNetwork)
				.ToList()
				.ForEach(
					address =>
					socket.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.AddMembership,
					                       new MulticastOption(IPAddress.Parse(AllHostsMulticastIP), address.Address)));
		}

        public static BooleanReason AddWirelessProfile(NetworkInterface adapter, string profile)
        {
            var handle = IntPtr.Zero;
            try
            {
                if (string.IsNullOrWhiteSpace(profile))
                {
                    Log.Warn("Cannot add wireless profile: profile text is empty");
                    return new BooleanReason(false, "Cannot add wireless profile: profile text is empty");
                }

                UInt32 negotiatedVersion;
                UInt32 version = 2;
                if (SystemUtilities.IsWindowsXp())
                    version = 1;

                var result = NativeWifi.WlanOpenHandle(version, IntPtr.Zero, out negotiatedVersion, out handle);
                if (result != 0)
                {
                    Log.WarnFormat("Could not open handle to native wifi interface: {0}", result);
                    return new BooleanReason(false, "Could not open handle to native wifi interface: {0}", result);
                }

                var identifier = new Guid(adapter.Id);
                NativeWifi.WlanReasonCode issueCode;

                result = NativeWifi.WlanSetProfile(
                    handle, identifier, NativeWifi.WlanProfileFlags.AllUser,
                    profile, null, true, IntPtr.Zero, out issueCode);

                if ((result != 0) && (result != 183))
                {
                    var issueText = GetTextForIssue(
                        "An issue occurred while attempting to set a wireless profile: {0}", issueCode);

                    Log.Warn(issueText);
                    return new BooleanReason(false, issueText);
                }

                return new BooleanReason(true, "");
            }

            catch (Exception e)
            {
                Log.Warn(e);
                return new BooleanReason(false, "An exception occurred while setting the wireless profile: {0}", e);
            }
            finally
            {
                if (handle != IntPtr.Zero)
                    NativeWifi.WlanCloseHandle(handle, IntPtr.Zero);
            }
        }

 public WifiWidget()
 {
     NetworkInterface[] interfaces = NetworkInterface.GetAllNetworkInterfaces();
     foreach (NetworkInterface inter in interfaces)
     {
         if (inter.NetworkInterfaceType == NetworkInterfaceType.Wireless80211)
         {
             _wifi = inter;
             break;
         }
     }
 }