static extern void socket_pool_queue (SocketAsyncCall d, SocketAsyncResult r);
public void Send ()
{
// Actual send() done in the runtime
if (result.error == 0) {
UpdateSendValues (result.Total);
if (result.Sock.disposed) {
result.Complete ();
return;
}
if (result.Size > 0) {
SocketAsyncCall sac = new SocketAsyncCall (this.Send);
sac.BeginInvoke (null, result);
return; // Have to finish writing everything. See bug #74475.
}
result.Total = send_so_far;
}
result.Complete ();
}
public void SendTo ()
{
int total = 0;
try {
total = result.Sock.SendTo_nochecks (result.Buffer,
result.Offset,
result.Size,
result.SockFlags,
result.EndPoint);
UpdateSendValues (total);
if (result.Size > 0) {
SocketAsyncCall sac = new SocketAsyncCall (this.SendTo);
sac.BeginInvoke (null, result);
return; // Have to finish writing everything. See bug #74475.
}
result.Total = send_so_far;
} catch (Exception e) {
result.Complete (e);
return;
}
result.Complete ();
}
public IAsyncResult BeginSend (IList<ArraySegment<byte>> buffers,
SocketFlags socketFlags,
AsyncCallback callback,
object state)
{
if (disposed && closed)
throw new ObjectDisposedException (GetType ().ToString ());
if (buffers == null)
throw new ArgumentNullException ("buffers");
if (!connected)
throw new SocketException ((int)SocketError.NotConnected);
SocketAsyncResult req;
lock (writeQ) {
req = new SocketAsyncResult (this, state, callback, SocketOperation.SendGeneric);
req.Buffers = buffers;
req.SockFlags = socketFlags;
writeQ.Enqueue (req);
if (writeQ.Count == 1) {
Worker worker = new Worker (req);
SocketAsyncCall sac = new SocketAsyncCall (worker.SendGeneric);
sac.BeginInvoke (null, req);
}
}
return(req);
}
public IAsyncResult BeginSendTo(byte[] buffer, int offset,
int size,
SocketFlags socket_flags,
EndPoint remote_end,
AsyncCallback callback,
object state) {
if (disposed && closed)
throw new ObjectDisposedException (GetType ().ToString ());
if (buffer == null)
throw new ArgumentNullException ("buffer");
if (offset < 0)
throw new ArgumentOutOfRangeException ("offset", "offset must be >= 0");
if (size < 0)
throw new ArgumentOutOfRangeException ("size", "size must be >= 0");
if (offset + size > buffer.Length)
throw new ArgumentOutOfRangeException ("offset, size", "offset + size exceeds the buffer length");
SocketAsyncResult req;
lock (writeQ) {
req = new SocketAsyncResult (this, state, callback, SocketOperation.SendTo);
req.Buffer = buffer;
req.Offset = offset;
req.Size = size;
req.SockFlags = socket_flags;
req.EndPoint = remote_end;
writeQ.Enqueue (req);
if (writeQ.Count == 1) {
Worker worker = new Worker (req);
SocketAsyncCall sac = new SocketAsyncCall (worker.SendTo);
sac.BeginInvoke (null, req);
}
}
return req;
}
public IAsyncResult BeginReceive(byte[] buffer, int offset,
int size,
SocketFlags socket_flags,
AsyncCallback callback,
object state) {
if (disposed && closed)
throw new ObjectDisposedException (GetType ().ToString ());
if (buffer == null)
throw new ArgumentNullException ("buffer");
if (offset < 0 || offset > buffer.Length)
throw new ArgumentOutOfRangeException ("offset");
if (size < 0 || offset + size > buffer.Length)
throw new ArgumentOutOfRangeException ("size");
SocketAsyncResult req;
lock (readQ) {
req = new SocketAsyncResult (this, state, callback, SocketOperation.Receive);
req.Buffer = buffer;
req.Offset = offset;
req.Size = size;
req.SockFlags = socket_flags;
readQ.Enqueue (req);
if (readQ.Count == 1) {
Worker worker = new Worker (req);
SocketAsyncCall sac = new SocketAsyncCall (worker.Receive);
sac.BeginInvoke (null, req);
}
}
return req;
}
public IAsyncResult BeginSend (byte[] buffer, int offset, int size, SocketFlags socket_flags,
AsyncCallback callback, object state)
{
if (disposed && closed)
throw new ObjectDisposedException (GetType ().ToString ());
if (buffer == null)
throw new ArgumentNullException ("buffer");
if (offset < 0)
throw new ArgumentOutOfRangeException ("offset", "offset must be >= 0");
if (size < 0)
throw new ArgumentOutOfRangeException ("size", "size must be >= 0");
if (offset + size > buffer.Length)
throw new ArgumentOutOfRangeException ("offset, size", "offset + size exceeds the buffer length");
#if NET_2_0
/* TODO: Check this exception in the 1.1 profile */
if (!connected)
throw new SocketException ((int)SocketError.NotConnected);
#endif
SocketAsyncResult req;
lock (writeQ) {
req = new SocketAsyncResult (this, state, callback, SocketOperation.Send);
req.Buffer = buffer;
req.Offset = offset;
req.Size = size;
req.SockFlags = socket_flags;
writeQ.Enqueue (req);
if (writeQ.Count == 1) {
Worker worker = new Worker (req);
SocketAsyncCall sac = new SocketAsyncCall (worker.Send);
sac.BeginInvoke (null, req);
}
}
return req;
}
public IAsyncResult BeginConnect (IPAddress[] addresses,
int port,
AsyncCallback callback,
object state)
{
if (disposed && closed)
throw new ObjectDisposedException (GetType ().ToString ());
if (addresses == null)
throw new ArgumentNullException ("addresses");
if (this.AddressFamily != AddressFamily.InterNetwork &&
this.AddressFamily != AddressFamily.InterNetworkV6)
throw new NotSupportedException ("This method is only valid for addresses in the InterNetwork or InterNetworkV6 families");
if (islistening)
throw new InvalidOperationException ();
SocketAsyncResult req = new SocketAsyncResult (this, state, callback, SocketOperation.Connect);
req.Addresses = addresses;
req.Port = port;
connected = false;
Worker worker = new Worker (req);
SocketAsyncCall sac = new SocketAsyncCall (worker.Connect);
sac.BeginInvoke (null, req);
return(req);
}
public IAsyncResult BeginDisconnect (bool reuseSocket,
AsyncCallback callback,
object state)
{
if (disposed && closed)
throw new ObjectDisposedException (GetType ().ToString ());
SocketAsyncResult req = new SocketAsyncResult (this, state, callback, SocketOperation.Disconnect);
req.ReuseSocket = reuseSocket;
Worker worker = new Worker (req);
SocketAsyncCall sac = new SocketAsyncCall (worker.Disconnect);
sac.BeginInvoke (null, req);
return(req);
}
public IAsyncResult BeginAccept (Socket acceptSocket,
int receiveSize,
AsyncCallback callback,
object state)
{
if (disposed && closed)
throw new ObjectDisposedException (GetType ().ToString ());
if (receiveSize < 0)
throw new ArgumentOutOfRangeException ("receiveSize", "receiveSize is less than zero");
if (acceptSocket != null) {
if (acceptSocket.disposed && acceptSocket.closed)
throw new ObjectDisposedException (acceptSocket.GetType ().ToString ());
if (acceptSocket.IsBound)
throw new InvalidOperationException ();
/* For some reason the MS runtime
* barfs if the new socket is not TCP,
* even though it's just about to blow
* away all those parameters
*/
if (acceptSocket.ProtocolType != ProtocolType.Tcp)
throw new SocketException ((int)SocketError.InvalidArgument);
}
SocketAsyncResult req = new SocketAsyncResult (this, state, callback, SocketOperation.AcceptReceive);
Worker worker = new Worker (req);
SocketAsyncCall sac = new SocketAsyncCall (worker.AcceptReceive);
req.Buffer = new byte[receiveSize];
req.Offset = 0;
req.Size = receiveSize;
req.SockFlags = SocketFlags.None;
req.AcceptSocket = acceptSocket;
sac.BeginInvoke (null, req);
return(req);
}
public IAsyncResult BeginConnect(EndPoint end_point,
AsyncCallback callback,
object state) {
if (disposed && closed)
throw new ObjectDisposedException (GetType ().ToString ());
if (end_point == null)
throw new ArgumentNullException ("end_point");
SocketAsyncResult req = new SocketAsyncResult (this, state, callback, SocketOperation.Connect);
req.EndPoint = end_point;
// Bug #75154: Connect() should not succeed for .Any addresses.
if (end_point is IPEndPoint) {
IPEndPoint ep = (IPEndPoint) end_point;
if (ep.Address.Equals (IPAddress.Any) || ep.Address.Equals (IPAddress.IPv6Any)) {
req.Complete (new SocketException ((int) SocketError.AddressNotAvailable), true);
return req;
}
}
int error = 0;
if (!blocking) {
SocketAddress serial = end_point.Serialize ();
Connect_internal (socket, serial, out error);
if (error == 0) {
// succeeded synch
connected = true;
req.Complete (true);
} else if (error != (int) SocketError.InProgress && error != (int) SocketError.WouldBlock) {
// error synch
connected = false;
req.Complete (new SocketException (error), true);
}
}
if (blocking || error == (int) SocketError.InProgress || error == (int) SocketError.WouldBlock) {
// continue asynch
connected = false;
Worker worker = new Worker (req);
SocketAsyncCall sac = new SocketAsyncCall (worker.Connect);
sac.BeginInvoke (null, req);
}
return(req);
}
public IAsyncResult BeginAccept (int receiveSize,
AsyncCallback callback,
object state)
{
if (disposed && closed)
throw new ObjectDisposedException (GetType ().ToString ());
if (receiveSize < 0)
throw new ArgumentOutOfRangeException ("receiveSize", "receiveSize is less than zero");
SocketAsyncResult req = new SocketAsyncResult (this, state, callback, SocketOperation.AcceptReceive);
Worker worker = new Worker (req);
SocketAsyncCall sac = new SocketAsyncCall (worker.AcceptReceive);
req.Buffer = new byte[receiveSize];
req.Offset = 0;
req.Size = receiveSize;
req.SockFlags = SocketFlags.None;
sac.BeginInvoke (null, req);
return(req);
}
public IAsyncResult BeginAccept(AsyncCallback callback,
object state)
{
if (disposed && closed)
throw new ObjectDisposedException (GetType ().ToString ());
#if NET_2_0
/* FIXME: check the 1.1 docs for this too */
if (!isbound || !islistening)
throw new InvalidOperationException ();
#endif
SocketAsyncResult req = new SocketAsyncResult (this, state, callback, SocketOperation.Accept);
Worker worker = new Worker (req);
SocketAsyncCall sac = new SocketAsyncCall (worker.Accept);
sac.BeginInvoke (null, req);
return(req);
}
static void socket_pool_queue(SocketAsyncCall d, SocketAsyncResult r)
{
throw new System.NotImplementedException();
}
static extern void socket_pool_queue(SocketAsyncCall d, SocketAsyncResult r);
static void socket_pool_queue (SocketAsyncCall d, SocketAsyncResult r)
{
throw new System.NotImplementedException();
}
