public static void ValidateListenIPAddress(IPAddress address)
{
if ((address != null) && (((address.Equals(IPAddress.Any) || address.Equals(IPAddress.IPv6Any)) || (address.Equals(IPAddress.IPv6None) || address.Equals(IPAddress.None))) || ((address.Equals(IPAddress.Broadcast) || address.IsIPv6Multicast) || IPAddress.IsLoopback(address))))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(System.ServiceModel.SR.GetString("PeerListenIPAddressInvalid", new object[] { address }), "address", null));
}
}
public static IPAddress GetMatchingLocalIP(IPAddress clientAddr)
{
if (clientAddr.Equals(IPAddress.Any) ||
clientAddr.Equals(IPAddress.Loopback))
{
return IPAddress.Loopback;
}
var clientBytes = clientAddr.GetAddressBytes();
// find an address that matches the most significant n-1 bytes of the address of the connecting client
foreach (var addr in CachedHostEntry.AddressList)
{
var bytes = addr.GetAddressBytes();
if (bytes.Length != clientBytes.Length) continue;
var match = true;
for (var i = bytes.Length-2; i >= 0; i--)
{
if (bytes[i] != clientBytes[i])
{
match = false;
break;
}
}
if (match) return addr;
}
return null;
}
private void ReceivePacketListener(IAsyncResult result)
{
try
{
int received = socket.EndReceive(result);
if (received > 20)
{
// Decode the packet if it is UDP
byte protocol = buffer[9];
if (protocol == 0x11)
{
// Source (offset=12)
byte[] srcBytes = new byte[4];
Array.Copy(buffer, 12, srcBytes, 0, srcBytes.Length);
IPAddress sourceIP = new System.Net.IPAddress(srcBytes);
// Destination (offset=16)
byte[] destBytes = new byte[4];
Array.Copy(buffer, 16, destBytes, 0, destBytes.Length);
IPAddress destIP = new System.Net.IPAddress(destBytes);
// Source port (offset=20)
int srcPort = (int)buffer[20] << 8 | (int)buffer[21];
// Destination port (offset=22)
int destPort = (int)buffer[22] << 8 | (int)buffer[23];
// Inbound traffic
if (!sourceIP.Equals(adapterIP) && destIP.Equals(adapterIP))
{
if (destPort >= AppSettings.Default.setNetLowPort &&
destPort <= AppSettings.Default.setNetHighPort)
{
RecordRxData(sourceIP, received);
}
}
// Outbound traffic
else if (sourceIP.Equals(adapterIP) && !destIP.Equals(adapterIP))
{
if (srcPort >= AppSettings.Default.setNetLowPort &&
srcPort <= AppSettings.Default.setNetHighPort)
{
RecordTxData(destIP, received);
}
}
}
}
}
catch { }
try
{
if (isActive)
{
socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(this.ReceivePacketListener), null);
}
}
catch { }
}
// outgoing
internal UdpTransport(IPAddress address, int port, ulong connectionType)
{
if (address.Equals (IPAddress.Any) || address.Equals (IPAddress.None) || port == 0)
throw new Exception ("Invalid IP Address/Port");
this.remoteEndPoint = new IPEndPoint (address, port);
base.connectionType = connectionType;
base.incoming = false;
base.transportState = TransportState.Waiting;
}
// End of added code
private void connectButton_Click(object sender, EventArgs e)
{
if (IpAdressTextBox.Text != null && IpAdressTextBox.Text != "")
{
((MainWindow)(this.Owner)).logWindow.Message = ((MainWindow)(this.Owner)).logMessagesHashTable["logMessage_searchingByIpAttemptingToConnect"].ToString();
this.Cursor = Cursors.WaitCursor;
Communication.CardID = 255;
System.Net.IPAddress testedIP = System.Net.IPAddress.Parse("0.0.0.0");
AvailableSocket tmp = NetworkCommunication.TestGivenSocket(IpAdressTextBox.Text);
if (testedIP.Equals(tmp.Ip))
{
((MainWindow)(this.Owner)).logWindow.Message = ((MainWindow)(this.Owner)).logMessagesHashTable["logMessage_searchingByIpUnableToConnect"].ToString();
//MessageBox.Show("The screen was not found via network connection.\nProbably given IP was misstyped.", "BengiLED - Connection Failure", MessageBoxButtons.OK, MessageBoxIcon.Information);
found = false;
}
else
{
NetworkCommunication.SocketsList.Add(tmp);
((MainWindow)(this.Owner)).logWindow.Message = string.Format("{0} {1}", ((MainWindow)(this.Owner)).logMessagesHashTable["logMessage_searchingByIpFoundIpIs"].ToString(), NetworkCommunication.SocketsList[0].Ip);
//MessageBox.Show(string.Format("The screen was found via network connection. IP is {0}", NetworkCommunication.SocketsList[0].Ip), "BengiLED - Connection Succes", MessageBoxButtons.OK, MessageBoxIcon.Information);
found = true;
this.Close();
}
this.Cursor = Cursors.Default;
}
}
public bool TestDefaultIP()
{
string defaultIP = ((MainWindow)this.Owner).ConfigHashtable["CurrentIP"].ToString();
Communication.Type = CommunicationType.Network;
System.Net.IPAddress testedIP = System.Net.IPAddress.Parse("0.0.0.0");
AvailableSocket tmp = NetworkCommunication.TestGivenSocket(defaultIP);
if (testedIP.Equals(tmp.Ip))
{
((MainWindow)(this.Owner)).logWindow.Message = ((MainWindow)(this.Owner)).logMessagesHashTable["logMessage_searchingByIpDefaultNotFound"].ToString();
//MessageBox.Show("The screen was not found via network default IP address.", "BengiLED - Connection Failure", MessageBoxButtons.OK, MessageBoxIcon.Information);
Communication.Type = CommunicationType.None;
return(false);
}
else
{
NetworkCommunication.SocketsList.Add(tmp);
((MainWindow)(this.Owner)).logWindow.Message = string.Format("{0} {1}", ((MainWindow)(this.Owner)).logMessagesHashTable["logMessage_searchingByIpFoundIpIsDefault"].ToString(), NetworkCommunication.SocketsList[0].Ip);
//MessageBox.Show(string.Format("The screen was found via network connection. IP is default {0}", NetworkCommunication.SocketsList[0].Ip), "BengiLED - Connection Succes", MessageBoxButtons.OK, MessageBoxIcon.Information);
return(true);
}
}
public override string ToString()
{
if (IsNull(this.from_) || IsNull(this.to_) || from_.Equals(to_))
{
return(From.ToString());
}
return(string.Format("{0}-{1}", From, To));
}
public bool IsOnIntranet(IPAddress ipAddress)
{
if (empty.Equals(ipAddress))
{
return false;
}
bool onIntranet = IPAddress.IsLoopback(ipAddress);
onIntranet = onIntranet ||
ipAddress.Equals(And(ipAddress,intranetMask1)); //10.255.255.255
onIntranet = onIntranet ||
ipAddress.Equals(And(ipAddress,intranetMask4)); ////192.168.255.255
onIntranet = onIntranet || (intranetMask2.Equals(And(ipAddress,intranetMask2))
&& ipAddress.Equals(And(ipAddress,intranetMask3)));
return onIntranet;
}
/// <summary>
/// Sends a ping using IcmpSendEcho2Ex function in Iphlpapi.dll. Use this method when you need to specify a source
/// interface for a ping otherwise use .NET ping implementation.
/// </summary>
/// <param name="srcAddress">The IPv4 source address on which to issue the echo request.</param>
/// <param name="destAddress">The IPv4 destination of the echo request.</param>
/// <param name="timeout">The time, in milliseconds, to wait for replies.</param>
/// <param name="buffer">A buffer that contains data to send in the request.</param>
/// <param name="po">IP header options for the request.</param>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="FormatException">When the destination address is no valid IpV4 address or not defining a specific IP.</exception>
public static PingReply SendPing(IPAddress srcAddress, IPAddress destAddress, int timeout = 5000, byte[] buffer = null, PingOptions po = null)
{
if (destAddress == null)
throw new ArgumentNullException("destAddress");
if (destAddress.AddressFamily != AddressFamily.InterNetwork || srcAddress.AddressFamily != AddressFamily.InterNetwork || destAddress.Equals(IPAddress.Any))
throw new FormatException();
//Defining p invoke arguments.
var source = srcAddress == null ? 0 : BitConverter.ToUInt32(srcAddress.GetAddressBytes(), 0);
var destination = BitConverter.ToUInt32(destAddress.GetAddressBytes(), 0);
var sendbuffer = buffer ?? new byte[] {};
var options = new Interop.Option
{
Ttl = (po == null ? (byte) 255 : (byte) po.Ttl),
Flags = (po == null ? (byte) 0 : po.DontFragment ? (byte) 0x02 : (byte) 0) //0x02
};
var fullReplyBufferSize = Interop.ReplyMarshalLength + sendbuffer.Length; //Size of Reply structure plus the transmitted buffer length.
var allocSpace = Marshal.AllocHGlobal(fullReplyBufferSize); // unmanaged allocation of reply size. TODO Maybe should be allocated on stack
try
{
DateTime start = DateTime.Now;
var nativeCode = Interop.IcmpSendEcho2Ex(
Interop.IcmpHandle, //_In_ HANDLE IcmpHandle,
default(IntPtr), //_In_opt_ HANDLE Event,
default(IntPtr), //_In_opt_ PIO_APC_ROUTINE ApcRoutine,
default(IntPtr), //_In_opt_ PVOID ApcContext
source, //_In_ IPAddr SourceAddress,
destination, //_In_ IPAddr DestinationAddress,
sendbuffer, //_In_ LPVOID RequestData,
(short) sendbuffer.Length, //_In_ WORD RequestSize,
ref options, //_In_opt_ PIP_OPTION_INFORMATION RequestOptions,
allocSpace, //_Out_ LPVOID ReplyBuffer,
fullReplyBufferSize, //_In_ DWORD ReplySize,
timeout //_In_ DWORD Timeout
);
TimeSpan duration = DateTime.Now - start;
var reply = (Interop.Reply) Marshal.PtrToStructure(allocSpace, typeof (Interop.Reply)); // Parse the beginning of reply memory to reply structure
byte[] replyBuffer = null;
if (sendbuffer.Length != 0)
{
replyBuffer = new byte[sendbuffer.Length];
Marshal.Copy(allocSpace + Interop.ReplyMarshalLength, replyBuffer, 0, sendbuffer.Length); //copy the rest of the reply memory to managed byte[]
}
if (nativeCode == 0) //Means that native method is faulted.
return new PingReply(nativeCode, reply.Status, new IPAddress(reply.Address), duration);
else
return new PingReply(nativeCode, reply.Status, new IPAddress(reply.Address), reply.RoundTripTime, replyBuffer);
}
finally
{
Marshal.FreeHGlobal(allocSpace); //free allocated space
}
}
public static bool SocketBlock = true; // true to block at connection, false to block at login request
#endregion Fields
#region Methods
public static bool IsExempt( IPAddress ip )
{
for ( int i = 0; i < Exemptions.Length; i++ )
{
if ( ip.Equals( Exemptions[i] ) )
return true;
}
return false;
}
/// <summary>
/// Returns the IPv4 subnet mask of the network interface with the given IPv4 address.
/// </summary>
public static IPAddress GetSubnetMask(IPAddress address)
{
foreach (NetworkInterface adapter in NetworkInterface.GetAllNetworkInterfaces()) {
foreach (UnicastIPAddressInformation unicastIPAddressInformation in adapter.GetIPProperties().UnicastAddresses) {
if (unicastIPAddressInformation.Address.AddressFamily == AddressFamily.InterNetwork) {
if (address.Equals (unicastIPAddressInformation.Address)) {
return unicastIPAddressInformation.IPv4Mask;
}
}
}
}
throw new ArgumentException ("Network interface with IPv4 address " + address + " does not exist.");
}
//functions
public static ArrayList calcAddressesSE(IPAddress start, IPAddress end, ProgressBar progress)
{
ArrayList addresses = new ArrayList();
addresses.Add(start);
if (start.Equals(end))return addresses;
UInt32 h = 0;
if (progress != null)
{
progress.Value = 0;
progress.Maximum = (int)(convertIPtoUInt32(end) - convertIPtoUInt32(start));
Log.WriteLog("Progressbar Maximum (clacAddressesSE): " + progress.Maximum);
}
while (!(start.Equals(end)))
{
h = convertIPtoUInt32(start);
h++;
if (progress != null) progress.PerformStep();
start = IPAddress.Parse(Convert.ToString(h));
addresses.Add(start);
}
return addresses;
}
/// <summary>
/// Sends an ARP request to determine a mac address for a given IP address. Uses a stopwatch to count the time for
/// the request, so duration may be inaccurate. Creates a new thread to use cancellation.
/// </summary>
/// <param name="destIp">The address of the requested mac address.</param>
/// <param name="timeout">
/// Defines the timeout to wait for the ARP reply to receive. Protocols allows a maximum timeout
/// around 3000 ms
/// </param>
/// <param name="srcIp">the address of the source interface from where the packet should be sent from.</param>
/// <param name="cancellationHandle">when cancellation handle is set packet is canceled immediately.</param>
public static ArpReply Send(IPAddress destIp, uint timeout = 0, IPAddress srcIp = null, WaitHandle cancellationHandle = null)
{
if (destIp == null)
throw new ArgumentNullException("destIp");
var macAddrBuffer = new byte[6];
var macAddrLength = (uint) macAddrBuffer.Length;
var srcAddress = srcIp == null ? 0 : (srcIp.Equals(IPAddress.Any) ? 0 : BitConverter.ToInt32(srcIp.GetAddressBytes(), 0));
var destAddress = BitConverter.ToInt32(destIp.GetAddressBytes(), 0);
uint nativeCode = 0;
var task = new Task(() => { nativeCode = Interop.SendARP(destAddress, srcAddress, macAddrBuffer, ref macAddrLength); }, TaskCreationOptions.LongRunning);
task.Start(TaskScheduler.Default);
var mre = (task as IAsyncResult).AsyncWaitHandle;
var wtch = Stopwatch.StartNew();
if (timeout != 0)
{
if (cancellationHandle != null)
{
int satisfyedArrayIndex = WaitHandle.WaitAny(new[] {mre, cancellationHandle}, (int) timeout);
if (satisfyedArrayIndex == WaitHandle.WaitTimeout)
nativeCode = (uint) ArpStatus.TimedOut;
else if (satisfyedArrayIndex == 1)
nativeCode = (uint) ArpStatus.Canceled;
}
else if (!mre.WaitOne((int) timeout))
nativeCode = (uint) ArpStatus.TimedOut;
}
else
mre.WaitOne();
wtch.Stop();
var duration = wtch.Elapsed;
if (nativeCode != 0)
return new ArpReply(nativeCode, duration);
var shortenedBytes = new byte[macAddrLength];
Array.Copy(macAddrBuffer, shortenedBytes, macAddrLength);
return new ArpReply(nativeCode, duration, shortenedBytes);
}
/// <summary>
/// 测试IP地址
/// </summary>
public static void Test6()
{
IPAddress a1 = new IPAddress(new byte[] { 101, 102, 103, 104 });
IPAddress a2 = IPAddress.Parse("101.102.103.104");
Console.WriteLine(a1.Equals(a2));
Console.WriteLine(a1.AddressFamily);
IPAddress a3 = IPAddress.Parse
("[3EA0:FFFF:198A:E4A3:4FF2:54fA:41BC:8D31]");
IPEndPoint ep = new IPEndPoint(a1, 222);
Console.WriteLine(a3.AddressFamily);
Console.WriteLine(ep.ToString());
}
public static bool IsLocalIpAddress(IPAddress hostIp)
{
// get local IP addresses
IPAddress[] localIPs = Dns.GetHostAddresses(Dns.GetHostName());
// is localhost
if (IPAddress.IsLoopback(hostIp)) return true;
// is local address
foreach (IPAddress localIp in localIPs)
{
if (hostIp.Equals(localIp)) return true;
}
return false;
}
public static void HandleOutgoing(byte[] data)
{
var packet = new PacketUDP(new MemoryStream(data));
var ip = new IPAddress(packet.ADDR);
var port = BitConverter.ToUInt16(packet.PORT, 0);
// THIS IS WHERE ALL THE MAGIC HAPPENS, BABY
// Loopback detection: If we're making a request to our external IP, route it!
// Note that we're rerouting regardless
if (ip.Equals(ExternalIP) && TargetPorts.Contains(port))
ip = (IPAddress)UDProxy.gConfiguration.Config["TargetIP"];
IPEndPoint destination = new IPEndPoint(ip, port);
TotalUp += MyUDP.Send(packet.DATA, packet.DATA.Length, destination);
}
public static System.Net.IPAddress GetSubnetMask(System.Net.IPAddress address)
{
foreach (NetworkInterface adapter in NetworkInterface.GetAllNetworkInterfaces())
{
foreach (UnicastIPAddressInformation unicastIPAddressInformation in adapter.GetIPProperties().UnicastAddresses)
{
if (unicastIPAddressInformation.Address.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
{
if (address.Equals(unicastIPAddressInformation.Address))
{
return(unicastIPAddressInformation.IPv4Mask);
}
}
}
}
throw new ArgumentException(string.Format("Can't find subnetmask for IP address '{0}'", address));
}
public static bool IsLoopback(IPAddress address)
{
if (address == null)
{
throw new ArgumentNullException(nameof(address));
}
if (address.IsIPv6)
{
// Do Equals test for IPv6 addresses
return(address.Equals(IPv6Loopback));
}
else
{
return((address.PrivateAddress & LoopbackMask) == (Loopback.PrivateAddress & LoopbackMask));
}
}
/// <summary>
/// Check if two ip are equal, using MapToIPv6 if needed
/// </summary>
/// <param name="ipAddress">IP address</param>
/// <param name="other">Other ip address</param>
/// <returns>True if ip are equal or equal, false otherwise</returns>
public static bool EqualsWithMapToIPv6(this System.Net.IPAddress ipAddress, System.Net.IPAddress other)
{
if (ipAddress.Equals(other))
{
return(true);
}
try
{
IPAddress ipv6 = (ipAddress.IsLocalHost() ? IPAddress.Parse("::1") : ipAddress.MapToIPv6());
IPAddress otherIPV6 = (other.IsLocalHost() ? IPAddress.Parse("::1") : other.MapToIPv6());
return(ipv6.Equals(otherIPV6));
}
catch
{
return(false);
}
}
/// <summary>
/// Determines whether the specified address is multicast.
/// </summary>
/// <param name="addr">The address.</param>
/// <returns>
/// <c>true</c> if the specified address is multicast; otherwise, <c>false</c>.
/// </returns>
public static bool IsMulticast(IPAddress addr)
{
// If this is IPv6 then our check is easy
if (addr.IsIPv6Multicast)
return true;
// Otherwise if we're IPv4 look for anything higher than 224.0.0.0
if (addr.AddressFamily == AddressFamily.InterNetwork)
{
// Special case for broadcast since it's above the multicast range
if (addr.Equals(IPAddress.Broadcast))
return false;
return ((addr.GetAddressBytes()[0] & 240) == 224);
}
return false;
}
public static IPAddress GetSubnetMask(IPAddress ip)
{
foreach (NetworkInterface adapter in NetworkInterface.GetAllNetworkInterfaces())
{
foreach (UnicastIPAddressInformation unicastIPAddressInformation in adapter.GetIPProperties().UnicastAddresses)
{
if (unicastIPAddressInformation.Address.AddressFamily == AddressFamily.InterNetwork)
{
if (ip.Equals(unicastIPAddressInformation.Address))
{
return unicastIPAddressInformation.IPv4Mask;
}
}
}
}
return null;
}
public static bool IsLoopback(IPAddress address)
{
if (address == null)
{
throw new ArgumentNullException("address");
}
if (address.m_Family == AddressFamily.InterNetworkV6)
{
//
// Do Equals test for IPv6 addresses
//
return(address.Equals(IPv6Loopback));
}
else
{
return((address.m_Address & IPAddress.LoopbackMask) == (IPAddress.Loopback.m_Address & IPAddress.LoopbackMask));
}
}
/// <summary>
/// Determines whether the current request is on localhost.
/// </summary>
/// <returns>
/// <c>true</c> if current request is localhost; otherwise, <c>false</c>.
/// </returns>
private static bool IsLocalhost()
{
bool localHost = false;
try
{
IPAddress address = IPAddress.Parse(HttpContext.Current.Request.UserHostAddress);
Debug.WriteLine("IP Address of user: "******"404Handler");
IPHostEntry host = Dns.GetHostEntry(Dns.GetHostName());
Debug.WriteLine("Host Entry of local computer: " + host.HostName, "404Handler");
localHost = address.Equals(IPAddress.Loopback) || (Array.IndexOf(host.AddressList, address) >= 0);
}
catch
{
// localhost is false
}
return(localHost);
}
public static bool Verify( IPAddress ourAddress, Account account )
{
if ( !Enabled )
return true;
int count = 0;
foreach ( var compState in GameServer.Instance.Clients )
{
if ( ourAddress.Equals( compState.Address ) && compState.Account != account )
{
++count;
if ( count > MaxAddresses )
return false;
}
}
return true;
}
// Borrowed from IPInterfaceProperties.cs
bool HasOnlyDefaultGateway (string iface)
{
int gwCount = 0;
int defaultGwCount = 0;
#if MONODROID
if (!File.Exists ("/proc/net/route"))
return false;
try {
using (StreamReader reader = new StreamReader ("/proc/net/route")) {
string line;
reader.ReadLine (); // Ignore first line
while ((line = reader.ReadLine ()) != null) {
line = line.Trim ();
if (line.Length == 0)
continue;
string [] parts = line.Split ('\t');
if (parts.Length < 3)
continue;
string gw_address = parts [2].Trim ();
byte [] ipbytes = new byte [4];
if (gw_address.Length == 8 && iface.Equals (parts [0], StringComparison.OrdinalIgnoreCase)) {
for (int i = 0; i < 4; i++) {
if (!Byte.TryParse (gw_address.Substring (i * 2, 2), NumberStyles.HexNumber, null, out ipbytes [3 - i]))
continue;
}
IPAddress ip = new IPAddress (ipbytes);
if (ip.Equals (IPAddress.Any))
defaultGwCount++;
else
gwCount++;
}
}
}
} catch {
}
#endif
return gwCount == 0 && defaultGwCount > 0;
}
public static bool IsLocalHost(IPAddress ip)
{
byte[] buff = ip.GetAddressBytes();
switch (buff[0])
{
case 192:
if (buff[1] == 168)
return true;
break;
case 127:
return true;
case 10:
if (buff[1] == 0)
return true;
break;
}
return ip.Equals(Settings.ExternalIP);
}
public static bool SocketBlock = true; // true to block at connection, false to block at login request
#endregion Fields
#region Methods
public static bool Verify( IPAddress ourAddress )
{
if ( !Enabled )
return true;
ArrayList netStates = NetState.Instances;
int count = 0;
for ( int i = 0; i < netStates.Count; ++i )
{
NetState compState = (NetState)netStates[i];
if ( ourAddress.Equals( compState.Address ) )
{
++count;
if ( count > MaxAddresses )
return false;
}
}
return true;
}
/// <summary>
/// IP 比對
/// </summary>
/// <param name="source"></param>
/// <param name="target"></param>
/// <returns></returns>
public static bool IPEquals(string source, string target)
{
string[] allIp = source.Split(',');
bool resultStatus = false;
foreach (string sourceIp in allIp)
{
string sIp = sourceIp.Trim();
string subNetMask = SubnetMask(sIp);
IPAddress nIpAddress = IPAddress.Parse(sIp.Replace('*', '1'));
IPAddress nSubnetMask = IPAddress.Parse(subNetMask);
IPAddress nNetworkAddress = new IPAddress(IPAddress.NetworkToHostOrder(IPAddress.HostToNetworkOrder(nIpAddress.Address) & IPAddress.HostToNetworkOrder(nSubnetMask.Address)));
IPAddress nIpAddress1 = IPAddress.Parse(target);
IPAddress nSubnetMask1 = IPAddress.Parse(subNetMask);
IPAddress nNetworkAddress1 = new IPAddress(IPAddress.NetworkToHostOrder(IPAddress.HostToNetworkOrder(nIpAddress1.Address) & IPAddress.HostToNetworkOrder(nSubnetMask1.Address)));
resultStatus = nNetworkAddress.Equals(nNetworkAddress1);
if (resultStatus)
{
break;
}
}
return resultStatus;
}
public static bool Verify( IPAddress ourAddress )
{
if ( !Enabled || IsExempt( ourAddress ) )
return true;
List<NetState> netStates = NetState.Instances;
int count = 0;
for ( int i = 0; i < netStates.Count; ++i )
{
NetState compState = netStates[i];
if ( ourAddress.Equals( compState.Address ) )
{
++count;
if ( count >= MaxAddresses )
return false;
}
}
return true;
}
private static ArrayList GetSharedAccounts( IPAddress ipAddress )
{
ArrayList list = new ArrayList();
foreach ( Account acct in Accounts.GetAccounts() )
{
IPAddress[] theirAddresses = acct.LoginIPs;
bool contains = false;
for ( int i = 0; !contains && i < theirAddresses.Length; ++i )
contains = ipAddress.Equals( theirAddresses[i] );
if ( contains )
list.Add( acct );
}
list.Sort( AccountComparer.Instance );
return list;
}
void CompareIPs (byte [] bytes, string address)
{
IPAddress ip = new IPAddress (bytes);
IPAddress ip2 = IPAddress.Parse (address);
Assert.IsTrue (ip2.Equals (ip), "#A-" + address);
Assert.IsTrue (ip.Equals (ip2), "#B-" + address);
}
/// <summary>
/// This method is one extra layer of checks to make sure someone isn't messing with us
/// (trying to remove streams they don't own by sending BYE packets for instance)
///
/// If we know the IPAddress of the request to RemoveStream, make sure it is the same
/// IPAddress that owns the stream
/// </summary>
/// <param name="ssrc"></param>
/// <param name="ip"></param>
private void RemoveSSRC(uint ssrc, IPAddress ip)
{
lock(streamsAndIPs)
{
// TODO - perhaps this should just be an SSRCConflict check (or it has already been done) JVE
if(streamsAndIPs.Contains(ssrc))
{
if(!ip.Equals(streamsAndIPs[ssrc].senderIP))
{
eventLog.WriteEntry(string.Format("IPAddress: {0} is trying to remove " +
"stream (ssrc: {1}), owned by IPAddress: {2}",
ip.ToString(), ssrc, streamsAndIPs[ssrc].senderIP.ToString()),
EventLogEntryType.Error, (int)RtpEL.ID.RemoveStreamAttack);
return; // Don't actually remove the stream
}
}
}
RemoveSSRC(ssrc);
}
internal static string/*!*/ IPAddressToHostName(IPAddress/*!*/ address, bool doNotReverseLookup) {
if (address.Equals(IPAddress.Any) || doNotReverseLookup) {
return address.ToString();
} else {
return Dns.GetHostEntry(address).HostName;
}
}
// TODO: handle other invalid addresses
internal static IPHostEntry/*!*/ GetHostEntry(IPAddress/*!*/ address, bool doNotReverseLookup) {
Assert.NotNull(address);
if (address.Equals(IPAddress.Any) || address.Equals(IPAddress.Loopback)) {
return MakeEntry(address, doNotReverseLookup);
} else {
return Dns.GetHostEntry(address);
}
}
public static bool IsLoopback(IPAddress address) {
if (address == null) {
throw new ArgumentNullException("address");
}
if ( address.m_Family == AddressFamily.InterNetworkV6 ) {
//
// Do Equals test for IPv6 addresses
//
return address.Equals(IPv6Loopback);
}
else {
return ((address.m_Address & IPAddress.LoopbackMask) == (IPAddress.Loopback.m_Address & IPAddress.LoopbackMask));
}
}
/// <summary>
/// Prüft, ob für die Kommunikation mit einem bestimmten Client zwingend Verschlüsselung erforderlich ist, oder nicht.
/// </summary>
/// <param name="clientAddress">IP-Adresse des Clients</param>
/// <returns>Wahr, wenn Verschlüsselung erforderlich ist, ansonsten Falsch</returns>
private bool RequireEncryption(IPAddress clientAddress)
{
// Wenn keine Ausnahmen definiert sind ...
if (clientAddress == null || _securityExemptionList == null || _securityExemptionList.Length == 0)
// Standardvorgabe zurückgeben
return _requireCryptoClient;
// Gefunden-Schalter
bool found = false;
// Alle IP-Adrssen der Ausnahmeliste durchgehen
foreach (IPAddress address in _securityExemptionList)
{
// Wenn die aktuelle Adresse gefunden wurde ...
if (clientAddress.Equals(address))
{
// Gefunden-Schalter setzen
found = true;
// Schleife abbrechen
break;
}
}
// Prüfergebnis bestimmen und zurückgeben
return found ? !_requireCryptoClient : _requireCryptoClient;
}
static bool ValidateAddress(IPAddress address, ref MessageQueueAndPath found)
{
if (found.Uri.HostNameType != UriHostNameType.IPv4 && found.Uri.HostNameType != UriHostNameType.IPv6)
{
return true;
}
IPAddress foundAddress = IPAddress.Parse(found.Uri.DnsSafeHost);
bool valid = (address.Equals(foundAddress) ||
(foundAddress.Equals(IPAddress.Any) && foundAddress.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork) ||
foundAddress.Equals(IPAddress.IPv6Any));
found = valid ? found : null;
return valid;
}
/// <summary>
/// Is empty
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
public static bool IsEmpty(this IPAddress address)
{
return(address == null ||
address.Equals(IPAddress.Any) || address.Equals(IPAddress.IPv6Any) ||
address.Equals(IPAddress.None) || address.Equals(IPAddress.IPv6None));
}
internal static bool IsAddressLocal(IPAddress ipAddress) {
IPAddress[] localAddresses = NclUtilities.LocalAddresses;
for (int i = 0; i < localAddresses.Length; i++)
{
if (ipAddress.Equals(localAddresses[i], false))
{
return true;
}
}
return false;
}
public static bool IsNetworkAddress(IPAddress vIPAddress, IPAddress vSubnetMask)
{
return vIPAddress.Equals(GetNetworkAddress(vIPAddress,vSubnetMask)); // if Network address from passed IP is the passed IP its a network address ;)
}
public void device_OnPacketArrival(object sender, CaptureEventArgs e)
{
var time = e.Packet.Timeval.Date;
var len = e.Packet.Data.Length;
var packet = PacketDotNet.Packet.ParsePacket(e.Packet.LinkLayerType, e.Packet.Data);
var tcpPacket = (PacketDotNet.TcpPacket)packet.Extract(typeof(PacketDotNet.TcpPacket));
FileStream fs;
if (tcpPacket != null)
{
var ipPacket = (PacketDotNet.IpPacket)tcpPacket.ParentPacket;
System.Net.IPAddress srcIpP = ipPacket.SourceAddress;
System.Net.IPAddress dstIpP = ipPacket.DestinationAddress;
if (srcIpP.Equals(IPAddress.Parse(srcIP)))
{//&&tcpPacket.DestinationPort==9100) {
if (isFin)
{
fileName = "pcl" + tcpPacket.AcknowledgmentNumber;
fileNameSet.Add(fileName);
isFin = false;
}
if (tcpPacket.Fin)
{
isFin = true;
}
if ((sequenceNum == -1 && tcpPacket.PayloadData.Length == 0) || (sequenceNum != -1 && tcpPacket.PayloadData.Length == 0))
{
// do nothing
}
else if (tcpPacket.PayloadData.Length > 0)
{
if (File.Exists(fileName))
{
fs = new FileStream(fileName, FileMode.Append);
}
else
{
fs = new FileStream(fileName, FileMode.Create);
}
BinaryWriter bw = new BinaryWriter(fs);
if (sequenceNum == -1 && tcpPacket.PayloadData.Length > 0)
{
sequenceNum = tcpPacket.SequenceNumber;
sequenceNum += tcpPacket.PayloadData.Length;
bw.Write(tcpPacket.PayloadData);
label8.Text = "Status: Has Captured Files, Continuing ..";
}
else if (sequenceNum != -1 && tcpPacket.PayloadData.Length > 0)
{
if (sequenceNum == tcpPacket.SequenceNumber)
{
sequenceNum += tcpPacket.PayloadData.Length;
bw.Write(tcpPacket.PayloadData);
}
}
bw.Flush();
bw.Close();
fs.Close();
}
}
// if (srcIp.Equals(IPAddress.Parse("192.168.37.130")) && dstIp.Equals(IPAddress.Parse("192.168.37.1"))) {
// device.SendPacket(ipPacket);
// Console.WriteLine("has send");
// }
int srcPort = tcpPacket.SourcePort;
int dstPort = tcpPacket.DestinationPort;
// Console.WriteLine("{0}:{1}:{2},{3} Len={4} {5}:{6} -> {7}:{8}", time.Hour, time.Minute, time.Second, time.Millisecond, len, srcIpP, srcPort, dstIpP, dstPort);
}
}
