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); }
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); } }); }
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; }
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); }
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); }
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); }
/// <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(); }
/// <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)); }
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; }
/// <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); }
/// <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); }
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); }); }
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; }
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; }
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); }
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); }
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); }
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); }
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); }
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; } }
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); }
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; }
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(); } } } } }
public static int Receive(this Socket socket, ArraySegment <byte> segment, SocketFlags socketFlags) { return(socket.Receive(segment.Array, segment.Offset, segment.Count, socketFlags)); }
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 )); }
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); }
private extern static int Receive_internal(IntPtr sock, byte[] buffer, int offset, int count, SocketFlags flags, out int error);
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); }
/// <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); }
public IAsyncResult BeginSend(Collections.Generic.IList <ArraySegment <byte> > buffers, SocketFlags socketFlags, out SocketError errorCode, AsyncCallback callback, object state) { throw null; }
public IAsyncResult BeginSend(byte[] buffer, int offset, int size, SocketFlags socketFlags, out SocketError errorCode, AsyncCallback callback, object state) { throw null; }
public int EndReceiveMessageFrom(IAsyncResult asyncResult, ref SocketFlags socketFlags, ref EndPoint endPoint, out IPPacketInformation ipPacketInformation) { throw null; }
public IAsyncResult BeginSendTo(byte[] buffer, int offset, int size, SocketFlags socketFlags, EndPoint remoteEP, AsyncCallback callback, object state) { throw null; }
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; } }
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; } }
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; } }
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); }
public IAsyncResult BeginReceiveMessageFrom(byte[] buffer, int offset, int size, SocketFlags socketFlags, ref EndPoint remoteEP, AsyncCallback callback, object state) { throw null; }
private void InnerStartOperationSendTo() { _receivedFlags = System.Net.Sockets.SocketFlags.None; _socketAddressSize = 0; }
public IAsyncResult BeginReceive(Collections.Generic.IList <ArraySegment <byte> > buffers, SocketFlags socketFlags, AsyncCallback callback, object state) { throw null; }
private void InnerStartOperationReceiveMessageFrom() { _receiveMessageFromPacketInfo = default(IPPacketInformation); _receivedFlags = System.Net.Sockets.SocketFlags.None; _socketAddressSize = 0; }
public IAsyncResult BeginReceive(byte[] buffer, int offset, int size, SocketFlags socketFlags, AsyncCallback callback, object state) { throw null; }
/// <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); }
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; } }
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; }
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(); }
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); }
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); }
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 }; } )); }