|
public Create ( |
||
| socketAddress | ||
| return | ||
/// <summary>
/// Reads the unmanaged sockaddr structure returned by a WinAPI function
/// </summary>
/// <param name="pSockaddrStructure">pointer to the unmanaged sockaddr structure</param>
/// <returns>IP address and port number</returns>
public static IPEndPoint ReadSockaddrStructure(IntPtr pSockaddrStructure) {
short sAddressFamily = Marshal.ReadInt16(pSockaddrStructure);
AddressFamily addressFamily = (AddressFamily)sAddressFamily;
int sockAddrSructureSize;
IPEndPoint ipEndPointAny;
switch (addressFamily) {
case AddressFamily.InterNetwork:
// IP v4 address
sockAddrSructureSize = 16;
ipEndPointAny = new IPEndPoint(IPAddress.Any, 0);
break;
case AddressFamily.InterNetworkV6:
// IP v6 address
sockAddrSructureSize = 28;
ipEndPointAny = new IPEndPoint(IPAddress.IPv6Any, 0);
break;
default:
throw new ArgumentOutOfRangeException("pSockaddrStructure", "Unknown address family");
}
// get bytes of the sockadrr structure
byte[] sockAddrSructureBytes = new byte[sockAddrSructureSize];
Marshal.Copy(pSockaddrStructure, sockAddrSructureBytes, 0, sockAddrSructureSize);
// create SocketAddress from bytes
var socketAddress = new SocketAddress(AddressFamily.Unspecified, sockAddrSructureSize);
for (int i = 0; i < sockAddrSructureSize; i++) {
socketAddress[i] = sockAddrSructureBytes[i];
}
// create IPEndPoint from SocketAddress
IPEndPoint result = (IPEndPoint)ipEndPointAny.Create(socketAddress);
return result;
}
public void Ctor_LongInt ()
{
IPEndPoint ep = new IPEndPoint (0, 80);
Assert.AreEqual (new IPAddress (0), ep.Address, "Address");
Assert.AreEqual (AddressFamily.InterNetwork, ep.AddressFamily, "AddressFamily");
Assert.AreEqual (80, ep.Port, "Port");
Assert.Throws<ArgumentNullException> (delegate {
ep.Create (null);
}, "Create(null)");
// note: documented as ArgumentException
Assert.Throws<ArgumentOutOfRangeException> (delegate {
SocketAddress sa = new SocketAddress (AddressFamily.InterNetwork, 1);
Assert.IsTrue (sa.Size < 8, "Size");
ep.Create (sa);
}, "Create(bad-size)");
Assert.Throws<ArgumentException> (delegate {
SocketAddress sa = new SocketAddress (AddressFamily.InterNetworkV6);
Assert.IsTrue (sa.Size >= 8, "SizeV6");
ep.Create (sa);
}, "Create(InterNetworkV6)");
Assert.Throws<ArgumentException> (delegate {
SocketAddress sa = new SocketAddress (AddressFamily.Unknown);
ep.Create (sa);
}, "Create(Unknown)");
Assert.Throws<ArgumentException> (delegate {
SocketAddress sa = new SocketAddress (AddressFamily.Unspecified);
ep.Create (sa);
}, "Create(Unspecified)");
EndPoint ep2 = ep.Create (new SocketAddress (AddressFamily.InterNetwork));
Assert.IsFalse (ep.Equals (null), "Equals(null)");
Assert.IsTrue (ep.Equals (ep), "Equals(self)");
Assert.IsFalse (ep.Equals (ep2), "Equals(Create)");
Assert.AreEqual ("InterNetwork:16:{0,80,0,0,0,0,0,0,0,0,0,0,0,0}", ep.Serialize ().ToString (), "Serialize");
Assert.AreEqual ("0.0.0.0:80", ep.ToString (), "ToString");
}
public string sortIpAddressList(string IPAddressList)
{
//---------------------------------------------------------------
//If the input is nothing, return nothing
//---------------------------------------------------------------
if(IPAddressList == null || IPAddressList.Length == 0)
{
return string.Empty;
}
//---------------------------------------------------------------
//The input string is supposed to be a list of IPAddress strings
//separated by a semicolon
//---------------------------------------------------------------
string[] IPAddressStrings = IPAddressList.Split(new char[] {';'});
if(IPAddressStrings.Length > MAX_IPADDRESS_LIST_LENGTH)
{
throw new ArgumentException(string.Format(
SR.GetString(SR.net_max_ip_address_list_length_exceeded),
MAX_IPADDRESS_LIST_LENGTH), "IPAddressList");
}
//----------------------------------------------------------------
//If there are no separators, just return the original string
//----------------------------------------------------------------
if(IPAddressStrings.Length == 1)
{
return IPAddressList;
}
//----------------------------------------------------------------
//Parse the strings into Socket Address buffers
//----------------------------------------------------------------
SocketAddress[] SockAddrIn6List = new SocketAddress[IPAddressStrings.Length];
for(int i = 0; i < IPAddressStrings.Length; i++)
{
//Trim leading and trailing spaces
IPAddressStrings[i] = IPAddressStrings[i].Trim();
if(IPAddressStrings[i].Length == 0)
throw new ArgumentException(SR.GetString(SR.dns_bad_ip_address), "IPAddressList");
SocketAddress saddrv6 = new SocketAddress(AddressFamily.InterNetworkV6,
SocketAddress.IPv6AddressSize);
//Parse the string to a v6 address structure
SocketError errorCode =
UnsafeNclNativeMethods.OSSOCK.WSAStringToAddress(
IPAddressStrings[i],
AddressFamily.InterNetworkV6,
IntPtr.Zero,
saddrv6.m_Buffer,
ref saddrv6.m_Size );
if(errorCode != SocketError.Success)
{
//Could not parse this into a SOCKADDR_IN6
//See if we can parse this into s SOCKEADDR_IN
SocketAddress saddrv4 = new SocketAddress(AddressFamily.InterNetwork, SocketAddress.IPv4AddressSize);
errorCode =
UnsafeNclNativeMethods.OSSOCK.WSAStringToAddress(
IPAddressStrings[i],
AddressFamily.InterNetwork,
IntPtr.Zero,
saddrv4.m_Buffer,
ref saddrv4.m_Size );
if(errorCode != SocketError.Success)
{
//This address is neither IPv4 nor IPv6 string throw
throw new ArgumentException(SR.GetString(SR.dns_bad_ip_address), "IPAddressList");
}
else
{
//This is a valid IPv4 address. We need to map this to a mapped v6 address
IPEndPoint dummy = new IPEndPoint(IPAddress.Any, 0);
IPEndPoint IPv4EndPoint = (IPEndPoint)dummy.Create(saddrv4);
byte[] IPv4AddressBytes = IPv4EndPoint.Address.GetAddressBytes();
byte[] IPv6MappedAddressBytes = new byte[16]; //IPv6 is 16 bytes address
for(int j = 0; j < 10; j++) IPv6MappedAddressBytes[j] = 0x00;
IPv6MappedAddressBytes[10] = 0xFF;
IPv6MappedAddressBytes[11] = 0xFF;
IPv6MappedAddressBytes[12] = IPv4AddressBytes[0];
IPv6MappedAddressBytes[13] = IPv4AddressBytes[1];
IPv6MappedAddressBytes[14] = IPv4AddressBytes[2];
IPv6MappedAddressBytes[15] = IPv4AddressBytes[3];
IPAddress v6Address = new IPAddress(IPv6MappedAddressBytes);
IPEndPoint IPv6EndPoint = new IPEndPoint(v6Address, IPv4EndPoint.Port);
saddrv6 = IPv6EndPoint.Serialize();
}
}
//At this point,we have SOCKADDR_IN6 buffer
//add them to the list
SockAddrIn6List[i] = saddrv6;
}
//----------------------------------------------------------------
//All the IPAddress strings are parsed into
//either a native v6 address or mapped v6 address
//The Next step is to prepare for calling the WSAIOctl
//By creating a SOCKET_ADDRESS_LIST
//----------------------------------------------------------------
int cbRequiredBytes = Marshal.SizeOf(typeof(UnsafeNclNativeMethods.OSSOCK.SOCKET_ADDRESS_LIST)) +
(SockAddrIn6List.Length -1)*Marshal.SizeOf(typeof(UnsafeNclNativeMethods.OSSOCK.SOCKET_ADDRESS));
Dictionary<IntPtr, KeyValuePair<SocketAddress, string> > UnmanagedToManagedMapping = new Dictionary<IntPtr, KeyValuePair<SocketAddress, string>>();
GCHandle[] GCHandles = new GCHandle[SockAddrIn6List.Length];
for(int i = 0; i < SockAddrIn6List.Length; i++)
{
GCHandles[i] = GCHandle.Alloc(SockAddrIn6List[i].m_Buffer, GCHandleType.Pinned);
}
IntPtr pSocketAddressList = Marshal.AllocHGlobal(cbRequiredBytes);
try
{
//---------------------------------------------------
//Create a socket address list structure
//and set the pointers to the pinned sock addr buffers
//---------------------------------------------------
unsafe
{
UnsafeNclNativeMethods.OSSOCK.SOCKET_ADDRESS_LIST* pList
= (UnsafeNclNativeMethods.OSSOCK.SOCKET_ADDRESS_LIST*)pSocketAddressList;
pList->iAddressCount = SockAddrIn6List.Length; //Set the number of addresses
UnsafeNclNativeMethods.OSSOCK.SOCKET_ADDRESS* pSocketAddresses =
&pList->Addresses;
for(int i = 0; i < pList->iAddressCount; i++)
{
pSocketAddresses[i].iSockaddrLength = SocketAddress.IPv6AddressSize;
pSocketAddresses[i].lpSockAddr = GCHandles[i].AddrOfPinnedObject();
UnmanagedToManagedMapping[pSocketAddresses[i].lpSockAddr]
= new KeyValuePair<SocketAddress, string>(SockAddrIn6List[i], IPAddressStrings[i]);
}
//---------------------------------------------------
//Create a socket and ask it to sort the list
//---------------------------------------------------
Socket s = new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp);
int cbProcessed = s.IOControl(
IOControlCode.AddressListSort,
pSocketAddressList, //Input buffer
cbRequiredBytes, //Buffer size
pSocketAddressList, //Outbuffer - same as in buffer
cbRequiredBytes //out buffer size - same as in buffer size
);
//---------------------------------------------------
//At this point The sorting is complete
//---------------------------------------------------
StringBuilder sb = new StringBuilder();
for(int i = 0; i < pList->iAddressCount; i++)
{
IntPtr lpSockAddr = pSocketAddresses[i].lpSockAddr;
KeyValuePair<SocketAddress, string> kv = UnmanagedToManagedMapping[lpSockAddr];
sb.Append(kv.Value);
if(i != pList->iAddressCount - 1) sb.Append(";");
}
return sb.ToString();
}
}
finally
{
if(pSocketAddressList != IntPtr.Zero)
{
Marshal.FreeHGlobal(pSocketAddressList);
}
for(int i = 0; i < GCHandles.Length; i++)
{
if(GCHandles[i].IsAllocated)
GCHandles[i].Free();
}
}
}
public string sortIpAddressList(string IPAddressList)
{
//---------------------------------------------------------------
//If the input is nothing, return nothing
//---------------------------------------------------------------
if (IPAddressList == null || IPAddressList.Length == 0)
{
return(string.Empty);
}
//---------------------------------------------------------------
//The input string is supposed to be a list of IPAddress strings
//separated by a semicolon
//---------------------------------------------------------------
string[] IPAddressStrings = IPAddressList.Split(new char[] { ';' });
if (IPAddressStrings.Length > MAX_IPADDRESS_LIST_LENGTH)
{
throw new ArgumentException(string.Format(
SR.GetString(SR.net_max_ip_address_list_length_exceeded),
MAX_IPADDRESS_LIST_LENGTH), "IPAddressList");
}
//----------------------------------------------------------------
//If there are no separators, just return the original string
//----------------------------------------------------------------
if (IPAddressStrings.Length == 1)
{
return(IPAddressList);
}
//----------------------------------------------------------------
//Parse the strings into Socket Address buffers
//----------------------------------------------------------------
SocketAddress[] SockAddrIn6List = new SocketAddress[IPAddressStrings.Length];
for (int i = 0; i < IPAddressStrings.Length; i++)
{
//Trim leading and trailing spaces
IPAddressStrings[i] = IPAddressStrings[i].Trim();
if (IPAddressStrings[i].Length == 0)
{
throw new ArgumentException(SR.GetString(SR.dns_bad_ip_address), "IPAddressList");
}
SocketAddress saddrv6 = new SocketAddress(AddressFamily.InterNetworkV6,
SocketAddress.IPv6AddressSize);
//Parse the string to a v6 address structure
SocketError errorCode =
UnsafeNclNativeMethods.OSSOCK.WSAStringToAddress(
IPAddressStrings[i],
AddressFamily.InterNetworkV6,
IntPtr.Zero,
saddrv6.m_Buffer,
ref saddrv6.m_Size);
if (errorCode != SocketError.Success)
{
//Could not parse this into a SOCKADDR_IN6
//See if we can parse this into s SOCKEADDR_IN
SocketAddress saddrv4 = new SocketAddress(AddressFamily.InterNetwork, SocketAddress.IPv4AddressSize);
errorCode =
UnsafeNclNativeMethods.OSSOCK.WSAStringToAddress(
IPAddressStrings[i],
AddressFamily.InterNetwork,
IntPtr.Zero,
saddrv4.m_Buffer,
ref saddrv4.m_Size);
if (errorCode != SocketError.Success)
{
//This address is neither IPv4 nor IPv6 string throw
throw new ArgumentException(SR.GetString(SR.dns_bad_ip_address), "IPAddressList");
}
else
{
//This is a valid IPv4 address. We need to map this to a mapped v6 address
IPEndPoint dummy = new IPEndPoint(IPAddress.Any, 0);
IPEndPoint IPv4EndPoint = (IPEndPoint)dummy.Create(saddrv4);
byte[] IPv4AddressBytes = IPv4EndPoint.Address.GetAddressBytes();
byte[] IPv6MappedAddressBytes = new byte[16]; //IPv6 is 16 bytes address
for (int j = 0; j < 10; j++)
{
IPv6MappedAddressBytes[j] = 0x00;
}
IPv6MappedAddressBytes[10] = 0xFF;
IPv6MappedAddressBytes[11] = 0xFF;
IPv6MappedAddressBytes[12] = IPv4AddressBytes[0];
IPv6MappedAddressBytes[13] = IPv4AddressBytes[1];
IPv6MappedAddressBytes[14] = IPv4AddressBytes[2];
IPv6MappedAddressBytes[15] = IPv4AddressBytes[3];
IPAddress v6Address = new IPAddress(IPv6MappedAddressBytes);
IPEndPoint IPv6EndPoint = new IPEndPoint(v6Address, IPv4EndPoint.Port);
saddrv6 = IPv6EndPoint.Serialize();
}
}
//At this point,we have SOCKADDR_IN6 buffer
//add them to the list
SockAddrIn6List[i] = saddrv6;
}
//----------------------------------------------------------------
//All the IPAddress strings are parsed into
//either a native v6 address or mapped v6 address
//The Next step is to prepare for calling the WSAIOctl
//By creating a SOCKET_ADDRESS_LIST
//----------------------------------------------------------------
int cbRequiredBytes = Marshal.SizeOf(typeof(UnsafeNclNativeMethods.OSSOCK.SOCKET_ADDRESS_LIST)) +
(SockAddrIn6List.Length - 1) * Marshal.SizeOf(typeof(UnsafeNclNativeMethods.OSSOCK.SOCKET_ADDRESS));
Dictionary <IntPtr, KeyValuePair <SocketAddress, string> > UnmanagedToManagedMapping = new Dictionary <IntPtr, KeyValuePair <SocketAddress, string> >();
GCHandle[] GCHandles = new GCHandle[SockAddrIn6List.Length];
for (int i = 0; i < SockAddrIn6List.Length; i++)
{
GCHandles[i] = GCHandle.Alloc(SockAddrIn6List[i].m_Buffer, GCHandleType.Pinned);
}
IntPtr pSocketAddressList = Marshal.AllocHGlobal(cbRequiredBytes);
try
{
//---------------------------------------------------
//Create a socket address list structure
//and set the pointers to the pinned sock addr buffers
//---------------------------------------------------
unsafe
{
UnsafeNclNativeMethods.OSSOCK.SOCKET_ADDRESS_LIST *pList
= (UnsafeNclNativeMethods.OSSOCK.SOCKET_ADDRESS_LIST *)pSocketAddressList;
pList->iAddressCount = SockAddrIn6List.Length; //Set the number of addresses
UnsafeNclNativeMethods.OSSOCK.SOCKET_ADDRESS *pSocketAddresses =
&pList->Addresses;
for (int i = 0; i < pList->iAddressCount; i++)
{
pSocketAddresses[i].iSockaddrLength = SocketAddress.IPv6AddressSize;
pSocketAddresses[i].lpSockAddr = GCHandles[i].AddrOfPinnedObject();
UnmanagedToManagedMapping[pSocketAddresses[i].lpSockAddr]
= new KeyValuePair <SocketAddress, string>(SockAddrIn6List[i], IPAddressStrings[i]);
}
//---------------------------------------------------
//Create a socket and ask it to sort the list
//---------------------------------------------------
Socket s = new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp);
int cbProcessed = s.IOControl(
IOControlCode.AddressListSort,
pSocketAddressList, //Input buffer
cbRequiredBytes, //Buffer size
pSocketAddressList, //Outbuffer - same as in buffer
cbRequiredBytes //out buffer size - same as in buffer size
);
//---------------------------------------------------
//At this point The sorting is complete
//---------------------------------------------------
StringBuilder sb = new StringBuilder();
for (int i = 0; i < pList->iAddressCount; i++)
{
IntPtr lpSockAddr = pSocketAddresses[i].lpSockAddr;
KeyValuePair <SocketAddress, string> kv = UnmanagedToManagedMapping[lpSockAddr];
sb.Append(kv.Value);
if (i != pList->iAddressCount - 1)
{
sb.Append(";");
}
}
return(sb.ToString());
}
}
finally
{
if (pSocketAddressList != IntPtr.Zero)
{
Marshal.FreeHGlobal(pSocketAddressList);
}
for (int i = 0; i < GCHandles.Length; i++)
{
if (GCHandles[i].IsAllocated)
{
GCHandles[i].Free();
}
}
}
}
internal static IPEndPoint/*!*/ UnpackSockAddr(MutableString/*!*/ stringAddress) {
byte[] bytes = stringAddress.ConvertToBytes();
SocketAddress addr = new SocketAddress(AddressFamily.InterNetwork, bytes.Length);
for (int i = 0; i < bytes.Length; ++i) {
addr[i] = bytes[i];
}
IPEndPoint ep = new IPEndPoint(0, 0);
return (IPEndPoint)ep.Create(addr);
}
/*
/// <summary>
/// Manually updates PlayerData from memory-mapped file.
/// </summary>
public void Update()
{
Stopwatch sw = new Stopwatch();
decimal avg = 0;
for (int i = 0; i < 10000; i++)
{
sw.Start();
// Make sure the memory-mapped file is loaded
if (_mappedFile == null) OpenMumbleLink();
// Read memory-mapped file
_accessor.Read(0, out data);
unsafe
{
fixed (LinkedMem* _data = &data)
{
byte[] tempBytes = new byte[512];
IntPtr tempByteIntPtr = new IntPtr((void*)_data->context);
Marshal.Copy(tempByteIntPtr, tempBytes, 0, 512);
float f = _data->fAvatarPosition[0];
int size = Marshal.SizeOf(typeof(LinkedMem));
byte[] dataBytes = new byte[size];
IntPtr dataBytesIntPtr = new IntPtr((void*)_data);
Marshal.Copy(dataBytesIntPtr, dataBytes, 0, size);
PlayerData pd = dataBytes.ToStruct<PlayerData>();
}
}
sw.Stop();
avg += sw.ElapsedTicks;
sw.Reset();
}
avg /= 10000;
Populate();
}
/// <summary>
/// Manually updates PlayerData from byte array.
/// </summary>
/// <param name="byteArray">Data from which to populate the Player object.</param>
public void Update(byte[] byteArray)
{
if (Marshal.SizeOf(typeof(PlayerData)) != byteArray.Length)
{
throw new ArgumentException(String.Format(
"The parameter {0} (length {1}) is invalid for converting to PlayerData struct.",
(MethodBase.GetCurrentMethod().GetParameters()[0]).Name,
byteArray.Length));
}
_pd = byteArray.ToStruct<PlayerData>();
Populate();
}
/// <summary>
/// Poll the memory-mapped file for data.
/// </summary>
private void Populate()
{
PopulateIdentity();
PopulateServerAddress();
}
/// <summary>
/// Parses identity string into Identity struct using JsonConvert.
/// </summary>
private void PopulateIdentity()
{
string identityJson = _pd.identityString.Substring(0, _pd.identityString.IndexOf('}') + 1);
if (identityJson.Length > 0)
{
_pi = JsonConvert.DeserializeObject<Identity>(identityJson);
}
}
/// <summary>
/// Parses server address byte array into IPEndPoint.
/// </summary>
private void PopulateServerAddress()
{
_serverAddress = GetServerAddress(_pd.serverAddress);
}
*/
/// <summary>
/// Helper method to convert byte array into IPEndpoint.
/// </summary>
/// <param name="serverAddressBytes"></param>
/// <returns></returns>
public static IPEndPoint GetServerAddress(byte[] serverAddressBytes)
{
if (serverAddressBytes.Length < 2)
{
return new IPEndPoint(IPAddress.Any, 0);
}
AddressFamily addressFamily = (AddressFamily)BitConverter.ToInt16(serverAddressBytes, 0);
int sockAddrSructureSize;
IPEndPoint ipEndPointAny;
IPEndPoint result;
switch (addressFamily)
{
case AddressFamily.InterNetwork:
// IP v4 address
sockAddrSructureSize = 16;
ipEndPointAny = new IPEndPoint(IPAddress.Any, 0);
break;
case AddressFamily.InterNetworkV6:
// IP v6 address
sockAddrSructureSize = 28;
ipEndPointAny = new IPEndPoint(IPAddress.IPv6Any, 0);
break;
default:
return new IPEndPoint(IPAddress.Any, 0);
//throw new ArgumentOutOfRangeException("pSockaddrStructure", "Unknown address family");
}
var socketAddress = new SocketAddress(AddressFamily.Unspecified, sockAddrSructureSize);
for (int i = 0; i < sockAddrSructureSize; i++)
{
socketAddress[i] = serverAddressBytes[i];
}
result = (IPEndPoint)ipEndPointAny.Create(socketAddress);
return result;
}
public MFTestResults NetTest5_IPEndPointBasic()
{
/// <summary>
/// 1. Creates 30 Random IPs between 0.0.0.0 and 255.255.255.127
/// 2. Verifies that they can be constructed as IPEndPoints with both ctors
/// 3. Verifies that their data, ToString and GetHashCode funcs return normally
/// 4. Clones one with Create and verifies the above funcs again
/// </summary>
///
bool testResult = true;
try
{
Random random = new Random();
for (int i = 0; i <= 30; i++)
{
int[] IPInts = { random.Next(256), random.Next(256),
random.Next(256), random.Next(128) };
int portInt = random.Next(65535) + 1;
long addressLong = (long)(
IPInts[0]
+ IPInts[1] * 256
+ IPInts[2] * 256 * 256
+ IPInts[3] * 256 * 256 * 256);
Log.Comment("Random IP " + IPInts[0] + "." + IPInts[1]
+ "." + IPInts[2] + "." + IPInts[3] + ":" + portInt);
IPAddress address = new IPAddress(addressLong);
Log.Comment("EndPoint1 created with IPAddress and int");
IPEndPoint endPoint1 = new IPEndPoint(address,portInt);
Log.Comment("EndPoint2 created with long and int");
IPEndPoint endPoint2 = new IPEndPoint(addressLong, portInt);
if (endPoint1 == null)
throw new Exception("EndPoint1 is null");
if (endPoint2 == null)
throw new Exception("EndPoint2 is null");
Type typeOfEndPoint = endPoint1.GetType();
if (typeOfEndPoint != Type.GetType("System.Net.IPEndPoint"))
throw new Exception("EndPoint1 Type is incorrect");
typeOfEndPoint = endPoint2.GetType();
if (typeOfEndPoint != Type.GetType("System.Net.IPEndPoint"))
throw new Exception("EndPoint2 Type is incorrect");
if (endPoint1.ToString() != endPoint2.ToString())
throw new Exception("ToString returns differently for same data");
if (!endPoint1.Equals(endPoint2))
{
throw new Exception("Equals returns false for same data");
}
int hashCode1 = endPoint1.GetHashCode();
int hashCode2 = endPoint2.GetHashCode();
if (hashCode1 != hashCode2)
throw new Exception("GetHasCode returns differently for same data");
if (endPoint1.Address.ToString() != endPoint2.Address.ToString()
|| endPoint1.Address.ToString() != address.ToString()
|| endPoint2.Address.ToString() != address.ToString())
throw new Exception("Address returns wrong data");
if (endPoint1.Port != endPoint2.Port
|| endPoint1.Port != portInt
|| endPoint2.Port != portInt)
throw new Exception("Port returns wrong data");
Log.Comment("Cloning Enpoint1 into EndPoint2");
endPoint2 = (IPEndPoint)endPoint2.Create(endPoint1.Serialize());
typeOfEndPoint = endPoint2.GetType();
if (typeOfEndPoint != Type.GetType("System.Net.IPEndPoint"))
throw new Exception("EndPoint2 Type is incorrect after clone");
if (endPoint1.ToString() != endPoint2.ToString())
throw new Exception("ToString returns differently for cloned data");
//21295 GetHashCode returns differently for cloned data
if (endPoint1.GetHashCode() != endPoint2.GetHashCode())
throw new Exception("GetHashCode returns differently for cloned data");
if (endPoint1.Address.ToString() != endPoint2.Address.ToString()
|| endPoint1.Address.ToString() != address.ToString()
|| endPoint2.Address.ToString() != address.ToString())
throw new Exception("Address returns wrong data after clone");
if (endPoint1.Port != endPoint2.Port
|| endPoint1.Port != portInt
|| endPoint2.Port != portInt)
throw new Exception("Port returns wrong data after clone");
Log.Comment("Recreating EndPoint2 with new data");
int portInt2 = portInt % 2 + 1;
long addressLong2 = (long)(
(IPInts[0] % 2 + 1)
+ (IPInts[1] % 2 + 1 )* 256
+ (IPInts[2] % 2 + 1 )* 256 * 256
+ (IPInts[3] % 2 + 1 )* 256 * 256 * 256);
endPoint2 = new IPEndPoint(addressLong2, portInt2);
if (endPoint1.GetHashCode() == endPoint2.GetHashCode())
throw new Exception("GetHashCode returns same for "
+ endPoint1.ToString()
+ " as " + endPoint2.ToString());
if (endPoint1.Address == endPoint2.Address
|| endPoint2.Address == address)
throw new Exception("Address returns wrong data after change");
if (endPoint1.Port == endPoint2.Port
|| endPoint2.Port == portInt)
throw new Exception("Port returns wrong data after change");
}
}
catch (Exception e)
{
Log.Comment("Caught exception: " + e.Message);
testResult = false;
}
return (testResult ? MFTestResults.Pass : MFTestResults.Fail);
}
public void Ctor_IPAddressInt ()
{
Assert.Throws<ArgumentNullException> (delegate {
new IPEndPoint (null, 80);
}, "IPEndPoint(null,int)");
IPAddress a = new IPAddress (new byte [16]);
Assert.AreEqual (AddressFamily.InterNetworkV6, a.AddressFamily, "IPAddress.AddressFamily");
IPEndPoint ep = new IPEndPoint (a, 0);
Assert.IsTrue (Object.ReferenceEquals (a, ep.Address), "Address");
Assert.AreEqual (AddressFamily.InterNetworkV6, ep.AddressFamily, "AddressFamily");
Assert.AreEqual (0, ep.Port, "Port");
Assert.Throws<ArgumentException> (delegate {
SocketAddress sa = new SocketAddress (AddressFamily.InterNetwork);
ep.Create (sa);
}, "Create(InterNetwork)");
Assert.Throws<ArgumentException> (delegate {
SocketAddress sa = new SocketAddress (AddressFamily.Unknown);
ep.Create (sa);
}, "Create(Unknown)");
Assert.Throws<ArgumentException> (delegate {
SocketAddress sa = new SocketAddress (AddressFamily.Unspecified);
ep.Create (sa);
}, "Create(Unspecified)");
EndPoint ep2 = ep.Create (new SocketAddress (AddressFamily.InterNetworkV6));
Assert.IsFalse (ep.Equals (null), "Equals(null)");
Assert.IsTrue (ep.Equals (ep), "Equals(self)");
Assert.IsTrue (ep.Equals (ep2), "Equals(Create)");
Assert.AreEqual ("InterNetworkV6:28:{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}", ep.Serialize ().ToString (), "Serialize");
// Assert.AreEqual ("0000:0000:0000:0000:0000:0000:0.0.0.0:0", ep.ToString (), "ToString");
}
public void Address ()
{
IPEndPoint ep = new IPEndPoint (0, 0);
Assert.AreEqual (AddressFamily.InterNetwork, ep.AddressFamily, "AddressFamily");
ep.Address = null;
Assert.IsNull (ep.Address, "null");
Assert.Throws<NullReferenceException> (delegate {
Assert.AreEqual (AddressFamily.InterNetwork, ep.AddressFamily);
}, "null-AddressFamily");
Assert.Throws<NullReferenceException> (delegate {
ep.ToString ();
}, "null-ToString");
Assert.Throws<NullReferenceException> (delegate {
ep.Create (new SocketAddress (AddressFamily.InterNetworkV6));
}, "null-Create");
// change family
IPAddress a = new IPAddress (new byte [16]);
ep.Address = a;
Assert.AreEqual (AddressFamily.InterNetworkV6, ep.AddressFamily, "v6-AddressFamily");
}
/// <summary>
/// Reads the unmanaged sockaddr structure returned by a WinAPI function
/// </summary>
/// <param name="pSockaddrStructure">pointer to the unmanaged sockaddr structure</param>
/// <returns>IP address and port number</returns>
private static IPEndPoint ReadSockAddrStorageStructure(SOCKADDR_STORAGE sockAddrStorageStructure)
{
short sAddressFamily = sockAddrStorageStructure.ss_family;
AddressFamily addressFamily = (AddressFamily)sAddressFamily;
int sockAddrSructureSize;
IPEndPoint ipEndPointAny;
switch (addressFamily)
{
case AddressFamily.InterNetwork:
// IP v4 address
sockAddrSructureSize = 8;
var socketAddress = new SocketAddress(AddressFamily.InterNetwork, sockAddrSructureSize);
socketAddress[0] = 2;
socketAddress[1] = 0;
for (int i = 2; i < sockAddrSructureSize; i++)
{
socketAddress[i] = sockAddrStorageStructure.__ss_pad1[i - 2];
}
ipEndPointAny = new IPEndPoint(IPAddress.Any, 0);
return (IPEndPoint)ipEndPointAny.Create(socketAddress);
default:
throw new ArgumentOutOfRangeException(nameof(sockAddrStorageStructure), "Unknown address family");
}
}
public unsafe string sortIpAddressList(string IPAddressList)
{
string str;
if ((IPAddressList == null) || (IPAddressList.Length == 0))
{
return string.Empty;
}
string[] strArray = IPAddressList.Split(new char[] { ';' });
if (strArray.Length > MAX_IPADDRESS_LIST_LENGTH)
{
throw new ArgumentException(string.Format(SR.GetString("net_max_ip_address_list_length_exceeded"), MAX_IPADDRESS_LIST_LENGTH), "IPAddressList");
}
if (strArray.Length == 1)
{
return IPAddressList;
}
SocketAddress[] addressArray = new SocketAddress[strArray.Length];
for (int i = 0; i < strArray.Length; i++)
{
strArray[i] = strArray[i].Trim();
if (strArray[i].Length == 0)
{
throw new ArgumentException(SR.GetString("dns_bad_ip_address"), "IPAddressList");
}
SocketAddress address = new SocketAddress(AddressFamily.InterNetworkV6, 0x1c);
if (UnsafeNclNativeMethods.OSSOCK.WSAStringToAddress(strArray[i], AddressFamily.InterNetworkV6, IntPtr.Zero, address.m_Buffer, ref address.m_Size) != SocketError.Success)
{
SocketAddress socketAddress = new SocketAddress(AddressFamily.InterNetwork, 0x10);
if (UnsafeNclNativeMethods.OSSOCK.WSAStringToAddress(strArray[i], AddressFamily.InterNetwork, IntPtr.Zero, socketAddress.m_Buffer, ref socketAddress.m_Size) != SocketError.Success)
{
throw new ArgumentException(SR.GetString("dns_bad_ip_address"), "IPAddressList");
}
IPEndPoint point = new IPEndPoint(IPAddress.Any, 0);
IPEndPoint point2 = (IPEndPoint) point.Create(socketAddress);
byte[] addressBytes = point2.Address.GetAddressBytes();
byte[] buffer2 = new byte[0x10];
for (int k = 0; k < 10; k++)
{
buffer2[k] = 0;
}
buffer2[10] = 0xff;
buffer2[11] = 0xff;
buffer2[12] = addressBytes[0];
buffer2[13] = addressBytes[1];
buffer2[14] = addressBytes[2];
buffer2[15] = addressBytes[3];
IPAddress address3 = new IPAddress(buffer2);
address = new IPEndPoint(address3, point2.Port).Serialize();
}
addressArray[i] = address;
}
int cb = Marshal.SizeOf(typeof(UnsafeNclNativeMethods.OSSOCK.SOCKET_ADDRESS_LIST)) + ((addressArray.Length - 1) * Marshal.SizeOf(typeof(UnsafeNclNativeMethods.OSSOCK.SOCKET_ADDRESS)));
Dictionary<IntPtr, KeyValuePair<SocketAddress, string>> dictionary = new Dictionary<IntPtr, KeyValuePair<SocketAddress, string>>();
GCHandle[] handleArray = new GCHandle[addressArray.Length];
for (int j = 0; j < addressArray.Length; j++)
{
handleArray[j] = GCHandle.Alloc(addressArray[j].m_Buffer, GCHandleType.Pinned);
}
IntPtr optionInValue = Marshal.AllocHGlobal(cb);
try
{
UnsafeNclNativeMethods.OSSOCK.SOCKET_ADDRESS_LIST* socket_address_listPtr = (UnsafeNclNativeMethods.OSSOCK.SOCKET_ADDRESS_LIST*) optionInValue;
socket_address_listPtr->iAddressCount = addressArray.Length;
UnsafeNclNativeMethods.OSSOCK.SOCKET_ADDRESS* socket_addressPtr = &socket_address_listPtr->Addresses;
for (int m = 0; m < socket_address_listPtr->iAddressCount; m++)
{
socket_addressPtr[m].iSockaddrLength = 0x1c;
socket_addressPtr[m].lpSockAddr = handleArray[m].AddrOfPinnedObject();
dictionary[socket_addressPtr[m].lpSockAddr] = new KeyValuePair<SocketAddress, string>(addressArray[m], strArray[m]);
}
new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp).IOControl(IOControlCode.AddressListSort, optionInValue, cb, optionInValue, cb);
StringBuilder builder = new StringBuilder();
for (int n = 0; n < socket_address_listPtr->iAddressCount; n++)
{
IntPtr lpSockAddr = socket_addressPtr[n].lpSockAddr;
KeyValuePair<SocketAddress, string> pair = dictionary[lpSockAddr];
builder.Append(pair.Value);
if (n != (socket_address_listPtr->iAddressCount - 1))
{
builder.Append(";");
}
}
str = builder.ToString();
}
finally
{
if (optionInValue != IntPtr.Zero)
{
Marshal.FreeHGlobal(optionInValue);
}
for (int num7 = 0; num7 < handleArray.Length; num7++)
{
if (handleArray[num7].IsAllocated)
{
handleArray[num7].Free();
}
}
}
return str;
}
public unsafe string sortIpAddressList(string IPAddressList)
{
string str;
if ((IPAddressList == null) || (IPAddressList.Length == 0))
{
return(string.Empty);
}
string[] strArray = IPAddressList.Split(new char[] { ';' });
if (strArray.Length > MAX_IPADDRESS_LIST_LENGTH)
{
throw new ArgumentException(string.Format(SR.GetString("net_max_ip_address_list_length_exceeded"), MAX_IPADDRESS_LIST_LENGTH), "IPAddressList");
}
if (strArray.Length == 1)
{
return(IPAddressList);
}
SocketAddress[] addressArray = new SocketAddress[strArray.Length];
for (int i = 0; i < strArray.Length; i++)
{
strArray[i] = strArray[i].Trim();
if (strArray[i].Length == 0)
{
throw new ArgumentException(SR.GetString("dns_bad_ip_address"), "IPAddressList");
}
SocketAddress address = new SocketAddress(AddressFamily.InterNetworkV6, 0x1c);
if (UnsafeNclNativeMethods.OSSOCK.WSAStringToAddress(strArray[i], AddressFamily.InterNetworkV6, IntPtr.Zero, address.m_Buffer, ref address.m_Size) != SocketError.Success)
{
SocketAddress socketAddress = new SocketAddress(AddressFamily.InterNetwork, 0x10);
if (UnsafeNclNativeMethods.OSSOCK.WSAStringToAddress(strArray[i], AddressFamily.InterNetwork, IntPtr.Zero, socketAddress.m_Buffer, ref socketAddress.m_Size) != SocketError.Success)
{
throw new ArgumentException(SR.GetString("dns_bad_ip_address"), "IPAddressList");
}
IPEndPoint point = new IPEndPoint(IPAddress.Any, 0);
IPEndPoint point2 = (IPEndPoint)point.Create(socketAddress);
byte[] addressBytes = point2.Address.GetAddressBytes();
byte[] buffer2 = new byte[0x10];
for (int k = 0; k < 10; k++)
{
buffer2[k] = 0;
}
buffer2[10] = 0xff;
buffer2[11] = 0xff;
buffer2[12] = addressBytes[0];
buffer2[13] = addressBytes[1];
buffer2[14] = addressBytes[2];
buffer2[15] = addressBytes[3];
IPAddress address3 = new IPAddress(buffer2);
address = new IPEndPoint(address3, point2.Port).Serialize();
}
addressArray[i] = address;
}
int cb = Marshal.SizeOf(typeof(UnsafeNclNativeMethods.OSSOCK.SOCKET_ADDRESS_LIST)) + ((addressArray.Length - 1) * Marshal.SizeOf(typeof(UnsafeNclNativeMethods.OSSOCK.SOCKET_ADDRESS)));
Dictionary <IntPtr, KeyValuePair <SocketAddress, string> > dictionary = new Dictionary <IntPtr, KeyValuePair <SocketAddress, string> >();
GCHandle[] handleArray = new GCHandle[addressArray.Length];
for (int j = 0; j < addressArray.Length; j++)
{
handleArray[j] = GCHandle.Alloc(addressArray[j].m_Buffer, GCHandleType.Pinned);
}
IntPtr optionInValue = Marshal.AllocHGlobal(cb);
try
{
UnsafeNclNativeMethods.OSSOCK.SOCKET_ADDRESS_LIST *socket_address_listPtr = (UnsafeNclNativeMethods.OSSOCK.SOCKET_ADDRESS_LIST *)optionInValue;
socket_address_listPtr->iAddressCount = addressArray.Length;
UnsafeNclNativeMethods.OSSOCK.SOCKET_ADDRESS *socket_addressPtr = &socket_address_listPtr->Addresses;
for (int m = 0; m < socket_address_listPtr->iAddressCount; m++)
{
socket_addressPtr[m].iSockaddrLength = 0x1c;
socket_addressPtr[m].lpSockAddr = handleArray[m].AddrOfPinnedObject();
dictionary[socket_addressPtr[m].lpSockAddr] = new KeyValuePair <SocketAddress, string>(addressArray[m], strArray[m]);
}
new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp).IOControl(IOControlCode.AddressListSort, optionInValue, cb, optionInValue, cb);
StringBuilder builder = new StringBuilder();
for (int n = 0; n < socket_address_listPtr->iAddressCount; n++)
{
IntPtr lpSockAddr = socket_addressPtr[n].lpSockAddr;
KeyValuePair <SocketAddress, string> pair = dictionary[lpSockAddr];
builder.Append(pair.Value);
if (n != (socket_address_listPtr->iAddressCount - 1))
{
builder.Append(";");
}
}
str = builder.ToString();
}
finally
{
if (optionInValue != IntPtr.Zero)
{
Marshal.FreeHGlobal(optionInValue);
}
for (int num7 = 0; num7 < handleArray.Length; num7++)
{
if (handleArray[num7].IsAllocated)
{
handleArray[num7].Free();
}
}
}
return(str);
}
public MFTestResults SocketExceptionTest11_AccessDenied()
{
/// <summary>
/// 1. Causes a AccessDenied error
/// </summary>
///
bool isCorrectCatch = false;
bool isAnyCatch = false;
SocketPair testSockets = new SocketPair(ProtocolType.Udp, SocketType.Dgram);
try
{
try
{
int clientPort = SocketTools.nextPort;
int serverPort = SocketTools.nextPort;
int tempPort = serverPort;
testSockets.socketClient.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Broadcast, false);
testSockets.Startup(clientPort, serverPort);
IPEndPoint epBroadcast = new IPEndPoint(SocketTools.DottedDecimalToIp((byte)255, (byte)255, (byte)255, (byte)255), tempPort);
EndPoint serverEndPoint = epBroadcast.Create(epBroadcast.Serialize());
testSockets.socketClient.SendTo(testSockets.bufSend, serverEndPoint);
}
catch (SocketException)
{
isCorrectCatch = true;
isAnyCatch = true;
}
}
catch (System.Exception e)
{
isAnyCatch = true;
Log.Comment("Incorrect exception caught: " + e.Message);
}
finally
{
testSockets.TearDown();
}
if (!isAnyCatch)
{
Log.Comment("No exception caught");
}
return (isCorrectCatch ? MFTestResults.Pass : MFTestResults.Fail);
}
public override EndPoint Create(SocketAddress socketaddr)
{
return(mIPEndPoint.Create(socketaddr));
}
private static IPEndPoint QueryRoutingInterface(Socket socket, IPEndPoint remoteEndPoint) {
SocketAddress address = remoteEndPoint.Serialize();
byte[] remoteAddrBytes = new byte[address.Size];
for (int i = 0; i < address.Size; i++) {
remoteAddrBytes[i] = address[i];
}
byte[] outBytes = new byte[remoteAddrBytes.Length];
socket.IOControl(IOControlCode.RoutingInterfaceQuery, remoteAddrBytes, outBytes);
for (int i = 0; i < address.Size; i++) {
address[i] = outBytes[i];
}
EndPoint ep = remoteEndPoint.Create(address);
return (IPEndPoint)ep;
}
