using System.Collections.Generic;
+using MonoTests.Helpers;
+
namespace MonoTests.System.Net.Sockets
{
[TestFixture]
[Test]
public void ConnectIPAddressAny ()
{
- IPEndPoint ep = new IPEndPoint (IPAddress.Any, 0);
+ IPEndPoint ep = new IPEndPoint (IPAddress.Any, NetworkHelpers.FindFreePort ());
/* UDP sockets use Any to disconnect
try {
public void IncompatibleAddress ()
{
IPEndPoint epIPv6 = new IPEndPoint (IPAddress.IPv6Any,
- 0);
+ NetworkHelpers.FindFreePort ());
try {
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP)) {
Socket.Select (list, list, list, 1000);
}
- private bool BlockingConnect (bool block)
+ private bool BlockingConnect (bool block, int port)
{
- IPEndPoint ep = new IPEndPoint(IPAddress.Loopback, 1234);
+ IPEndPoint ep = new IPEndPoint(IPAddress.Loopback, port);
Socket server = new Socket(AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
public void AcceptBlockingStatus()
{
bool block;
-
- block = BlockingConnect(true);
+ var port = NetworkHelpers.FindFreePort ();
+
+ block = BlockingConnect(true, port);
Assert.AreEqual (block, true, "BlockingStatus01");
- block = BlockingConnect(false);
+ block = BlockingConnect(false, port);
Assert.AreEqual (block, false, "BlockingStatus02");
}
* anything...
*/
sock.BeginConnect (new IPEndPoint (IPAddress.Loopback,
- 114),
+ NetworkHelpers.FindFreePort ()),
new AsyncCallback (CFACallback),
sock);
CFACalledBack.WaitOne ();
[Test]
public void SetSocketOptionBoolean ()
{
- IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 1);
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, NetworkHelpers.FindFreePort ());
Socket sock = new Socket (ep.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
try {
sock.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
[Test]
public void TestSelect1 ()
{
- Socket srv = CreateServer ();
+ Socket srv = CreateServer (NetworkHelpers.FindFreePort ());
ClientSocket clnt = new ClientSocket (srv.LocalEndPoint);
Thread th = new Thread (new ThreadStart (clnt.ConnectSleepClose));
Socket acc = null;
}
}
- static Socket CreateServer ()
+ static Socket CreateServer (int port)
{
Socket sock = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
- sock.Bind (new IPEndPoint (IPAddress.Loopback, 0));
+ sock.Bind (new IPEndPoint (IPAddress.Loopback, port));
sock.Listen (1);
return sock;
}
public void Disposed19 ()
{
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
- EndPoint ep = new IPEndPoint (IPAddress.Any, 31337);
+ EndPoint ep = new IPEndPoint (IPAddress.Any, NetworkHelpers.FindFreePort ());
s.Close();
s.SendTo (buf, 0, ep);
public void Disposed20 ()
{
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
- EndPoint ep = new IPEndPoint (IPAddress.Any, 31337);
+ EndPoint ep = new IPEndPoint (IPAddress.Any, NetworkHelpers.FindFreePort ());
s.Close();
s.SendTo (buf, 10, 0, ep);
public void Disposed21 ()
{
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
- EndPoint ep = new IPEndPoint (IPAddress.Any, 31337);
+ EndPoint ep = new IPEndPoint (IPAddress.Any, NetworkHelpers.FindFreePort ());
s.Close();
s.SendTo (buf, 0, 10, 0, ep);
public void Disposed22 ()
{
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
- EndPoint ep = new IPEndPoint (IPAddress.Any, 31337);
+ EndPoint ep = new IPEndPoint (IPAddress.Any, NetworkHelpers.FindFreePort ());
s.Close();
s.SendTo (buf, ep);
Socket server = new Socket (AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
IPEndPoint ep = new IPEndPoint (IPAddress.Loopback,
- 9010);
+ NetworkHelpers.FindFreePort ());
server.Bind (ep);
server.Listen (1);
sock.DontFragment = true;
Assert.Fail ("DontFragment #1");
} catch (NotSupportedException) {
- } catch {
- Assert.Fail ("DontFragment #2");
} finally {
sock.Close ();
}
Assert.Fail ("EnableBroadcastDefaultTcp #1");
} catch (SocketException ex) {
Assert.AreEqual (10042, ex.ErrorCode, "EnableBroadcastDefaultTcp #2");
- } catch {
- Assert.Fail ("EnableBroadcastDefaultTcp #2");
} finally {
sock.Close ();
}
Assert.Fail ("EnableBroadcastChangeTcp #1");
} catch (SocketException ex) {
Assert.AreEqual (10042, ex.ErrorCode, "EnableBroadcastChangeTcp #2");
- } catch {
- Assert.Fail ("EnableBroadcastChangeTcp #2");
} finally {
sock.Close ();
}
SocketType.Stream,
ProtocolType.Tcp);
- sock.Bind (new IPEndPoint (IPAddress.Any, 1235));
+ sock.Bind (new IPEndPoint (IPAddress.Any, NetworkHelpers.FindFreePort ()));
sock.ExclusiveAddressUse = true;
sock.Close ();
}
Assert.Fail ("MulticastLoopbackDefaultTcp #1");
} catch (SocketException ex) {
Assert.AreEqual (10042, ex.ErrorCode, "MulticastLoopbackDefaultTcp #2");
- } catch {
- Assert.Fail ("MulticastLoopbackDefaultTcp #2");
} finally {
sock.Close ();
}
Assert.Fail ("MulticastLoopbackChangeTcp #1");
} catch (SocketException ex) {
Assert.AreEqual (10042, ex.ErrorCode, "MulticastLoopbackChangeTcp #2");
- } catch {
- Assert.Fail ("MulticastLoopbackChangeTcp #2");
} finally {
sock.Close ();
}
} catch (SocketException ex) {
Assert.AreEqual (10022, ex.ErrorCode,
"TtlChangeOverflow #2");
- } catch {
- Assert.Fail ("TtlChangeoverflow #3");
} finally {
sock.Close ();
}
} catch (SocketException ex) {
Assert.AreEqual (10022, ex.ErrorCode,
"TtlChangeOverflow #5");
- } catch {
- Assert.Fail ("TtlChangeOverflow #6");
} finally {
sock.Close ();
}
sock.SendTimeout = -2;
Assert.Fail ("SendTimeoutChange #8");
} catch (ArgumentOutOfRangeException) {
- } catch {
- Assert.Fail ("SendTimeoutChange #9");
} finally {
sock.Close ();
}
sock.ReceiveTimeout = -2;
Assert.Fail ("ReceiveTimeoutChange #8");
} catch (ArgumentOutOfRangeException) {
- } catch {
- Assert.Fail ("ReceiveTimeoutChange #9");
} finally {
sock.Close ();
}
} catch (SocketException ex) {
Assert.AreEqual (10042, ex.ErrorCode,
"NoDelayDefaultUdp #2");
- } catch {
- Assert.Fail ("NoDelayDefaultUdp #3");
} finally {
sock.Close ();
}
} catch (SocketException ex) {
Assert.AreEqual (10042, ex.ErrorCode,
"NoDelayChangeUdp #2");
- } catch {
- Assert.Fail ("NoDelayChangeUdp #3");
} finally {
sock.Close ();
}
SocketType.Stream,
ProtocolType.Tcp);
- sock.Bind (new IPEndPoint (IPAddress.Any, 1236));
+ sock.Bind (new IPEndPoint (IPAddress.Any, NetworkHelpers.FindFreePort ()));
sock.BeginAccept (BACallback, sock);
SocketType.Stream,
ProtocolType.Tcp);
IPEndPoint ep = new IPEndPoint (IPAddress.Loopback,
- 1237);
+ NetworkHelpers.FindFreePort ());
sock.Bind (ep);
sock.Listen (1);
SocketType.Stream,
ProtocolType.Tcp);
IPEndPoint ep = new IPEndPoint (IPAddress.Loopback,
- 1238);
+ NetworkHelpers.FindFreePort ());
sock.Bind (ep);
sock.Listen (1);
ProtocolType.Udp);
IPEndPoint ep = new IPEndPoint (IPAddress.Loopback,
- 1239);
+ NetworkHelpers.FindFreePort ());
sock.Bind (ep);
sock.Listen (1);
Assert.Fail ("BeginAcceptSocketUdp #1");
} catch (SocketException ex) {
Assert.AreEqual (10022, ex.ErrorCode, "BeginAcceptSocketUdp #2");
- } catch {
- Assert.Fail ("BeginAcceptSocketUdp #3");
} finally {
acc.Close ();
sock.Close ();
ProtocolType.Tcp);
IPEndPoint ep1 = new IPEndPoint (IPAddress.Loopback,
- 1240);
+ NetworkHelpers.FindFreePort ());
IPEndPoint ep2 = new IPEndPoint (IPAddress.Loopback,
- 1241);
+ NetworkHelpers.FindFreePort ());
sock.Bind (ep1);
sock.Listen (1);
sock.BeginAccept (acc, 256, BADCallback, sock);
Assert.Fail ("BeginAcceptSocketBound #1");
} catch (InvalidOperationException) {
- } catch {
- Assert.Fail ("BeginAcceptSocketBound #2");
} finally {
acc.Close ();
sock.Close ();
ProtocolType.Tcp);
IPEndPoint ep = new IPEndPoint (IPAddress.Loopback,
- 1242);
+ NetworkHelpers.FindFreePort ());
sock.Bind (ep);
sock.Listen (1);
sock.BeginAccept (acc, 256, BADCallback, null);
Assert.Fail ("BeginAcceptSocketClosed #1");
} catch (ObjectDisposedException) {
- } catch {
- Assert.Fail ("BeginAcceptSocketClosed #2");
} finally {
acc.Close ();
}
SocketType.Stream,
ProtocolType.Tcp);
IPEndPoint ep = new IPEndPoint (IPAddress.Loopback,
- 1243);
+ NetworkHelpers.FindFreePort ());
sock.Bind (ep);
sock.Listen (1);
sock.BeginAccept (acc, 256, BADCallback, null);
Assert.Fail ("BeginAcceptSocketAccClosed #1");
} catch (ObjectDisposedException) {
- } catch {
- Assert.Fail ("BeginAcceptSocketAccClosed #2");
} finally {
sock.Close ();
}
SocketType.Stream,
ProtocolType.Tcp);
IPAddress ip = IPAddress.Loopback;
- IPEndPoint ep = new IPEndPoint (ip, 1244);
+ IPEndPoint ep = new IPEndPoint (ip, NetworkHelpers.FindFreePort ());
listen.Bind (ep);
listen.Listen (1);
BCConnected = false;
- sock.BeginConnect (ip, 1244, BCCallback, sock);
+ sock.BeginConnect (ip, ep.Port, BCCallback, sock);
if (BCCalledBack.WaitOne (2000, false) == false) {
Assert.Fail ("BeginConnectAddressPort wait timed out");
sock);
Assert.Fail ("BeginConnectAddressPortNull #1");
} catch (ArgumentNullException) {
- } catch {
- Assert.Fail ("BeginConnectAddressPortNull #2");
} finally {
sock.Close ();
}
SocketType.Stream,
ProtocolType.Tcp);
IPAddress ip = IPAddress.Loopback;
- IPEndPoint ep = new IPEndPoint (ip, 1245);
+ IPEndPoint ep = new IPEndPoint (ip, NetworkHelpers.FindFreePort ());
sock.Bind (ep);
sock.Listen (1);
try {
- sock.BeginConnect (ip, 1245, BCCallback, sock);
+ sock.BeginConnect (ip, ep.Port, BCCallback, sock);
Assert.Fail ("BeginConnectAddressPortListen #1");
} catch (InvalidOperationException) {
- } catch {
- Assert.Fail ("BeginConnectAddressPortListen #2");
} finally {
sock.Close ();
}
SocketType.Stream,
ProtocolType.Tcp);
IPEndPoint ep = new IPEndPoint (IPAddress.Loopback,
- 1246);
+ NetworkHelpers.FindFreePort ());
IPAddress[] ips = new IPAddress[4];
ips[0] = IPAddress.Parse ("127.0.0.4");
BCConnected = false;
- sock.BeginConnect (ips, 1246, BCCallback, sock);
+ sock.BeginConnect (ips, ep.Port, BCCallback, sock);
/* Longer wait here, because the ms runtime
* takes a lot longer to not connect
* succeed it it can connect to at least one of the requested
* addresses.
*/
- IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 1246);
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, NetworkHelpers.FindFreePort ());
listen.Bind (ep);
listen.Listen (1);
BCConnected = false;
- sock.BeginConnect (allIps, 1246, BCCallback, sock);
+ sock.BeginConnect (allIps, ep.Port, BCCallback, sock);
/* Longer wait here, because the ms runtime
* takes a lot longer to not connect
sock);
Assert.Fail ("BeginConnectMultipleNull #1");
} catch (ArgumentNullException) {
- } catch {
- Assert.Fail ("BeginConnectMultipleNull #2");
} finally {
sock.Close ();
}
ProtocolType.Tcp);
IPAddress[] ips = new IPAddress[4];
IPEndPoint ep = new IPEndPoint (IPAddress.Loopback,
- 1247);
+ NetworkHelpers.FindFreePort ());
ips[0] = IPAddress.Parse ("127.0.0.4");
ips[1] = IPAddress.Parse ("127.0.0.3");
sock.Listen (1);
try {
- sock.BeginConnect (ips, 1247, BCCallback,
+ sock.BeginConnect (ips, ep.Port, BCCallback,
sock);
Assert.Fail ("BeginConnectMultipleListen #1");
} catch (InvalidOperationException) {
- } catch {
- Assert.Fail ("BeginConnectMultipleListen #2");
} finally {
sock.Close ();
}
BCCallback, sock);
Assert.Fail ("BeginConnectHostPort #1");
} catch (ArgumentNullException) {
- } catch {
- Assert.Fail ("BeginConnectHostPort #2");
} finally {
sock.Close ();
}
SocketType.Stream,
ProtocolType.Tcp);
IPAddress ip = IPAddress.Loopback;
- IPEndPoint ep = new IPEndPoint (ip, 1248);
+ IPEndPoint ep = new IPEndPoint (ip, NetworkHelpers.FindFreePort ());
sock.Bind (ep);
sock.Listen (1);
try {
- sock.BeginConnect ("localhost", 1248,
+ sock.BeginConnect ("localhost", ep.Port,
BCCallback, sock);
Assert.Fail ("BeginConnectHostPortListen #1");
} catch (InvalidOperationException) {
- } catch {
- Assert.Fail ("BeginConnectHostPortListen #2");
} finally {
sock.Close ();
}
sock);
Assert.Fail ("BeginConnectHostPortNotIP #1");
} catch (NotSupportedException) {
- } catch {
- Assert.Fail ("BeginConnectHostPortNotIP #2");
} finally {
sock.Close ();
}
SocketType.Stream,
ProtocolType.Tcp);
IPAddress ip = IPAddress.Loopback;
- IPEndPoint ep = new IPEndPoint (ip, 1254);
+ IPEndPoint ep = new IPEndPoint (ip, NetworkHelpers.FindFreePort ());
listen.Bind (ep);
listen.Listen (1);
- sock.Connect (ip, 1254);
+ sock.Connect (ip, ep.Port);
Assert.AreEqual (true, sock.Connected, "BeginDisconnect #1");
Assert.Fail ("BeginSendNotConnected #1");
} catch (SocketException ex) {
Assert.AreEqual (10057, ex.ErrorCode, "BeginSendNotConnected #2");
- } catch {
- Assert.Fail ("BeginSendNotConnected #3");
} finally {
sock.Close ();
}
SocketType.Stream,
ProtocolType.Tcp);
IPEndPoint ep1 = new IPEndPoint (IPAddress.Loopback,
- 1256);
+ NetworkHelpers.FindFreePort ());
IPEndPoint ep2 = new IPEndPoint (IPAddress.Loopback,
- 1257);
+ NetworkHelpers.FindFreePort ());
sock.Bind (ep1);
Assert.Fail ("BindTwice #1");
} catch (SocketException ex) {
Assert.AreEqual (10022, ex.ErrorCode, "BindTwice #2");
- } catch {
- Assert.Fail ("BindTwice #3");
} finally {
sock.Close ();
}
SocketType.Stream,
ProtocolType.Tcp);
IPEndPoint ep = new IPEndPoint (IPAddress.Loopback,
- 1258);
+ NetworkHelpers.FindFreePort ());
listen.Bind (ep);
listen.Listen (1);
SocketType.Stream,
ProtocolType.Tcp);
IPAddress ip = IPAddress.Loopback;
- IPEndPoint ep = new IPEndPoint (ip, 1249);
+ IPEndPoint ep = new IPEndPoint (ip, NetworkHelpers.FindFreePort ());
listen.Bind (ep);
listen.Listen (1);
- sock.Connect (ip, 1249);
+ sock.Connect (ip, ep.Port);
Assert.AreEqual (true, sock.Connected, "ConnectAddressPort #1");
sock.Connect (ip, 1249);
Assert.Fail ("ConnectAddressPortNull #1");
} catch (ArgumentNullException) {
- } catch {
- Assert.Fail ("ConnectAddressPortNull #2");
} finally {
sock.Close ();
}
SocketType.Stream,
ProtocolType.Tcp);
IPAddress ip = IPAddress.Loopback;
- IPEndPoint ep = new IPEndPoint (ip, 1250);
+ IPEndPoint ep = new IPEndPoint (ip, NetworkHelpers.FindFreePort ());
sock.Bind (ep);
sock.Listen (1);
try {
- sock.Connect (ip, 1250);
+ sock.Connect (ip, ep.Port);
Assert.Fail ("ConnectAddressPortListen #1");
} catch (InvalidOperationException) {
- } catch {
- Assert.Fail ("ConnectAddressPortListen #2");
} finally {
sock.Close ();
}
SocketType.Stream,
ProtocolType.Tcp);
IPEndPoint ep = new IPEndPoint (IPAddress.Loopback,
- 1251);
+ NetworkHelpers.FindFreePort ());
IPAddress[] ips = new IPAddress[4];
ips[0] = IPAddress.Parse ("127.0.0.4");
listen.Bind (ep);
listen.Listen (1);
- sock.Connect (ips, 1251);
+ sock.Connect (ips, ep.Port);
Assert.AreEqual (true, sock.Connected, "ConnectMultiple #1");
Assert.AreEqual (AddressFamily.InterNetwork, sock.RemoteEndPoint.AddressFamily, "ConnectMultiple #2");
* Bind to IPAddress.Any; Connect() will fail unless it can
* connect to all the addresses in allIps.
*/
- IPEndPoint ep = new IPEndPoint (IPAddress.Any, 1251);
+ IPEndPoint ep = new IPEndPoint (IPAddress.Any, NetworkHelpers.FindFreePort ());
listen.Bind (ep);
listen.Listen (1);
- sock.Connect (allIps, 1251);
+ sock.Connect (allIps, ep.Port);
Assert.AreEqual (true, sock.Connected, "ConnectMultiple2 #1");
Assert.AreEqual (AddressFamily.InterNetwork, sock.RemoteEndPoint.AddressFamily, "ConnectMultiple2 #2");
sock.Connect (ips, 1251);
Assert.Fail ("ConnectMultipleNull #1");
} catch (ArgumentNullException) {
- } catch {
- Assert.Fail ("ConnectMultipleNull #2");
} finally {
sock.Close ();
}
ProtocolType.Tcp);
IPAddress[] ips = new IPAddress[4];
IPEndPoint ep = new IPEndPoint (IPAddress.Loopback,
- 1252);
+ NetworkHelpers.FindFreePort ());
ips[0] = IPAddress.Parse ("127.0.0.4");
ips[1] = IPAddress.Parse ("127.0.0.3");
sock.Listen (1);
try {
- sock.Connect (ips, 1252);
+ sock.Connect (ips, ep.Port);
Assert.Fail ("ConnectMultipleListen #1");
} catch (InvalidOperationException) {
- } catch {
- Assert.Fail ("ConnectMultipleListen #2");
} finally {
sock.Close ();
}
sock.Connect ((string)null, 0);
Assert.Fail ("ConnectHostPort #1");
} catch (ArgumentNullException) {
- } catch {
- Assert.Fail ("ConnectHostPort #2");
} finally {
sock.Close ();
}
SocketType.Stream,
ProtocolType.Tcp);
IPAddress ip = IPAddress.Loopback;
- IPEndPoint ep = new IPEndPoint (ip, 1253);
+ IPEndPoint ep = new IPEndPoint (ip, NetworkHelpers.FindFreePort ());
sock.Bind (ep);
sock.Listen (1);
try {
- sock.Connect ("localhost", 1253);
+ sock.Connect ("localhost", ep.Port);
Assert.Fail ("ConnectHostPortListen #1");
} catch (InvalidOperationException) {
- } catch {
- Assert.Fail ("ConnectHostPortListen #2");
} finally {
sock.Close ();
}
sock.Connect ("localhost", 0);
Assert.Fail ("ConnectHostPortNotIP #1");
} catch (NotSupportedException) {
- } catch {
- Assert.Fail ("ConnectHostPortNotIP #2");
} finally {
sock.Close ();
}
SocketType.Stream,
ProtocolType.Tcp);
IPAddress ip = IPAddress.Loopback;
- IPEndPoint ep = new IPEndPoint (ip, 1255);
+ IPEndPoint ep = new IPEndPoint (ip, NetworkHelpers.FindFreePort ());
listen.Bind (ep);
listen.Listen (1);
- sock.Connect (ip, 1255);
+ sock.Connect (ip, ep.Port);
Assert.AreEqual (true, sock.Connected, "Disconnect #1");
{
int i;
- IPEndPoint endpoint = new IPEndPoint(IPAddress.Loopback, 1258);
+ IPEndPoint endpoint = new IPEndPoint(IPAddress.Loopback, NetworkHelpers.FindFreePort ());
Socket listensock = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
listensock.Bind (endpoint);
{
int i;
- IPEndPoint endpoint = new IPEndPoint(IPAddress.Loopback, 1259);
+ IPEndPoint endpoint = new IPEndPoint(IPAddress.Loopback, NetworkHelpers.FindFreePort ());
Socket listensock = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
listensock.Bind (endpoint);
Assert.Fail ("ListenNotBound #1");
} catch (SocketException ex) {
Assert.AreEqual (10022, ex.ErrorCode, "ListenNotBound #2");
- } catch {
- Assert.Fail ("ListenNotBound #3");
} finally {
sock.Close ();
}
SocketType.Dgram,
ProtocolType.Udp);
CWRSocket.Bind (new IPEndPoint (IPAddress.Loopback,
- 1256));
+ NetworkHelpers.FindFreePort ()));
Thread recv_thread = new Thread (new ThreadStart (CWRReceiveThread));
CWRReady.Reset ();
static bool RRCLastRead = false;
static ManualResetEvent RRCReady = new ManualResetEvent (false);
- private static void RRCClientThread ()
+ private static void RRCClientThread (int port)
{
byte[] bytes = new byte[8];
int readbyte;
SocketType.Stream,
ProtocolType.Tcp);
sock.Connect (new IPEndPoint (IPAddress.Loopback,
- 1257));
+ port));
NetworkStream stream = new NetworkStream (sock);
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
ProtocolType.Tcp);
- EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, 8001);
+ EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, NetworkHelpers.FindFreePort ());
try {
s.ReceiveFrom ((Byte []) null, ref remoteEP);
Assert.Fail ("#1");
ProtocolType.Tcp);
s.Close ();
- EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, 8001);
+ EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, NetworkHelpers.FindFreePort ());
try {
s.ReceiveFrom ((Byte []) null, ref remoteEP);
Assert.Fail ("#1");
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
ProtocolType.Tcp);
- EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, 8001);
+ EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, NetworkHelpers.FindFreePort ());
try {
s.ReceiveFrom ((Byte []) null, (SocketFlags) 666, ref remoteEP);
Assert.Fail ("#1");
ProtocolType.Tcp);
s.Close ();
- EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, 8001);
+ EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, NetworkHelpers.FindFreePort ());
try {
s.ReceiveFrom ((Byte []) null, (SocketFlags) 666, ref remoteEP);
Assert.Fail ("#1");
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
ProtocolType.Tcp);
- EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, 8001);
+ EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, NetworkHelpers.FindFreePort ());
try {
s.ReceiveFrom ((Byte []) null, 0, (SocketFlags) 666,
ref remoteEP);
{
Socket s;
byte [] buffer = new byte [5];
- EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, 8001);
+ EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, NetworkHelpers.FindFreePort ());
// size negative
s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
ProtocolType.Tcp);
s.Close ();
- EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, 8001);
+ EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, NetworkHelpers.FindFreePort ());
try {
s.ReceiveFrom ((Byte []) null, -1, (SocketFlags) 666,
ref remoteEP);
{
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
ProtocolType.Tcp);
- EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, 8001);
+ EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, NetworkHelpers.FindFreePort ());
try {
s.ReceiveFrom ((Byte []) null, -1, -1, (SocketFlags) 666,
{
Socket s;
byte [] buffer = new byte [5];
- EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, 8001);
+ EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, NetworkHelpers.FindFreePort ());
// offset negative
s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
{
Socket s;
byte [] buffer = new byte [5];
- EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, 8001);
+ EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, NetworkHelpers.FindFreePort ());
// size negative
s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
s.Close ();
byte [] buffer = new byte [5];
- EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, 8001);
+ EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, NetworkHelpers.FindFreePort ());
try {
s.ReceiveFrom (buffer, -1, -1, (SocketFlags) 666,
ref remoteEP);
[Test]
public void ReceiveRemoteClosed ()
{
+ var port = NetworkHelpers.FindFreePort ();
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
- sock.Bind (new IPEndPoint (IPAddress.Loopback, 1257));
+ sock.Bind (new IPEndPoint (IPAddress.Loopback, port));
sock.Listen (1);
RRCReady.Reset ();
- Thread client_thread = new Thread (new ThreadStart (RRCClientThread));
+ Thread client_thread = new Thread (() => RRCClientThread (port));
client_thread.Start ();
Socket client = sock.Accept ();
[Test]
public void UdpDoubleBind ()
{
- Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
- s.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1);
-
- s.Bind (new IPEndPoint (IPAddress.Any, 12345));
-
- Socket ss = new Socket (AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
- ss.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1);
-
- ss.Bind (new IPEndPoint (IPAddress.Any, 12345));
+ using (Socket s = new Socket (AddressFamily.InterNetwork,
+ SocketType.Dgram, ProtocolType.Udp))
+ using (Socket ss = new Socket (AddressFamily.InterNetwork,
+ SocketType.Dgram, ProtocolType.Udp)) {
+ var supportsReuseAddress = true;
+ try {
+ s.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
+ } catch (SocketException e) {
+ // Exception is thrown when ReuseAddress is not supported
+ Assert.AreEqual ((int) SocketError.OperationNotSupported, e.NativeErrorCode,
+ "Expected SocketError.OperationNotSupported");
+ supportsReuseAddress = false;
+ }
- // If we make it this far, we succeeded.
-
- ss.Close ();
- s.Close ();
- }
+ var ep = new IPEndPoint (IPAddress.Any, NetworkHelpers.FindFreePort ());
+ s.Bind (ep);
- static bool? supportsPortReuse;
- static bool SupportsPortReuse ()
- {
- if (supportsPortReuse.HasValue)
- return supportsPortReuse.Value;
+ if (supportsReuseAddress)
+ ss.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
- supportsPortReuse = (bool) typeof (Socket).GetMethod ("SupportsPortReuse",
- BindingFlags.Static | BindingFlags.NonPublic)
- .Invoke (null, new object [] {});
- return supportsPortReuse.Value;
+ try {
+ ss.Bind (new IPEndPoint (IPAddress.Any, ep.Port));
+ if (!supportsReuseAddress)
+ Assert.Fail ("Reusing address is not supported, exception was expected on second bind.");
+ } catch (SocketException e) {
+ }
+ }
}
// Test case for bug #31557
SocketType.Stream, ProtocolType.Tcp))
using (Socket ss = new Socket (AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp)) {
- s.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
+ var supportsReuseAddress = true;
+ try {
+ s.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
+ } catch (SocketException e) {
+ // Exception is thrown when ReuseAddress is not supported
+ Assert.AreEqual ((int) SocketError.OperationNotSupported, e.NativeErrorCode,
+ "Expected SocketError.OperationNotSupported");
+ supportsReuseAddress = false;
+ }
- s.Bind (new IPEndPoint (IPAddress.Any, 12345));
+ var ep = new IPEndPoint (IPAddress.Any, NetworkHelpers.FindFreePort ());
+ s.Bind (ep);
s.Listen(1);
- ss.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
+ if (supportsReuseAddress)
+ ss.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
- Exception ex = null;
try {
- ss.Bind (new IPEndPoint (IPAddress.Any, 12345));
+ ss.Bind (new IPEndPoint (IPAddress.Any, ep.Port));
ss.Listen(1);
+ if (!supportsReuseAddress)
+ Assert.Fail ("Reusing address is not supported, exception was expected on second bind.");
} catch (SocketException e) {
- ex = e;
}
-
- Assert.AreEqual (SupportsPortReuse (), ex == null);
}
}
[Category ("NotOnMac")]
public void ConnectedProperty ()
{
- TcpListener listener = new TcpListener (IPAddress.Loopback, 23456);
+ TcpListener listener = new TcpListener (IPAddress.Loopback, NetworkHelpers.FindFreePort ());
listener.Start();
Socket client = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
- client.Connect (IPAddress.Loopback, 23456);
+ client.Connect (IPAddress.Loopback, ((IPEndPoint)listener.LocalEndpoint).Port);
Socket server = listener.AcceptSocket ();
try {
IPAddress mcast_addr = IPAddress.Parse ("239.255.255.250");
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp)) {
- s.Bind (new IPEndPoint (IPAddress.Any, 1901));
+ s.Bind (new IPEndPoint (IPAddress.Any, NetworkHelpers.FindFreePort ()));
try {
s.SetSocketOption (SocketOptionLevel.IP, SocketOptionName.AddMembership,
new IPv6MulticastOption (mcast_addr));
IPAddress mcast_addr = IPAddress.Parse ("239.255.255.250");
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp)) {
- s.Bind (new IPEndPoint (IPAddress.Any, 1901));
+ s.Bind (new IPEndPoint (IPAddress.Any, NetworkHelpers.FindFreePort ()));
s.SetSocketOption (SocketOptionLevel.IP, SocketOptionName.AddMembership,
new MulticastOption (mcast_addr));
}
IPAddress mcast_addr = IPAddress.Parse ("ff02::1");
using (Socket s = new Socket (AddressFamily.InterNetworkV6, SocketType.Dgram, ProtocolType.Udp)) {
- s.Bind (new IPEndPoint (IPAddress.IPv6Any, 1902));
+ s.Bind (new IPEndPoint (IPAddress.IPv6Any, NetworkHelpers.FindFreePort ()));
s.SetSocketOption (SocketOptionLevel.IPv6, SocketOptionName.AddMembership,
new IPv6MulticastOption (mcast_addr));
}
IPAddress mcast_addr = IPAddress.Parse ("ff02::1");
using (Socket s = new Socket (AddressFamily.InterNetworkV6, SocketType.Dgram, ProtocolType.Udp)) {
- s.Bind (new IPEndPoint (IPAddress.IPv6Any, 1902));
+ s.Bind (new IPEndPoint (IPAddress.IPv6Any, NetworkHelpers.FindFreePort ()));
try {
s.SetSocketOption (SocketOptionLevel.IPv6, SocketOptionName.AddMembership,
new MulticastOption (mcast_addr));
IPAddress mcast_addr = IPAddress.Parse ("239.255.255.250");
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp)) {
- s.Bind (new IPEndPoint (IPAddress.Any, 1901));
+ s.Bind (new IPEndPoint (IPAddress.Any, NetworkHelpers.FindFreePort ()));
s.SetSocketOption (SocketOptionLevel.IP, SocketOptionName.AddMembership,
new MulticastOption (mcast_addr));
try {
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp)) {
MulticastOption option = new MulticastOption (mcast_addr);
- s.Bind (new IPEndPoint (IPAddress.Any, 1901));
+ s.Bind (new IPEndPoint (IPAddress.Any, NetworkHelpers.FindFreePort ()));
s.SetSocketOption (SocketOptionLevel.IP, SocketOptionName.AddMembership,
option);
s.SetSocketOption (SocketOptionLevel.IP, SocketOptionName.DropMembership,
IPAddress mcast_addr = IPAddress.Parse ("ff02::1");
using (Socket s = new Socket (AddressFamily.InterNetworkV6, SocketType.Dgram, ProtocolType.Udp)) {
- s.Bind (new IPEndPoint (IPAddress.IPv6Any, 1902));
+ s.Bind (new IPEndPoint (IPAddress.IPv6Any, NetworkHelpers.FindFreePort ()));
s.SetSocketOption (SocketOptionLevel.IPv6, SocketOptionName.AddMembership,
new IPv6MulticastOption (mcast_addr));
try {
public void Shutdown_NoConnect ()
{
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
- s.Bind (new IPEndPoint (IPAddress.Loopback, 0));
+ s.Bind (new IPEndPoint (IPAddress.Loopback, NetworkHelpers.FindFreePort ()));
s.Listen (1);
try {
s.Shutdown (SocketShutdown.Both);
}
}
+ [Test]
+ public void ConnectToIPV4EndPointUsingDualModelSocket () {
+ using (var server = new Socket (SocketType.Stream, ProtocolType.Tcp))
+ using (var client = new Socket (SocketType.Stream, ProtocolType.Tcp)) {
+ var host = new IPEndPoint (IPAddress.Loopback, NetworkHelpers.FindFreePort ());
+
+ server.Bind (host);
+ server.Listen (0);
+
+ var ep = server.LocalEndPoint as IPEndPoint;
+
+ client.Connect (ep);
+ client.Disconnect (true);
+
+ client.Connect (IPAddress.Loopback, ep.Port);
+ client.Disconnect (true);
+
+ client.Connect (new [] {IPAddress.Loopback}, ep.Port);
+ client.Disconnect (true);
+ }
+ }
+
+ [Test]
+ public void BeginConnectToIPV4EndPointUsingDualModelSocket () {
+ using (var server = new Socket (SocketType.Stream, ProtocolType.Tcp))
+ using (var client = new Socket (SocketType.Stream, ProtocolType.Tcp)) {
+ var host = new IPEndPoint (IPAddress.Loopback, NetworkHelpers.FindFreePort ());
+
+ server.Bind (host);
+ server.Listen (0);
+
+ var ep = server.LocalEndPoint as IPEndPoint;
+
+ BCCalledBack.Reset ();
+ var ar1 = client.BeginConnect (ep, BCCallback, client);
+ Assert.IsTrue (BCCalledBack.WaitOne (10000), "#1");
+ client.Disconnect (true);
+
+ BCCalledBack.Reset ();
+ var ar2 = client.BeginConnect (IPAddress.Loopback, ep.Port, BCCallback, client);
+ Assert.IsTrue (BCCalledBack.WaitOne (10000), "#2");
+ client.Disconnect (true);
+
+ BCCalledBack.Reset ();
+ var ar3 = client.BeginConnect (new [] {IPAddress.Loopback}, ep.Port, BCCallback, client);
+ Assert.IsTrue (BCCalledBack.WaitOne (10000), "#2");
+ client.Disconnect (true);
+ }
+ }
+
Socket StartSocketServer ()
{
Socket listenSocket = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
- listenSocket.Bind (new IPEndPoint (IPAddress.Loopback, 0));
+ listenSocket.Bind (new IPEndPoint (IPAddress.Loopback, NetworkHelpers.FindFreePort ()));
listenSocket.Listen (1);
listenSocket.BeginAccept (new AsyncCallback (ReceiveCallback), listenSocket);
/* see https://bugzilla.xamarin.com/show_bug.cgi?id=36941 */
using (Socket socket = new Socket (AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp)) {
- IPEndPoint end_point = new IPEndPoint (IPAddress.Any, 11000);
+ IPEndPoint end_point = new IPEndPoint (IPAddress.Any, NetworkHelpers.FindFreePort ());
socket.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1);
socket.Bind (end_point);
socket.SetSocketOption (SocketOptionLevel.IP, SocketOptionName.MulticastTimeToLive, 19);
projects / mono.git / blobdiff