Пример #1
0
 public static Task<int> ReceiveAsync(
     this Socket socket, 
     IList<ArraySegment<byte>> buffers, 
     SocketFlags socketFlags)
 {
     return Task<int>.Factory.FromAsync(socket.BeginReceive, socket.EndReceive, buffers, socketFlags, null);
 }
Пример #2
0
		private static int Receive_internal (IntPtr sock,
		WSABUF[] bufarray,
		SocketFlags flags,
		out int error)
		{
			throw new System.NotImplementedException();
		}
        public static IObservable<ByteBuffer> ToClientObservable(this Socket socket, int size, SocketFlags socketFlags)
        {
            return Observable.Create<ByteBuffer>(async (observer, token) =>
            {
                var buffer = new byte[size];

                try
                {
                    while (!token.IsCancellationRequested)
                    {
                        var received = await socket.ReceiveAsync(buffer, 0, size, socketFlags);
                        if (received == 0)
                            break;

                        observer.OnNext(new ByteBuffer(buffer, received));
                    }

                    observer.OnCompleted();
                }
                catch (Exception error)
                {
                    observer.OnError(error);
                }
            });
        }
        public static IObservable<DisposableByteBuffer> ToFrameClientObservable(this Socket socket, SocketFlags socketFlags, BufferManager bufferManager)
        {
            return Observable.Create<DisposableByteBuffer>(async (observer, token) =>
            {
                var headerBuffer = new byte[sizeof(int)];

                try
                {
                    while (!token.IsCancellationRequested)
                    {
                        if (await socket.ReceiveCompletelyAsync(headerBuffer, headerBuffer.Length, socketFlags, token) != headerBuffer.Length)
                            break;
                        var length = BitConverter.ToInt32(headerBuffer, 0);

                        var buffer = bufferManager.TakeBuffer(length);
                        if (await socket.ReceiveCompletelyAsync(buffer, length, socketFlags, token) != length)
                            break;

                        observer.OnNext(new DisposableByteBuffer(buffer, length, Disposable.Create(() => bufferManager.ReturnBuffer(buffer))));
                    }

                    observer.OnCompleted();

                    socket.Close();
                }
                catch (Exception error)
                {
                    observer.OnError(error);
                }
            });
        }
Пример #5
0
		public void Init (Socket socket, AsyncCallback callback, object state, SocketOperation operation)
		{
			base.Init (callback, state);

			this.socket = socket;
			this.handle = socket != null ? socket.Handle : IntPtr.Zero;
			this.operation = operation;

			DelayedException = null;

			EndPoint = null;
			Buffer = null;
			Offset = 0;
			Size = 0;
			SockFlags = SocketFlags.None;
			AcceptSocket = null;
			Addresses = null;
			Port = 0;
			Buffers = null;
			ReuseSocket = false;
			CurrentAddress = 0;

			AcceptedSocket = null;
			Total = 0;

			error = 0;

			EndCalled = 0;
		}
Пример #6
0
		internal IAsyncResult BeginMultipleSend (BufferOffsetSize[] buffers, SocketFlags socketFlags, AsyncCallback callback, object state)
		{
			var segments = new ArraySegment<byte> [buffers.Length];
			for (int i = 0; i < buffers.Length; i++)
				segments [i] = new ArraySegment<byte> (buffers [i].Buffer, buffers [i].Offset, buffers [i].Size);
			return BeginSend (segments, socketFlags, callback, state);
		}
Пример #7
0
		internal void MultipleSend (BufferOffsetSize[] buffers, SocketFlags socketFlags)
		{
			var segments = new ArraySegment<byte> [buffers.Length];
			for (int i = 0; i < buffers.Length; i++)
				segments [i] = new ArraySegment<byte> (buffers [i].Buffer, buffers [i].Offset, buffers [i].Size);
			Send (segments, socketFlags);
		}
Пример #8
0
        public static int Receive(this Socket socket, byte[] buffer, int offset, int size, int timeout, SocketFlags socketFlags)
        {
            if (!WaitForData(socket, timeout))
                return 0;

            return socket.Receive(buffer, offset, size, socketFlags);
        }
Пример #9
0
        /// <summary>
        /// Asynchronously receives data from a connected socket.
        /// </summary>
        /// <param name="socket">
        /// The socket from which to read data.
        /// </param>
        /// <param name="buffer">
        /// An array of type <see cref="byte"/> that is the storage location for
        /// the received data.
        /// </param>
        /// <param name="offset">
        /// The zero-based position in the <paramref name="buffer"/> parameter at which to
        /// start storing data.
        /// </param>
        /// <param name="size">
        /// The number of bytes to receive.
        /// </param>
        /// <param name="socketFlags">
        /// A bitwise combination of the <see cref="SocketFlags"/> values.
        /// </param>
        /// <returns>
        /// The number of bytes received.
        /// </returns>
        public static Task<int> ReceiveAsync(
            this Socket socket,
            byte[] buffer,
            int offset,
            int size,
            SocketFlags socketFlags)
        {
            var tcs = new TaskCompletionSource<int>(socket);

            socket.BeginReceive(
                buffer,
                offset,
                size,
                socketFlags,
                iar =>
                {
                    var t = (TaskCompletionSource<int>)iar.AsyncState;
                    var s = (Socket)t.Task.AsyncState;
                    try
                    {
                        t.TrySetResult(s.EndReceive(iar));
                    }
                    catch (Exception ex)
                    {
                        t.TrySetException(ex);
                    }
                },
                tcs);

            return tcs.Task;
        }
		private static int Send_internal(IntPtr sock,
		byte[] buf, int offset,
		int count,
		SocketFlags flags,
		out int error)
		{
			throw new System.NotImplementedException();
		}
Пример #11
0
        /// <summary>
        /// Initializes a new instance of the <see cref="UDPClient"/> class.
        /// </summary>
        /// <param name="ep">The ep.</param>
        public UDPClient(IPAddress IPAddress, UInt16 Port, Boolean Broadcast = false, SocketFlags Socketflags = SocketFlags.None)
            : this(Broadcast, Socketflags)
        {
            this.InternalIPAddress  = IPAddress;
            this.InternalPort       = Port;

            InternalSocket.Connect(new IPEndPoint(IPAddress, Port));
        }
Пример #12
0
 public IAsyncResult BeginReceive(IList<ArraySegment<byte>> buffers, SocketFlags socketFlags, AsyncCallback callback, object state)
 {
     Encoding.UTF8.GetBytes(_request).CopyTo(buffers[0].Array, 0);
     var result = new Mock<IAsyncResult>();
     result.Setup(r => r.AsyncState).Returns(state);
     callback(result.Object);
     return result.Object;
 }
Пример #13
0
 /// <summary>
 /// Sends data asynchronously to a specific remote host
 /// </summary>
 /// <param name="socket">socket</param>
 /// <param name="buffer">an array of type System.Byte that contains the data to send</param>
 /// <param name="offset">the zero-based position in buffer at which to begin sending data</param>
 /// <param name="size">the number of bytes to send</param>
 /// <param name="flags">a bitwise combination of the System.Net.Sockets.SocketFlags values.</param>
 /// <param name="remoteEP">an System.Net.EndPoint that represents the remote device</param>
 /// <returns>Task</returns>
 public static Task SendToAsync(this Socket socket, byte[] buffer, int offset, int size, SocketFlags flags, EndPoint remoteEP)
 {
     return Task<int>.Factory.FromAsync(
         (ac, state) => socket.BeginSendTo(buffer, offset, size, flags, remoteEP, ac, state),
         socket.EndSendTo,
         null,
         TaskCreationOptions.None);
 }
Пример #14
0
 /// <summary>
 /// Receives data from connected <see cref="CrosSocket"/> and stores it into the buffer using specified <see cref="SocketFlags"/>, buffer is resized to data received
 /// </summary>
 /// <param name="buffer">Array which will contain received data</param>
 /// <param name="socketFlags">SocketFlags to use</param>
 /// <returns>Number of bytes received</returns>
 public virtual int CrosReceive(ref byte[] buffer, SocketFlags socketFlags)
 {
     byte[] lengthBytes = new byte[4];
     base.Receive(lengthBytes, socketFlags);
     int dataSize = BitConverter.ToInt32(lengthBytes, 0);
     Array.Resize(ref buffer, dataSize);
     return base.Receive(buffer, socketFlags);
 }
Пример #15
0
 public int Send(byte[] data, int offset, int length, SocketFlags flags) {
     lock (this) {
         if (_shuttedDown_Send)
             return 0;
         else
             return _socket.Send(data, offset, length, flags);
     }
 }
 public static IObserver<ByteBuffer> ToClientObserver(this Socket socket, int size, SocketFlags socketFlags)
 {
     return Observer.Create<ByteBuffer>(async buffer =>
     {
         var sent = 0;
         while (sent < buffer.Length)
             sent += await socket.SendAsync(buffer.Bytes, sent, buffer.Length - sent, socketFlags);
     });
 }
Пример #17
0
 public static void ReceiveFromAPM(this Socket socket, byte[] buffer, int offset, int count, SocketFlags flags, EndPoint remoteEndpoint, Action<int, EndPoint> handler)
 {
     var callback = new AsyncCallback(asyncResult =>
     {
         int received = ((Socket)asyncResult.AsyncState).EndReceiveFrom(asyncResult, ref remoteEndpoint);
         handler(received, remoteEndpoint);
     });
     socket.BeginReceiveFrom(buffer, offset, count, flags, ref remoteEndpoint, callback, socket);
 }
        //
        // SetUnmanagedStructures -
        // Fills in Overlapped Structures used in an Async Overlapped Winsock call
        //   these calls are outside the runtime and are unmanaged code, so we need
        //   to prepare specific structures and ints that lie in unmanaged memory
        //   since the Overlapped calls can be Async
        //

        internal void SetUnmanagedStructures(byte[] buffer, int offset, int size, SocketAddress socketAddress, SocketFlags socketFlags)
        {
            m_MessageBuffer = new byte[s_WSAMsgSize];
            m_WSABufferArray = new byte[s_WSABufferSize];

            //ipv4 or ipv6?
            IPAddress ipAddress = (socketAddress.Family == AddressFamily.InterNetworkV6 
                ? socketAddress.GetIPAddress() : null);
            bool ipv4 = (((Socket)AsyncObject).AddressFamily == AddressFamily.InterNetwork
                || (ipAddress != null && ipAddress.IsIPv4MappedToIPv6)); // DualMode
            bool ipv6 = ((Socket)AsyncObject).AddressFamily == AddressFamily.InterNetworkV6;

            //prepare control buffer
            if (ipv4) {
                m_ControlBuffer = new byte[s_ControlDataSize];
            }
            else if (ipv6) {
                m_ControlBuffer = new byte[s_ControlDataIPv6Size];
            }

            //pin buffers
            object[] objectsToPin = new object[(m_ControlBuffer != null)?5:4];
            objectsToPin[0] = buffer;
            objectsToPin[1] = m_MessageBuffer;
            objectsToPin[2] = m_WSABufferArray;
            
            //prepare socketaddress buffer
            m_SocketAddress = socketAddress;
            m_SocketAddress.CopyAddressSizeIntoBuffer();
            objectsToPin[3] = m_SocketAddress.m_Buffer;
                
            if(m_ControlBuffer != null){
                objectsToPin[4] = m_ControlBuffer;
            }

            base.SetUnmanagedStructures(objectsToPin);

            //prepare data buffer
            m_WSABuffer = (WSABuffer*) Marshal.UnsafeAddrOfPinnedArrayElement(m_WSABufferArray, 0);
            m_WSABuffer->Length = size;
            m_WSABuffer->Pointer = Marshal.UnsafeAddrOfPinnedArrayElement(buffer, offset);


            //setup structure
            m_Message = (UnsafeNclNativeMethods.OSSOCK.WSAMsg*) Marshal.UnsafeAddrOfPinnedArrayElement(m_MessageBuffer, 0);
            m_Message->socketAddress = Marshal.UnsafeAddrOfPinnedArrayElement(m_SocketAddress.m_Buffer,0);
            m_Message->addressLength = (uint)m_SocketAddress.Size;
            m_Message->buffers = Marshal.UnsafeAddrOfPinnedArrayElement(m_WSABufferArray,0);
            m_Message->count = 1;

            if(m_ControlBuffer != null){
                m_Message->controlBuffer.Pointer = Marshal.UnsafeAddrOfPinnedArrayElement(m_ControlBuffer, 0);
                m_Message->controlBuffer.Length = m_ControlBuffer.Length;
            }

            m_Message->flags = socketFlags;
        }
Пример #19
0
        public static SocketError Send(this UDPClient UDPClient, String UDPPacketString, Encoding Encoding = null, SocketFlags SocketFlags = SocketFlags.None)
        {
            if (Encoding == null)
                Encoding = Encoding.UTF8;

            var UDPPacketData = Encoding.GetBytes(UDPPacketString);

            return UDPClient.Send(UDPPacketData, SocketFlags);
        }
 public static IObserver<DisposableByteBuffer> ToFrameClientObserver(this Socket socket, SocketFlags socketFlags, CancellationToken token)
 {
     return Observer.Create<DisposableByteBuffer>(async managedBuffer =>
     {
         var headerBuffer = BitConverter.GetBytes(managedBuffer.Length);
         await socket.SendCompletelyAsync(headerBuffer, headerBuffer.Length, socketFlags, token);
         await socket.SendCompletelyAsync(managedBuffer.Bytes, managedBuffer.Length, socketFlags, token);
     });
 }
        // SetUnmanagedStructures
        //
        // Fills in overlapped Structures used in an async overlapped Winsock call.
        // These calls are outside the runtime and are unmanaged code, so we need
        // to prepare specific structures and ints that lie in unmanaged memory
        // since the overlapped calls may complete asynchronously.
        internal void SetUnmanagedStructures(byte[] buffer, int offset, int size, Internals.SocketAddress socketAddress, SocketFlags socketFlags)
        {
            _messageBuffer = new byte[s_wsaMsgSize];
            _wsaBufferArray = new byte[s_wsaBufferSize];

            bool ipv4, ipv6;
            Socket.GetIPProtocolInformation(((Socket)AsyncObject).AddressFamily, socketAddress, out ipv4, out ipv6);

            // Prepare control buffer.
            if (ipv4)
            {
                _controlBuffer = new byte[s_controlDataSize];
            }
            else if (ipv6)
            {
                _controlBuffer = new byte[s_controlDataIPv6Size];
            }

            // Pin buffers.
            object[] objectsToPin = new object[(_controlBuffer != null) ? 5 : 4];
            objectsToPin[0] = buffer;
            objectsToPin[1] = _messageBuffer;
            objectsToPin[2] = _wsaBufferArray;

            // Prepare socketaddress buffer.
            _socketAddress = socketAddress;
            _socketAddress.CopyAddressSizeIntoBuffer();
            objectsToPin[3] = _socketAddress.Buffer;

            if (_controlBuffer != null)
            {
                objectsToPin[4] = _controlBuffer;
            }

            base.SetUnmanagedStructures(objectsToPin);

            // Prepare data buffer.
            _wsaBuffer = (WSABuffer*)Marshal.UnsafeAddrOfPinnedArrayElement(_wsaBufferArray, 0);
            _wsaBuffer->Length = size;
            _wsaBuffer->Pointer = Marshal.UnsafeAddrOfPinnedArrayElement(buffer, offset);


            // Setup structure.
            _message = (Interop.Winsock.WSAMsg*)Marshal.UnsafeAddrOfPinnedArrayElement(_messageBuffer, 0);
            _message->socketAddress = Marshal.UnsafeAddrOfPinnedArrayElement(_socketAddress.Buffer, 0);
            _message->addressLength = (uint)_socketAddress.Size;
            _message->buffers = Marshal.UnsafeAddrOfPinnedArrayElement(_wsaBufferArray, 0);
            _message->count = 1;

            if (_controlBuffer != null)
            {
                _message->controlBuffer.Pointer = Marshal.UnsafeAddrOfPinnedArrayElement(_controlBuffer, 0);
                _message->controlBuffer.Length = _controlBuffer.Length;
            }

            _message->flags = socketFlags;
        }
Пример #22
0
        public static void SendTo(this UDPClient UDPClient, String UDPPacketString, IIPAddress RemoteIPAddress, IPPort IPPort, Encoding Encoding = null, SocketFlags SocketFlags = SocketFlags.None)
        {
            if (Encoding == null)
                Encoding = Encoding.UTF8;

            var UDPPacketData = Encoding.GetBytes(UDPPacketString);
            var RemoteIPEndPoint = new IPEndPoint(new IPAddress(RemoteIPAddress.GetBytes()), IPPort.ToInt32());

            UDPClient.SendTo(UDPPacketData, RemoteIPEndPoint, SocketFlags);
        }
Пример #23
0
        public static Task<int> ReceiveAsync(this Socket socket, byte[] buffer, int offset, int size, SocketFlags flags = SocketFlags.None)
        {
            if (buffer == null) throw new ArgumentNullException("buffer");

            return Task<int>.Factory.FromAsync(
                (ac, state) => socket.BeginReceive(buffer, offset, size, flags, ac, state),
                socket.EndReceive,
                null,
                TaskCreationOptions.None);
        }
Пример #24
0
        public void CompletionCallback(int numBytes, byte[] socketAddress, int socketAddressSize, SocketFlags receivedFlags, SocketError errorCode)
        {
            if (_socketAddress != null)
            {
                Debug.Assert(socketAddress == null || _socketAddress.Buffer == socketAddress);
                _socketAddressSize = socketAddressSize;
            }

            base.CompletionCallback(numBytes, errorCode);
        }
Пример #25
0
		private static int RecvFrom_internal(IntPtr sock,
		byte[] buffer,
		int offset,
		int count,
		SocketFlags flags,
		ref SocketAddress sockaddr,
		out int error)
		{
			throw new System.NotImplementedException();
		}
        public void CompletionCallback(int numBytes, byte[] socketAddress, int socketAddressSize, SocketFlags receivedFlags, IPPacketInformation ipPacketInformation, SocketError errorCode)
        {
            Debug.Assert(_socketAddress != null);
            Debug.Assert(socketAddress == null || _socketAddress.Buffer == socketAddress);

            _socketAddressSize = socketAddressSize;
            _socketFlags = receivedFlags;
            _ipPacketInformation = ipPacketInformation;

            base.CompletionCallback(numBytes, errorCode);
        }
Пример #27
0
        public static Task<int> SendAsync(this Socket socket, IList<ArraySegment<byte>> buffers, SocketFlags flags = SocketFlags.None)
        {
            if (socket == null) throw new ArgumentNullException("socket");
            if (buffers == null) throw new ArgumentNullException("buffers");

            return Task<int>.Factory.FromAsync(
                (ac, state) => socket.BeginSend(buffers, flags, ac, state),
                socket.EndSend,
                null,
                TaskCreationOptions.None);
        }
Пример #28
0
 public bool Write(byte[] buffer, int offset, int count, SocketFlags flag = SocketFlags.None)
 {
     try
     {
         _clientSocket.Send(buffer, offset, count, flag);
         return true;
     }
     catch
     {
         return false;
     }
 }
Пример #29
0
 public static Task<int> ReceiveAsync(this Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags)
 {
     return Task<int>.Factory.FromAsync(
         (callback, state) => socket.BeginReceive(
                                         buffer.Array, 
                                         buffer.Offset, 
                                         buffer.Count, 
                                         socketFlags, 
                                         callback, 
                                         state), 
         socket.EndReceive, null);
 }
Пример #30
0
        public static Task<int> ReceiveAsync(this Socket socket,
            byte[] buffer, int offset, int size, SocketFlags socketFlags)
        {
            if (socket == null) throw new ArgumentNullException(nameof(socket));

            var tcs = new TaskCompletionSource<int>();
            socket.BeginReceive(buffer, offset, size, socketFlags, ar =>
            {
                try { tcs.TrySetResult(socket.EndReceive(ar)); }
                catch (Exception e) { tcs.TrySetException(e);  }
            }, state: null);
            return tcs.Task;
        }
Пример #31
0
        public static SocketError Send(SafeCloseSocket handle, IList <ArraySegment <byte> > buffers, SocketFlags socketFlags, out int bytesTransferred)
        {
            int count = buffers.Count;

            WSABuffer[] WSABuffers   = new WSABuffer[count];
            GCHandle[]  objectsToPin = null;

            try
            {
                objectsToPin = new GCHandle[count];
                for (int i = 0; i < count; ++i)
                {
                    ArraySegment <byte> buffer = buffers[i];
                    RangeValidationHelpers.ValidateSegment(buffer);
                    objectsToPin[i]       = GCHandle.Alloc(buffer.Array, GCHandleType.Pinned);
                    WSABuffers[i].Length  = buffer.Count;
                    WSABuffers[i].Pointer = Marshal.UnsafeAddrOfPinnedArrayElement(buffer.Array, buffer.Offset);
                }

                // This may throw ObjectDisposedException.
                SocketError errorCode = Interop.Winsock.WSASend(
                    handle.DangerousGetHandle(),
                    WSABuffers,
                    count,
                    out bytesTransferred,
                    socketFlags,
                    SafeNativeOverlapped.Zero,
                    IntPtr.Zero);

                if ((SocketError)errorCode == SocketError.SocketError)
                {
                    errorCode = GetLastSocketError();
                }

                return(errorCode);
            }
            finally
            {
                if (objectsToPin != null)
                {
                    for (int i = 0; i < objectsToPin.Length; ++i)
                    {
                        if (objectsToPin[i].IsAllocated)
                        {
                            objectsToPin[i].Free();
                        }
                    }
                }
            }
        }
Пример #32
0
 public static int Receive(this Socket socket, ArraySegment <byte> segment, SocketFlags socketFlags)
 {
     return(socket.Receive(segment.Array, segment.Offset, segment.Count, socketFlags));
 }
Пример #33
0
 public static Task <int> SendToAsync(this Socket socket, byte[] buffer, int offset, int count, SocketFlags flags, EndPoint remoteEndPoint)
 {
     return(Task <int> .Factory.FromAsync(
                socket.BeginSendTo(buffer, offset, count, flags, remoteEndPoint, null, null),
                socket.EndSendTo
                ));
 }
Пример #34
0
        public static Task <int> ReceiveAsync(this Socket socket, byte[] buffer, int offset, int size, SocketFlags flags)
        {
            var tcs = new TaskCompletionSource <int>(socket);

            socket.BeginReceive(buffer, offset, size, flags, iar =>
            {
                var t = (TaskCompletionSource <int>)iar.AsyncState;
                var s = (Socket)t.Task.AsyncState;
                try
                {
                    t.TrySetResult(s.EndReceive(iar));
                }
                catch (Exception exc)
                {
                    t.TrySetException(exc);
                }
            }, tcs);
            return(tcs.Task);
        }
Пример #35
0
 private extern static int Receive_internal(IntPtr sock,
                                            byte[] buffer,
                                            int offset,
                                            int count,
                                            SocketFlags flags,
                                            out int error);
Пример #36
0
        private void ReceiveMessageFromCompletionCallback(int bytesTransferred, byte[] socketAddress, int socketAddressSize, SocketFlags receivedFlags, IPPacketInformation ipPacketInformation, SocketError errorCode)
        {
            Debug.Assert(_socketAddress != null, "Expected non-null _socketAddress");
            Debug.Assert(socketAddress == null || _socketAddress.Buffer == socketAddress, $"Unexpected socketAddress: {socketAddress}");

            _socketAddressSize            = socketAddressSize;
            _receivedFlags                = receivedFlags;
            _receiveMessageFromPacketInfo = ipPacketInformation;

            CompletionCallback(bytesTransferred, errorCode);
        }
Пример #37
0
        /// <summary>
        /// Receive
        /// </summary>
        /// <param name="clientSocket">Socket</param>
        /// <param name="buffer">Reusable SocketAsyncEventArgs buffer</param>
        /// <param name="numBytes">Size in bytes</param>
        /// <param name="flags">Socket flags</param>
        /// <returns></returns>
        public static bool ReceiveFully(Socket clientSocket, byte[] buffer, int numBytes, SocketFlags flags = SocketFlags.None)
        {
            Debug.Assert(numBytes <= buffer.Length);
            var totalReceived = 0;

            do
            {
                var received = clientSocket.Receive(buffer, totalReceived, numBytes - totalReceived, flags);
                if (received == 0)
                {
                    return(false);
                }
                totalReceived += received;
            } while (totalReceived < numBytes);

            return(true);
        }
Пример #38
0
 public IAsyncResult BeginSend(Collections.Generic.IList <ArraySegment <byte> > buffers, SocketFlags socketFlags, out SocketError errorCode, AsyncCallback callback, object state)
 {
     throw null;
 }
Пример #39
0
 public IAsyncResult BeginSend(byte[] buffer, int offset, int size, SocketFlags socketFlags, out SocketError errorCode, AsyncCallback callback, object state)
 {
     throw null;
 }
Пример #40
0
 public int EndReceiveMessageFrom(IAsyncResult asyncResult, ref SocketFlags socketFlags, ref EndPoint endPoint, out IPPacketInformation ipPacketInformation)
 {
     throw null;
 }
Пример #41
0
 public IAsyncResult BeginSendTo(byte[] buffer, int offset, int size, SocketFlags socketFlags, EndPoint remoteEP, AsyncCallback callback, object state)
 {
     throw null;
 }
Пример #42
0
        public static unsafe SocketError ReceiveAsync(SafeCloseSocket handle, IList <ArraySegment <byte> > buffers, SocketFlags socketFlags, OverlappedAsyncResult asyncResult)
        {
            // Set up asyncResult for overlapped WSASend.
            asyncResult.SetUnmanagedStructures(buffers);
            try
            {
                // This can throw ObjectDisposedException.
                int         bytesTransferred;
                SocketError errorCode = Interop.Winsock.WSARecv(
                    handle,
                    asyncResult._wsaBuffers,
                    asyncResult._wsaBuffers.Length,
                    out bytesTransferred,
                    ref socketFlags,
                    asyncResult.OverlappedHandle,
                    IntPtr.Zero);

                return(asyncResult.ProcessOverlappedResult(errorCode == SocketError.Success, bytesTransferred));
            }
            catch
            {
                asyncResult.ReleaseUnmanagedStructures();
                throw;
            }
        }
Пример #43
0
        public static unsafe SocketError ReceiveFromAsync(SafeCloseSocket handle, byte[] buffer, int offset, int count, SocketFlags socketFlags, Internals.SocketAddress socketAddress, OverlappedAsyncResult asyncResult)
        {
            // Set up asyncResult for overlapped WSARecvFrom.
            asyncResult.SetUnmanagedStructures(buffer, offset, count, socketAddress, true);
            try
            {
                int         bytesTransferred;
                SocketError errorCode = Interop.Winsock.WSARecvFrom(
                    handle,
                    ref asyncResult._singleBuffer,
                    1,
                    out bytesTransferred,
                    ref socketFlags,
                    asyncResult.GetSocketAddressPtr(),
                    asyncResult.GetSocketAddressSizePtr(),
                    asyncResult.OverlappedHandle,
                    IntPtr.Zero);

                return(asyncResult.ProcessOverlappedResult(errorCode == SocketError.Success, bytesTransferred));
            }
            catch
            {
                asyncResult.ReleaseUnmanagedStructures();
                throw;
            }
        }
Пример #44
0
        public static unsafe SocketError ReceiveMessageFromAsync(Socket socket, SafeCloseSocket handle, byte[] buffer, int offset, int count, SocketFlags socketFlags, Internals.SocketAddress socketAddress, ReceiveMessageOverlappedAsyncResult asyncResult)
        {
            asyncResult.SetUnmanagedStructures(buffer, offset, count, socketAddress, socketFlags);
            try
            {
                int         bytesTransfered;
                SocketError errorCode = (SocketError)socket.WSARecvMsg(
                    handle,
                    Marshal.UnsafeAddrOfPinnedArrayElement(asyncResult._messageBuffer, 0),
                    out bytesTransfered,
                    asyncResult.OverlappedHandle,
                    IntPtr.Zero);

                return(asyncResult.ProcessOverlappedResult(errorCode == SocketError.Success, bytesTransfered));
            }
            catch
            {
                asyncResult.ReleaseUnmanagedStructures();
                throw;
            }
        }
Пример #45
0
        private void TransferCompletionCallback(int bytesTransferred, byte[] socketAddress, int socketAddressSize, SocketFlags receivedFlags, SocketError socketError)
        {
            Debug.Assert(socketAddress == null || socketAddress == _socketAddress.Buffer, $"Unexpected socketAddress: {socketAddress}");
            _socketAddressSize = socketAddressSize;
            _receivedFlags     = receivedFlags;

            CompletionCallback(bytesTransferred, socketError);
        }
Пример #46
0
 public IAsyncResult BeginReceiveMessageFrom(byte[] buffer, int offset, int size, SocketFlags socketFlags, ref EndPoint remoteEP, AsyncCallback callback, object state)
 {
     throw null;
 }
Пример #47
0
 private void InnerStartOperationSendTo()
 {
     _receivedFlags     = System.Net.Sockets.SocketFlags.None;
     _socketAddressSize = 0;
 }
Пример #48
0
 public IAsyncResult BeginReceive(Collections.Generic.IList <ArraySegment <byte> > buffers, SocketFlags socketFlags, AsyncCallback callback, object state)
 {
     throw null;
 }
Пример #49
0
 private void InnerStartOperationReceiveMessageFrom()
 {
     _receiveMessageFromPacketInfo = default(IPPacketInformation);
     _receivedFlags     = System.Net.Sockets.SocketFlags.None;
     _socketAddressSize = 0;
 }
Пример #50
0
 public IAsyncResult BeginReceive(byte[] buffer, int offset, int size, SocketFlags socketFlags, AsyncCallback callback, object state)
 {
     throw null;
 }
Пример #51
0
        /// <summary>
        /// Send
        /// </summary>
        /// <param name="clientSocket">Socket</param>
        /// <param name="buffer">Byte array to send</param>
        /// <param name="offset">Offset</param>
        /// <param name="size">Size to send</param>
        /// <param name="flags">Socket flags</param>
        public static void SendFully(Socket clientSocket, byte[] buffer, int offset, int size, SocketFlags flags = SocketFlags.None)
        {
            Debug.Assert(offset >= 0 && offset < buffer.Length && offset + size <= buffer.Length);
            var totalSent = 0;

            do
            {
                var sent = clientSocket.Send(buffer, offset + totalSent, size - totalSent, flags);
                totalSent += sent;
            } while (totalSent < size);
        }
Пример #52
0
        private void ReadUdpRequestAsync(object parameter)
        {
            Socket   udpListener = parameter as Socket;
            EndPoint remoteEP    = new IPEndPoint(IPAddress.Any, 0);

            byte[] recvBuffer = new byte[576];
            int    bytesRecv;

            try
            {
                bool processOnlyUnicastMessages = !(udpListener.LocalEndPoint as IPEndPoint).Address.Equals(IPAddress.Any); //only 0.0.0.0 ip should process broadcast to avoid duplicate offers on Windows

                while (true)
                {
                    SocketFlags         flags = SocketFlags.None;
                    IPPacketInformation ipPacketInformation;

                    try
                    {
                        bytesRecv = udpListener.ReceiveMessageFrom(recvBuffer, 0, recvBuffer.Length, ref flags, ref remoteEP, out ipPacketInformation);
                    }
                    catch (SocketException ex)
                    {
                        switch (ex.SocketErrorCode)
                        {
                        case SocketError.ConnectionReset:
                        case SocketError.HostUnreachable:
                        case SocketError.MessageSize:
                        case SocketError.NetworkReset:
                            bytesRecv = 0;
                            break;

                        default:
                            throw;
                        }
                    }

                    if (bytesRecv > 0)
                    {
                        if (processOnlyUnicastMessages && ipPacketInformation.Address.Equals(IPAddress.Broadcast))
                        {
                            continue;
                        }

                        switch ((remoteEP as IPEndPoint).Port)
                        {
                        case 67:
                        case 68:
                            try
                            {
                                DhcpMessage request = new DhcpMessage(new MemoryStream(recvBuffer, 0, bytesRecv, false));
                                _ = ProcessDhcpRequestAsync(request, remoteEP as IPEndPoint, ipPacketInformation, udpListener);
                            }
                            catch (Exception ex)
                            {
                                LogManager log = _log;
                                if (log != null)
                                {
                                    log.Write(remoteEP as IPEndPoint, ex);
                                }
                            }

                            break;
                        }
                    }
                }
            }
            catch (ObjectDisposedException)
            {
                //socket disposed
            }
            catch (SocketException ex)
            {
                switch (ex.SocketErrorCode)
                {
                case SocketError.Interrupted:
                    break;     //server stopping

                default:
                    LogManager log = _log;
                    if (log != null)
                    {
                        log.Write(remoteEP as IPEndPoint, ex);
                    }

                    throw;
                }
            }
            catch (Exception ex)
            {
                if ((_state == ServiceState.Stopping) || (_state == ServiceState.Stopped))
                {
                    return; //server stopping
                }
                LogManager log = _log;
                if (log != null)
                {
                    log.Write(remoteEP as IPEndPoint, ex);
                }

                throw;
            }
        }
Пример #53
0
 private extern static int Send_internal(IntPtr sock,
                                         byte[] buf, int offset,
                                         int count,
                                         SocketFlags flags,
                                         out int error);
        //
        // SetUnmanagedStructures -
        // Fills in Overlapped Structures used in an Async Overlapped Winsock call
        //   these calls are outside the runtime and are unmanaged code, so we need
        //   to prepare specific structures and ints that lie in unmanaged memory
        //   since the Overlapped calls can be Async
        //

        internal void SetUnmanagedStructures(byte[] buffer, int offset, int size, SocketAddress socketAddress, SocketFlags socketFlags)
        {
            m_MessageBuffer  = new byte[s_WSAMsgSize];
            m_WSABufferArray = new byte[s_WSABufferSize];

            //ipv4 or ipv6?
            IPAddress ipAddress = (socketAddress.Family == AddressFamily.InterNetworkV6
                ? socketAddress.GetIPAddress() : null);
            bool ipv4 = (((Socket)AsyncObject).AddressFamily == AddressFamily.InterNetwork ||
                         (ipAddress != null && ipAddress.IsIPv4MappedToIPv6)); // DualMode
            bool ipv6 = ((Socket)AsyncObject).AddressFamily == AddressFamily.InterNetworkV6;

            //prepare control buffer
            if (ipv4)
            {
                m_ControlBuffer = new byte[s_ControlDataSize];
            }
            else if (ipv6)
            {
                m_ControlBuffer = new byte[s_ControlDataIPv6Size];
            }

            //pin buffers
            object[] objectsToPin = new object[(m_ControlBuffer != null)?5:4];
            objectsToPin[0] = buffer;
            objectsToPin[1] = m_MessageBuffer;
            objectsToPin[2] = m_WSABufferArray;

            //prepare socketaddress buffer
            m_SocketAddress = socketAddress;
            m_SocketAddress.CopyAddressSizeIntoBuffer();
            objectsToPin[3] = m_SocketAddress.m_Buffer;

            if (m_ControlBuffer != null)
            {
                objectsToPin[4] = m_ControlBuffer;
            }

            base.SetUnmanagedStructures(objectsToPin);

            //prepare data buffer
            m_WSABuffer          = (WSABuffer *)Marshal.UnsafeAddrOfPinnedArrayElement(m_WSABufferArray, 0);
            m_WSABuffer->Length  = size;
            m_WSABuffer->Pointer = Marshal.UnsafeAddrOfPinnedArrayElement(buffer, offset);


            //setup structure
            m_Message = (UnsafeNclNativeMethods.OSSOCK.WSAMsg *)Marshal.UnsafeAddrOfPinnedArrayElement(m_MessageBuffer, 0);
            m_Message->socketAddress = Marshal.UnsafeAddrOfPinnedArrayElement(m_SocketAddress.m_Buffer, 0);
            m_Message->addressLength = (uint)m_SocketAddress.Size;
            m_Message->buffers       = Marshal.UnsafeAddrOfPinnedArrayElement(m_WSABufferArray, 0);
            m_Message->count         = 1;

            if (m_ControlBuffer != null)
            {
                m_Message->controlBuffer.Pointer = Marshal.UnsafeAddrOfPinnedArrayElement(m_ControlBuffer, 0);
                m_Message->controlBuffer.Length  = m_ControlBuffer.Length;
            }

            m_Message->flags = socketFlags;
        }
Пример #55
0
 public static Task <int> ReceiveAsync(this Socket socket, byte[] buffer, int offset, int count, SocketFlags socketFlags)
 {
     return(Task <int> .Factory.FromAsync(
                socket.BeginReceive(buffer, offset, count, socketFlags, null, null),
                socket.EndReceive
                ));
 }
 protected override void ForceReleaseUnmanagedStructures()
 {
     m_flags = m_Message->flags;
     base.ForceReleaseUnmanagedStructures();
 }
Пример #57
0
 public static Task <int> SendAsync(this Socket socket, ArraySegment <byte> segment, SocketFlags socketFlags)
 {
     return(Task <int> .Factory.FromAsync(
                socket.BeginSend(segment.Array, segment.Offset, segment.Count, socketFlags, null, null),
                socket.EndSend
                ));
 }
 internal void SetUnmanagedStructures(byte[] buffer, int offset, int size, SocketAddress socketAddress, SocketFlags socketFlags, ref OverlappedCache overlappedCache)
 {
     SetupCache(ref overlappedCache);
     SetUnmanagedStructures(buffer, offset, size, socketAddress, socketFlags);
 }
Пример #59
0
        public static unsafe SocketError Send(SafeCloseSocket handle, byte[] buffer, int offset, int size, SocketFlags socketFlags, out int bytesTransferred)
        {
            int bytesSent;

            if (buffer.Length == 0)
            {
                bytesSent = Interop.Winsock.send(handle.DangerousGetHandle(), null, 0, socketFlags);
            }
            else
            {
                fixed(byte *pinnedBuffer = &buffer[0])
                {
                    bytesSent = Interop.Winsock.send(
                        handle.DangerousGetHandle(),
                        pinnedBuffer + offset,
                        size,
                        socketFlags);
                }
            }

            if (bytesSent == (int)SocketError.SocketError)
            {
                bytesTransferred = 0;
                return(GetLastSocketError());
            }

            bytesTransferred = bytesSent;
            return(SocketError.Success);
        }
Пример #60
0
        public static Task <ReceiveFromResult> ReceiveFromAsync(this Socket socket, byte[] buffer, int offset, int count, SocketFlags flags)
        {
            EndPoint tmp = new IPEndPoint(IPAddress.Any, 0);

            return(Task <ReceiveFromResult> .Factory.FromAsync(
                       socket.BeginReceiveFrom(buffer, offset, count, flags, ref tmp, null, null),
                       (result) =>
            {
                //EndPoint tmp = new IPEndPoint(IPAddress.Any, 0);

                var x = socket.EndReceiveFrom(result, ref tmp);
                return new ReceiveFromResult
                {
                    RemoteEndpoint = (IPEndPoint)tmp,
                    BytesTransferred = x
                };
            }
                       ));
        }