code/Net/Net.cs

Go to the documentation of this file.

namespace Sylloge
{
    public static partial class Net
    {
        public static class IPv4
        {
            public struct StructInterface
            {
                public bool IsLoopback;
                public string IpAddress;
                public string SubnetMask;
                public string Broadcast;
                public System.Net.NetworkInformation.PhysicalAddress MAC;
                public System.Net.NetworkInformation.NetworkInterface Interface;
            }

            public static Sylloge.Net.IPv4.StructInterface[] Interfaces
            {
                get
                {
                    System.Collections.Generic.List<Sylloge.Net.IPv4.StructInterface> ifaces = new System.Collections.Generic.List<Sylloge.Net.IPv4.StructInterface>();
                    foreach (System.Net.NetworkInformation.NetworkInterface iface in System.Net.NetworkInformation.NetworkInterface.GetAllNetworkInterfaces()) {
                        bool lback = (iface.NetworkInterfaceType == System.Net.NetworkInformation.NetworkInterfaceType.Loopback);
                        foreach (System.Net.NetworkInformation.UnicastIPAddressInformation IP in iface.GetIPProperties().UnicastAddresses) {
                            if (IP.Address.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork) {
                                if (IP != null && IP.Address != null && IP.IPv4Mask != null) {
                                    Sylloge.Net.IPv4.StructInterface Item = new Sylloge.Net.IPv4.StructInterface();
                                    Item.Interface = iface;
                                    Item.IsLoopback = lback;
                                    Item.IpAddress = IP.Address.ToString();
                                    Item.SubnetMask = IP.IPv4Mask.ToString();
                                    Item.MAC = iface.GetPhysicalAddress();
                                    Item.Broadcast = Sylloge.Net.IPv4.GetBroadcastFromIpAndSubnet(Item.IpAddress, Item.SubnetMask);
                                    ifaces.Add(Item);
                                }

                            }
                        }
                    }
                    return ifaces.ToArray();
                }
            }

            public static string GetBroadcastFromIpAndSubnet(string ipAddress, string subnetMask)
            {
                if (!Sylloge.Net.IPv4.IsValidIp(ipAddress)) { throw new System.FormatException("Invalid IP address"); }
                if (!Sylloge.Net.IPv4.IsValidIp(subnetMask)) { throw new System.FormatException("Invalid subnet mask"); }
                string[] curip = ipAddress.Split('.');
                string[] curmsk = subnetMask.Split('.');
                string[] bcast = { "", "", "", "" };
                for (int count = 0; count < 3; count++) {
                    int bs = (int)(System.Convert.ToInt32(curip[count]) | (int)(System.Convert.ToInt32(curmsk[count]) ^ 255));
                    bcast[count] = bs.ToString();
                }
                return string.Format("{0}.{1}.{2}.{3}", bcast[0], bcast[1], bcast[2], bcast[3]);
            }

            public static bool IsValidIp(string ipAddress)
            {
                System.Net.IPAddress o = new System.Net.IPAddress(0);
                if (!System.Net.IPAddress.TryParse(ipAddress, out o)) { return false; }
                return o.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork;
            }
        }

        public class IpHeader
        {
            public delegate void IpErrorEventHandler(string message);
            public event IpErrorEventHandler IpError;

            public enum IpProtocol
            {
                TCP = 6,
                UDP = 17,
                UNKNOWN = -1
            }

            #region Properties

            //IP Header fields
            // Eight bits for version and header length
            private byte _VersionAndHeaderLength;
            // Eight bits for differentiated services (TOS)
            private byte _DifferentiatedServices;
            // Sixteen bits for total length of the datagram (header + message)
            private ushort _TotalLength;
            // Sixteen bits for identification
            private ushort _Identification;
            // Eight bits for flags and fragmentation offset
            private ushort _FlagsAndOffset;
            // Eight bits for TTL (Time To Live)
            private byte _TTL;
            // Eight bits for the underlying protocol
            private byte _Protocol;
            // Sixteen bits containing the checksum of the header, (checksum can be negative so taken as short)
            private short _Checksum;
            // Thirty two bit source IP Address
            private uint _SourceIpAddress;
            // Thirty two bit destination IP Address
            private uint _DestinationIpAddress;
            //End IP Header fields
            // Header length
            private byte _HeaderLength;
            // Data carried by the datagram
            private byte[] _IpData = new byte[4097];

            #endregion

            public IpHeader(byte[] data, int length)
            {
                try {
                    // Create MemoryStream out of the received bytes
                    System.IO.MemoryStream MemoryStream = new System.IO.MemoryStream(data, 0, length);
                    // Next we create a BinaryReader out of the MemoryStream
                    System.IO.BinaryReader BinaryReader = new System.IO.BinaryReader(MemoryStream);
                    // The first eight bits of the IP header contain the version and header length so we read them
                    this._VersionAndHeaderLength = BinaryReader.ReadByte();
                    // The next eight bits contain the Differentiated services
                    this._DifferentiatedServices = BinaryReader.ReadByte();
                    // Next eight bits hold the total length of the datagram
                    this._TotalLength = System.Convert.ToUInt16(System.Net.IPAddress.NetworkToHostOrder(BinaryReader.ReadInt16()));
                    // Next sixteen have the identification bytes
                    this._Identification = System.Convert.ToUInt16(System.Net.IPAddress.NetworkToHostOrder(BinaryReader.ReadInt16()));
                    // Next sixteen bits contain the flags and fragmentation offset
                    this._FlagsAndOffset = System.Convert.ToUInt16(System.Net.IPAddress.NetworkToHostOrder(BinaryReader.ReadInt16()));
                    // Next eight bits have the TTL value
                    this._TTL = BinaryReader.ReadByte();
                    // Next eight represnts the protocol encapsulated in the datagram
                    this._Protocol = BinaryReader.ReadByte();
                    // Next sixteen bits contain the checksum of the header
                    this._Checksum = System.Convert.ToInt16(System.Net.IPAddress.NetworkToHostOrder(BinaryReader.ReadInt16()));
                    // Next thirty two bits have the source IP address
                    this._SourceIpAddress = System.Convert.ToUInt32(BinaryReader.ReadUInt32());
                    // Next thirty two hold the destination IP address
                    this._DestinationIpAddress = System.Convert.ToUInt32(BinaryReader.ReadUInt32());
                    // Now we calculate the header length
                    this._HeaderLength = this._VersionAndHeaderLength;
                    // The last four bits of the version and header length field contain the
                    // header length, we perform some simple binary airthmatic operations to
                    // extract them
                    this._HeaderLength <<= 4;
                    this._HeaderLength >>= 4;
                    // Multiply by four to get the exact header length
                    this._HeaderLength = System.Convert.ToByte(this._HeaderLength * 4);
                    // Copy the data carried by the data gram into another array so that
                    // according to the protocol being carried in the IP datagram
                    System.Array.Copy(data, this._HeaderLength, this._IpData, 0, this._TotalLength - this._HeaderLength);
                } catch (System.Exception ex) {
                    if (IpError != null) {
                        IpError(ex.ToString());
                    }
                }
            }

            public string Version
            {
                get
                {
                    switch ((this._VersionAndHeaderLength >> 4)) {
                        case 4:
                            return "IP v4";
                        case 6:
                            return "IP v6";
                        default:
                            return "Unknown";
                    }
                }
            }

            public string HeaderLength
            {
                get { return this._HeaderLength.ToString(); }
            }

            public ushort MessageLength
            {
                // MessageLength = Total length of the datagram - Header length
                get { return System.Convert.ToUInt16(this._TotalLength - this._HeaderLength); }
            }

            public string DifferentiatedServices
            {
                get { return string.Format("0x{0:x2} ({1})", this._DifferentiatedServices, this._DifferentiatedServices); }
            }

            public string Flags
            {
                get
                {
                    // The first three bits of the flags and fragmentation field 
                    //    represent the flags (which indicate whether the data is 
                    //    fragmented or not)
                    int ReceivedFlags = this._FlagsAndOffset >> 13;
                    switch (ReceivedFlags) {
                        case 2:
                            return "Don't Fragment";
                        case 1:
                            return "More Fragments To Come";
                        default:
                            return ReceivedFlags.ToString();
                    }
                }
            }

            public string FragmentationOffset
            {
                get
                {
                    // The last thirteen bits of the flags and fragmentation field 
                    //    contain the fragmentation offset
                    int Offset = this._FlagsAndOffset << 3;
                    Offset >>= 3;
                    return Offset.ToString();
                }
            }

            public string TTL
            {
                get { return System.Convert.ToString(this._TTL); }
            }

            public IpProtocol ProtocolType
            {
                get
                {
                    // The protocol field represents the protocol in the data portion
                    //    of the datagram
                    switch (System.Convert.ToInt32(this._Protocol)) {
                        case 6:
                            return IpProtocol.TCP;
                        case 17:
                            return IpProtocol.UDP;
                        default:
                            return IpProtocol.UNKNOWN;
                    }
                }
            }

            public string Checksum
            {
                get { return string.Format("0x{0:x2}", this._Checksum); }
            }

            public System.Net.IPAddress SourceIpAddress
            {
                get { return new System.Net.IPAddress(this._SourceIpAddress); }
            }

            public System.Net.IPAddress DestinationIpAddress
            {
                get { return new System.Net.IPAddress(this._DestinationIpAddress); }
            }

            public string TotalLength
            {
                get { return this._TotalLength.ToString(); }
            }

            public string Identification
            {
                get { return this._Identification.ToString(); }
            }

            public byte[] Data
            {
                get { return this._IpData; }
            }
        }

        public class UdpHeader
        {
            #region UDP Header fields

            // Sixteen bits for the source port number        
            private ushort _SourcePort;
            // Sixteen bits for the destination port number
            private ushort _DestinationPort;
            // Length of the UDP header
            private ushort _Length;
            // Sixteen bits for the checksum (checksum can be negative so taken as short)              
            private ushort _Checksum;
            // End UDP header fields
            // Data carried by the UDP packet
            private byte[] _UdpData = new byte[4097];

            #endregion

            public UdpHeader(byte[] data, int length)
            {
                System.IO.MemoryStream MemoryStream = new System.IO.MemoryStream(data, 0, length);
                System.IO.BinaryReader BinaryReader = new System.IO.BinaryReader(MemoryStream);
                // The first sixteen bits contain the source port
                this._SourcePort = System.Convert.ToUInt16(System.Net.IPAddress.NetworkToHostOrder(BinaryReader.ReadInt16()));
                // The next sixteen bits contain the destination port
                this._DestinationPort = System.Convert.ToUInt16(System.Net.IPAddress.NetworkToHostOrder(BinaryReader.ReadInt16()));
                // The next sixteen bits contain the length of the UDP packet
                this._Length = System.Convert.ToUInt16(System.Net.IPAddress.NetworkToHostOrder(BinaryReader.ReadInt16()));
                // The next sixteen bits contain the checksum
                this._Checksum = System.Convert.ToUInt16(System.Net.IPAddress.NetworkToHostOrder(BinaryReader.ReadInt16()));
                // Copy the data carried by the UDP packet into the data buffer
                // The UDP header is of 8 bytes so we start copying after it
                System.Array.Copy(data, 8, this._UdpData, 0, length - 8);
            }

            public string Checksum
            {
                get { return string.Format("0x{0:x2}", this._Checksum); }
            }

            public string DestinationPort
            {
                get { return this._DestinationPort.ToString(); }
            }

            public string Length
            {
                get { return this._Length.ToString(); }
            }

            public string SourcePort
            {
                get { return this._SourcePort.ToString(); }
            }

            public byte[] UdpData
            {
                get { return this._UdpData; }
            }
        }

        public class TcpHeader
        {
            public delegate void TcpErrorEventHandler(string message);
            public event TcpErrorEventHandler TcpError;

            #region Properties

            // TCP header fields
            // Sixteen bits for the source port number
            private ushort _SourcePort;
            // Sixteen bits for the destination port number
            private ushort _DestinationPort;
            // Thirty two bits for the sequence number
            private uint _SequenceNumber = 555;
            // Thirty two bits for the acknowledgement number
            private uint _AcknowledgementNumber = 555;
            // Sixteen bits for flags and data offset
            private ushort _DataOffsetAndFlags = 555;
            // Sixteen bits for the window size
            private ushort _Window = 555;
            // Sixteen bits for the checksum (checksum can be negative so taken as short)
            private short _Checksum = 555;
            // Sixteen bits for the urgent pointer
            private ushort _UrgentPointer;
            // End TCP header fields
            // Header length
            private byte _HeaderLength;
            // Length of the data being carried
            private ushort _MessageLength;
            // Data carried by the TCP packet
            private byte[] _TcpData = new byte[4097];

            #endregion

            public TcpHeader(byte[] data, int length)
            {
                try {
                    // Create MemoryStream out of the received bytes
                    System.IO.MemoryStream MemoryStream = new System.IO.MemoryStream(data, 0, length);
                    // Next we create a BinaryReader out of the MemoryStream
                    System.IO.BinaryReader BinaryReader = new System.IO.BinaryReader(MemoryStream);
                    // The first sixteen bits contain the source port
                    this._SourcePort = System.Convert.ToUInt16(System.Net.IPAddress.NetworkToHostOrder(BinaryReader.ReadInt16()));
                    // The next sixteen contain the destiination port
                    this._DestinationPort = System.Convert.ToUInt16(System.Net.IPAddress.NetworkToHostOrder(BinaryReader.ReadInt16()));
                    // Next thirty two have the sequence number
                    this._SequenceNumber = System.Convert.ToUInt32(System.Net.IPAddress.NetworkToHostOrder(BinaryReader.ReadInt32()));
                    // Next thirty two have the acknowledgement number
                    this._AcknowledgementNumber = System.Convert.ToUInt32(System.Net.IPAddress.NetworkToHostOrder(BinaryReader.ReadInt32()));
                    // The next sixteen bits hold the flags and the data offset
                    this._DataOffsetAndFlags = System.Convert.ToUInt16(System.Net.IPAddress.NetworkToHostOrder(BinaryReader.ReadInt16()));
                    // The next sixteen contain the window size
                    this._Window = System.Convert.ToUInt16(System.Net.IPAddress.NetworkToHostOrder(BinaryReader.ReadInt16()));
                    // In the next sixteen we have the checksum
                    this._Checksum = System.Convert.ToInt16(System.Net.IPAddress.NetworkToHostOrder(BinaryReader.ReadInt16()));
                    // The following sixteen contain the urgent pointer
                    this._UrgentPointer = System.Convert.ToUInt16(System.Net.IPAddress.NetworkToHostOrder(BinaryReader.ReadInt16()));
                    // The data offset indicates where the data begins, so using it we
                    // calculate the header length
                    this._HeaderLength = System.Convert.ToByte(this._DataOffsetAndFlags >> 12);
                    this._HeaderLength = System.Convert.ToByte(this._HeaderLength * 4);
                    // Message length = Total length of the TCP packet - Header length
                    this._MessageLength = System.Convert.ToUInt16(length - this._HeaderLength);
                    // Copy the TCP data into the data buffer
                    System.Array.Copy(data, this._HeaderLength, this._TcpData, 0, length - this._HeaderLength);
                } catch (System.Exception ex) {
                    if (TcpError != null) {
                        TcpError(ex.Message);
                    }
                }
            }

            public string SourcePort
            {
                get { return this._SourcePort.ToString(); }
            }

            public string DestinationPort
            {
                get { return this._DestinationPort.ToString(); }
            }

            public string SequenceNumber
            {
                get { return this._SequenceNumber.ToString(); }
            }

            public string AcknowledgementNumber
            {
                get
                {
                    // If the ACK flag is set then only we have a valid value in
                    //    the acknowlegement field, so check for it beore returning anything
                    if ((this._DataOffsetAndFlags & 0x10) != 0) {
                        return this._AcknowledgementNumber.ToString();
                    } else {
                        return string.Empty;
                    }
                }
            }

            public string DataOffsetAndFlags
            {
                get { return this._DataOffsetAndFlags.ToString(); }
            }

            public string Window
            {
                get { return this._Window.ToString(); }
            }

            public string Checksum
            {
                get { return string.Format("0x{0:x2}", this._Checksum); }
            }

            public string UrgentPointer
            {
                get
                {
                    if ((this._DataOffsetAndFlags & 0x20) != 0) {
                        return this._UrgentPointer.ToString();
                    } else {
                        return string.Empty;
                    }
                }
            }

            public string Flags
            {
                get
                {
                    // The last six bits of the data offset and flags contain the control bits
                    // First we extract the flags
                    int CurrentFlags = (this._DataOffsetAndFlags & 0x3f);
                    string Value = string.Format("0x{0:x2} (", CurrentFlags);
                    // Now we start looking whether individual bits are set or not
                    if ((CurrentFlags & 0x1) != 0) {
                        Value += "FIN, ";
                    }
                    if ((CurrentFlags & 0x2) != 0) {
                        Value += "SYN, ";
                    }
                    if ((CurrentFlags & 0x4) != 0) {
                        Value += "RST, ";
                    }
                    if ((CurrentFlags & 0x8) != 0) {
                        Value += "PSH, ";
                    }
                    if ((CurrentFlags & 0x10) != 0) {
                        Value += "ACK, ";
                    }
                    if ((CurrentFlags & 0x20) != 0) {
                        Value += "URG";
                    }
                    Value += ")";
                    if ((Value.Contains("()"))) {
                        Value = Value.Remove(Value.Length - 3);
                    } else if ((Value.Contains(", )"))) {
                        Value = Value.Remove(Value.Length - 3, 2);
                    }
                    return Value;
                }
            }

            public string HeaderLength
            {
                get { return this._HeaderLength.ToString(); }
            }

            public ushort MessageLength
            {
                get { return this._MessageLength; }
            }

            public byte[] TcpData
            {
                get { return this._TcpData; }
            }
        }

        public class BroadcastListener
        {
            public enum ListenerType
            {
                BROADCAST_LISTENER,
                PACKET_SNIFFER
            }

            public enum ThreadErrorType
            {
                GENERAL,
                CANT_BIND,
                NO_PROMISC
            }

            #region Events

            public delegate void DelegateThreadError(ThreadErrorType errorType);
            public event DelegateThreadError ThreadError;
            public delegate void DelegateThreadReset();
            public event DelegateThreadReset ThreadReset;

            private void OnThreadError(ThreadErrorType errorType)
            {
                if (ThreadError != null) { ThreadError(errorType); }
            }

            private void OnThreadReset()
            {
                if (ThreadReset != null) { ThreadReset(); }
            }

            #endregion

            #region Local Attributes

            public System.Net.Sockets.Socket BroadcastSocket { get; private set; }
            public string IpAddressToListenfor { get; set; }
            public string IpAddressToListenOn { get; set; }
            public bool IsRunning { get; private set; }
            public System.Threading.Thread ListenThread { get; private set; }
            public byte[] ReceiveBuffer { get; private set; }

            private Sylloge.Net.BroadcastListener.ListenerType m_Type { get; set; }

            #endregion

            #region Class Mehtods and Properties

            public BroadcastListener(Sylloge.Net.BroadcastListener.ListenerType type)
            {
                this.m_Type = type;
            }

            public void Close()
            {
                this.IsRunning = false;
                if (this.BroadcastSocket != null) {
                    try {
                        this.BroadcastSocket.Close();
                    } catch (System.Exception ex) {
                        System.Console.WriteLine(ex.Message);
                    }
                }
                if (this.ListenThread != null) {
                    try {
                        this.ListenThread.Abort();
                    } catch (System.Exception ex) {
                        System.Console.WriteLine(ex.Message);
                    }
                }
            }

            private void ListenBroadcast()
            {
                try {
                    System.Net.IPAddress IpAddress = new System.Net.IPAddress(0);
                    System.Net.IPAddress.TryParse(this.IpAddressToListenOn, out IpAddress);
                    System.Net.IPEndPoint BindEndPoint = new System.Net.IPEndPoint(IpAddress, 0);
                    this.BroadcastSocket = new System.Net.Sockets.Socket(System.Net.Sockets.AddressFamily.InterNetwork, System.Net.Sockets.SocketType.Raw, System.Net.Sockets.ProtocolType.IP);
                    try {
                        this.BroadcastSocket.Bind(BindEndPoint);
                    } catch (System.Exception ex) {
                        System.Console.WriteLine("Broadcast error: " + ex.Message);
                        this.OnThreadError(ThreadErrorType.CANT_BIND);
                        return;
                    }
                    this.BroadcastSocket.SetSocketOption(System.Net.Sockets.SocketOptionLevel.IP, System.Net.Sockets.SocketOptionName.HeaderIncluded, true);
                    byte[] OptionCaptureAllPackets = { 1, 0, 0, 0 }; // Capture all packets 
                    byte[] OptionTrue = { 1, 0, 0, 0 }; // True
                    try {
                        this.BroadcastSocket.IOControl(System.Net.Sockets.IOControlCode.ReceiveAll, OptionTrue, OptionCaptureAllPackets);
                    } catch (System.Exception ex) {
                        // Here are a couple reasons for the exception here
                        // 1.) The user running is NOT an admin on the machine
                        // 2.) The interface can not be put into promiscuous mode
                        System.Console.WriteLine(ex.Message);
                        this.OnThreadError(ThreadErrorType.NO_PROMISC);
                        return;
                    }
                    this.BroadcastSocket.BeginReceive(this.ReceiveBuffer, 0, this.ReceiveBuffer.Length, System.Net.Sockets.SocketFlags.None, new System.AsyncCallback(this.OnReceiveData), null);
                } catch (System.Exception ex) {
                    System.Console.WriteLine("Broadcast error: " + ex.Message);
                    this.OnThreadError(ThreadErrorType.GENERAL);
                }
            }

            private void OnReceiveData(System.IAsyncResult ia)
            {
                int BytesReceived = 0;
                try {
                    BytesReceived = this.BroadcastSocket.EndReceive(ia);
                } catch (System.Exception ex) { // Silent catch here
                    System.Console.WriteLine(ex.Message);
                }
                this.ParseReceivedData(this.ReceiveBuffer, BytesReceived);
                if (this.IsRunning) {
                    this.ReceiveBuffer = new byte[4096];
                    this.BroadcastSocket.BeginReceive(
                        this.ReceiveBuffer, 
                        0, 
                        this.ReceiveBuffer.Length, 
                        System.Net.Sockets.SocketFlags.None,
                        new System.AsyncCallback(this.OnReceiveData), 
                        null
                    );
                }
            }

            private void ParseReceivedData(byte[] data, int length)
            {
                // Since all protocol packets are encapsulated in the IP datagram, we start by
                //    parsing the IP header and see what protocol data is being carried by it
                IpHeader IpHeader = new Sylloge.Net.IpHeader(data, length);
                if (IpHeader.DestinationIpAddress.ToString() == this.IpAddressToListenfor) {
                    System.Net.Sockets.Socket ResponseSocket = new System.Net.Sockets.Socket(System.Net.Sockets.AddressFamily.InterNetwork, System.Net.Sockets.SocketType.Raw, System.Net.Sockets.ProtocolType.Icmp);
                    System.Net.IPEndPoint RemoteEndPoint = new System.Net.IPEndPoint(IpHeader.SourceIpAddress, 0);
                    System.Net.IPEndPoint LocalEndPoint = new System.Net.IPEndPoint(System.Net.IPAddress.Parse(this.IpAddressToListenOn), 0);
                    ResponseSocket.Bind(LocalEndPoint);
                    // For a proper reply, the response MUST be the same exact data
                    ResponseSocket.SendTo(data, System.Net.Sockets.SocketFlags.None, RemoteEndPoint);
                    ResponseSocket.Close();
                    ResponseSocket = null;
                }
                if (this.m_Type == ListenerType.PACKET_SNIFFER) {
                    // DEV_NOTE: We could use this as a packet sniffer, uncomment the below lines and grab the info from the headers
                    // Connection.TcpHeader TcpHeader = null;
                    // Connection.UdpHeader UdpHeader = null;
                    // switch (IpHeader.ProtocolType) {
                    //    case Connection.IpHeader.enumProtocol.TCP:
                    //       TcpHeader = new TcpHeader(IpHeader.Data, Convert.ToInt32(IpHeader.MessageLength));
                    //       break;
                    //    case Connection.IpHeader.enumProtocol.UDP:
                    //       UdpHeader = new UdpHeader(IpHeader.Data, Convert.ToInt32(IpHeader.MessageLength));
                    //       break;
                    //    case Connection.IpHeader.enumProtocol.UNKNOWN:
                    //       break;
                    // }
                }                
            }

            public void Start(string ipToListenOn, string broadcastAddress)
            {
                this.IpAddressToListenOn = ipToListenOn;
                this.IpAddressToListenfor = broadcastAddress;
                // Regular and Special both use the same listen thread address
                System.Threading.ThreadStart StartAddress = new System.Threading.ThreadStart(this.ListenBroadcast);
                this.ListenThread = new System.Threading.Thread(StartAddress);
                this.ListenThread.Start();
                this.IsRunning = true;
            }

            #endregion
        }

        #region Static Members

        public static bool IsHostUp(string ipAddress)
        {
            System.Net.NetworkInformation.PingReply Reply = Sylloge.Net.Ping(ipAddress);
            if (Reply == null || Reply.Status != System.Net.NetworkInformation.IPStatus.Success) { return false; }
            return true;
        }

        public static System.Net.NetworkInformation.PingReply Ping(string ipAddress, System.Net.NetworkInformation.PingCompletedEventHandler pceh = null)
        {
            try {
                System.Net.NetworkInformation.Ping Ping = new System.Net.NetworkInformation.Ping();
                if (pceh != null) { Ping.PingCompleted += pceh; }
                System.Net.IPAddress o = new System.Net.IPAddress(0);
                System.Net.IPAddress.TryParse(ipAddress, out o);
                return Ping.Send(o);
            } catch (System.Exception ex) {
                System.Console.WriteLine("Error while pinging: " + ex.Message);
            }
            return null;
        }

        public static void SendUdp(string ipAddress, int port, byte[] data)
        {
            try {
                System.Net.Sockets.UdpClient Client = new System.Net.Sockets.UdpClient(port, System.Net.Sockets.AddressFamily.InterNetwork);
                System.Net.IPAddress IPAddress = new System.Net.IPAddress(0);
                System.Net.IPAddress.TryParse(ipAddress, out IPAddress);
                Client.Connect(IPAddress, port);
                Client.Send(data, data.Length);
                Client.Close();
            } catch (System.Exception ex) {
                System.Console.WriteLine("Error sending UDP: " + ex.Message);
            }
        }

        public static void SendTcp(string ipAddress, int port, byte[] data)
        {
            try {
                System.Net.IPAddress IPAddress = new System.Net.IPAddress(0);
                System.Net.IPAddress.TryParse(ipAddress, out IPAddress);
                try {
                    System.Net.Sockets.TcpClient TcpClient = new System.Net.Sockets.TcpClient();
                    TcpClient.Connect(IPAddress, port);
                    if (TcpClient != null && TcpClient.Connected) {
                        System.Net.Sockets.NetworkStream Stream = TcpClient.GetStream();
                        Stream.Write(data, 0, data.Length);
                        Stream.Close();
                        TcpClient.Close();
                    }
                } catch (System.Exception ex) {
                    System.Console.WriteLine("Error connecting: " + ex.Message);
                    return;
                }
            } catch (System.Exception ex) {
                System.Console.WriteLine("Error connecting: " + ex.Message);
                return;
            }
        }

        #endregion
    }
}