private unsafe void InitIPPacketInformation()
{
IPAddress address = null;
if (this.m_ControlBuffer.Length == s_ControlDataSize)
{
UnsafeNclNativeMethods.OSSOCK.ControlData data = (UnsafeNclNativeMethods.OSSOCK.ControlData) Marshal.PtrToStructure(this.m_Message.controlBuffer.Pointer, typeof(UnsafeNclNativeMethods.OSSOCK.ControlData));
if (data.length != UIntPtr.Zero)
{
address = new IPAddress((long) data.address);
}
this.m_IPPacketInformation = new IPPacketInformation((address != null) ? address : IPAddress.None, (int) data.index);
}
else if (this.m_ControlBuffer.Length == s_ControlDataIPv6Size)
{
UnsafeNclNativeMethods.OSSOCK.ControlDataIPv6 pv = (UnsafeNclNativeMethods.OSSOCK.ControlDataIPv6) Marshal.PtrToStructure(this.m_Message.controlBuffer.Pointer, typeof(UnsafeNclNativeMethods.OSSOCK.ControlDataIPv6));
if (pv.length != UIntPtr.Zero)
{
address = new IPAddress(pv.address);
}
this.m_IPPacketInformation = new IPPacketInformation((address != null) ? address : IPAddress.IPv6None, (int) pv.index);
}
else
{
this.m_IPPacketInformation = new IPPacketInformation();
}
}
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 NetworkInterface GetInterface(IPPacketInformation packetInfo)
{
int interfaceId = packetInfo.Interface;
NetworkInterface[] interfaces = NetworkInterface.GetAllNetworkInterfaces();
foreach (var netInterface in interfaces)
{
var ipv4InterfaceProps = netInterface.GetIPProperties().GetIPv4Properties();
if (ipv4InterfaceProps != null &&
ipv4InterfaceProps.Index == interfaceId)
return netInterface;
}
return null;
}
public int EndReceiveMessageFrom (IAsyncResult asyncResult,
ref SocketFlags socketFlags,
ref EndPoint endPoint,
out IPPacketInformation ipPacketInformation)
{
if (disposed && closed)
throw new ObjectDisposedException (GetType ().ToString ());
if (asyncResult == null)
throw new ArgumentNullException ("asyncResult");
if (endPoint == null)
throw new ArgumentNullException ("endPoint");
SocketAsyncResult req = asyncResult as SocketAsyncResult;
if (req == null)
throw new ArgumentException ("Invalid IAsyncResult", "asyncResult");
if (Interlocked.CompareExchange (ref req.EndCalled, 1, 0) == 1)
throw InvalidAsyncOp ("EndReceiveMessageFrom");
throw new NotImplementedException ();
}
public static SocketError ReceiveMessageFrom(Socket socket, SafeCloseSocket handle, byte[] buffer, int offset, int count, ref SocketFlags socketFlags, Internals.SocketAddress socketAddress, out Internals.SocketAddress receiveAddress, out IPPacketInformation ipPacketInformation, out int bytesTransferred)
{
byte[] socketAddressBuffer = socketAddress.Buffer;
int socketAddressLen = socketAddress.Size;
bool isIPv4, isIPv6;
Socket.GetIPProtocolInformation(socket.AddressFamily, socketAddress, out isIPv4, out isIPv6);
SocketError errorCode;
if (!handle.IsNonBlocking)
{
errorCode = handle.AsyncContext.ReceiveMessageFrom(buffer, offset, count, ref socketFlags, socketAddressBuffer, ref socketAddressLen, isIPv4, isIPv6, handle.ReceiveTimeout, out ipPacketInformation, out bytesTransferred);
}
else
{
if (!TryCompleteReceiveMessageFrom(handle.FileDescriptor, buffer, offset, count, socketFlags, socketAddressBuffer, ref socketAddressLen, isIPv4, isIPv6, out bytesTransferred, out socketFlags, out ipPacketInformation, out errorCode))
{
errorCode = SocketError.WouldBlock;
}
}
socketAddress.InternalSize = socketAddressLen;
receiveAddress = socketAddress;
return errorCode;
}
private static unsafe int ReceiveMessageFrom(int fd, SocketFlags flags, int available, byte[] buffer, int offset, int count, byte[] socketAddress, ref int socketAddressLen, bool isIPv4, bool isIPv6, out SocketFlags receivedFlags, out IPPacketInformation ipPacketInformation, out Interop.Error errno)
{
Debug.Assert(socketAddress != null);
int cmsgBufferLen = Interop.Sys.GetControlMessageBufferSize(isIPv4, isIPv6);
var cmsgBuffer = stackalloc byte[cmsgBufferLen];
int sockAddrLen = socketAddressLen;
Interop.Sys.MessageHeader messageHeader;
long received;
fixed (byte* rawSocketAddress = socketAddress)
fixed (byte* b = buffer)
{
var sockAddr = (byte*)rawSocketAddress;
var iov = new Interop.Sys.IOVector {
Base = &b[offset],
Count = (UIntPtr)count
};
messageHeader = new Interop.Sys.MessageHeader {
SocketAddress = sockAddr,
SocketAddressLen = sockAddrLen,
IOVectors = &iov,
IOVectorCount = 1,
ControlBuffer = cmsgBuffer,
ControlBufferLen = cmsgBufferLen
};
errno = Interop.Sys.ReceiveMessage(fd, &messageHeader, flags, &received);
receivedFlags = messageHeader.Flags;
sockAddrLen = messageHeader.SocketAddressLen;
}
ipPacketInformation = GetIPPacketInformation(&messageHeader, isIPv4, isIPv6);
if (errno != Interop.Error.SUCCESS)
{
return -1;
}
socketAddressLen = sockAddrLen;
return checked((int)received);
}
internal void FinishOperationSuccess(SocketError socketError, int bytesTransferred, SocketFlags flags) {
SetResults(socketError, bytesTransferred, flags);
switch(m_CompletedOperation) {
case SocketAsyncOperation.Accept:
if (bytesTransferred > 0) {
// Log and Perf counters.
if (s_LoggingEnabled) LogBuffer(bytesTransferred);
if (Socket.s_PerfCountersEnabled) UpdatePerfCounters(bytesTransferred, false);
}
// Get the endpoint.
SocketAddress remoteSocketAddress = m_CurrentSocket.m_RightEndPoint.Serialize();
IntPtr localAddr;
int localAddrLength;
IntPtr remoteAddr;
try {
m_CurrentSocket.GetAcceptExSockaddrs(
m_PtrSingleBuffer != IntPtr.Zero ? m_PtrSingleBuffer : m_PtrAcceptBuffer,
m_Count != 0 ? m_Count - m_AcceptAddressBufferCount : 0,
m_AcceptAddressBufferCount / 2,
m_AcceptAddressBufferCount / 2,
out localAddr,
out localAddrLength,
out remoteAddr,
out remoteSocketAddress.m_Size
);
Marshal.Copy(remoteAddr, remoteSocketAddress.m_Buffer, 0, remoteSocketAddress.m_Size);
// Set the socket context.
IntPtr handle = m_CurrentSocket.SafeHandle.DangerousGetHandle();
socketError = UnsafeNclNativeMethods.OSSOCK.setsockopt(
m_AcceptSocket.SafeHandle,
SocketOptionLevel.Socket,
SocketOptionName.UpdateAcceptContext,
ref handle,
Marshal.SizeOf(handle));
if(socketError == SocketError.SocketError) {
socketError = (SocketError)Marshal.GetLastWin32Error();
}
}
catch(ObjectDisposedException) {
socketError = SocketError.OperationAborted;
}
if(socketError == SocketError.Success) {
m_AcceptSocket = m_CurrentSocket.UpdateAcceptSocket(m_AcceptSocket, m_CurrentSocket.m_RightEndPoint.Create(remoteSocketAddress), false);
if (s_LoggingEnabled) Logging.PrintInfo(Logging.Sockets, m_AcceptSocket,
SR.GetString(SR.net_log_socket_accepted, m_AcceptSocket.RemoteEndPoint, m_AcceptSocket.LocalEndPoint));
} else {
SetResults(socketError, bytesTransferred, SocketFlags.None);
m_AcceptSocket = null;
}
break;
case SocketAsyncOperation.Connect:
if (bytesTransferred > 0) {
// Log and Perf counters.
if (s_LoggingEnabled) LogBuffer(bytesTransferred);
if (Socket.s_PerfCountersEnabled) UpdatePerfCounters(bytesTransferred, true);
}
// Update the socket context.
try {
socketError = UnsafeNclNativeMethods.OSSOCK.setsockopt(
m_CurrentSocket.SafeHandle,
SocketOptionLevel.Socket,
SocketOptionName.UpdateConnectContext,
null,
0);
if(socketError == SocketError.SocketError) {
socketError = (SocketError)Marshal.GetLastWin32Error();
}
}
catch(ObjectDisposedException) {
socketError = SocketError.OperationAborted;
}
// Mark socket connected.
if(socketError == SocketError.Success) {
if (s_LoggingEnabled) Logging.PrintInfo(Logging.Sockets, m_CurrentSocket,
SR.GetString(SR.net_log_socket_connected, m_CurrentSocket.LocalEndPoint, m_CurrentSocket.RemoteEndPoint));
m_CurrentSocket.SetToConnected();
m_ConnectSocket = m_CurrentSocket;
}
break;
case SocketAsyncOperation.Disconnect:
m_CurrentSocket.SetToDisconnected();
m_CurrentSocket.m_RemoteEndPoint = null;
break;
case SocketAsyncOperation.Receive:
if (bytesTransferred > 0) {
// Log and Perf counters.
if (s_LoggingEnabled) LogBuffer(bytesTransferred);
if (Socket.s_PerfCountersEnabled) UpdatePerfCounters(bytesTransferred, false);
}
break;
case SocketAsyncOperation.ReceiveFrom:
if (bytesTransferred > 0) {
// Log and Perf counters.
if (s_LoggingEnabled) LogBuffer(bytesTransferred);
if (Socket.s_PerfCountersEnabled) UpdatePerfCounters(bytesTransferred, false);
}
// Deal with incoming address.
m_SocketAddress.SetSize(m_PtrSocketAddressBufferSize);
SocketAddress socketAddressOriginal = m_RemoteEndPoint.Serialize();
if(!socketAddressOriginal.Equals(m_SocketAddress)) {
try {
m_RemoteEndPoint = m_RemoteEndPoint.Create(m_SocketAddress);
}
catch {
}
}
break;
case SocketAsyncOperation.ReceiveMessageFrom:
if (bytesTransferred > 0) {
// Log and Perf counters.
if (s_LoggingEnabled) LogBuffer(bytesTransferred);
if (Socket.s_PerfCountersEnabled) UpdatePerfCounters(bytesTransferred, false);
}
// Deal with incoming address.
m_SocketAddress.SetSize(m_PtrSocketAddressBufferSize);
socketAddressOriginal = m_RemoteEndPoint.Serialize();
if(!socketAddressOriginal.Equals(m_SocketAddress)) {
try {
m_RemoteEndPoint = m_RemoteEndPoint.Create(m_SocketAddress);
}
catch {
}
}
// Extract the packet information.
unsafe {
IPAddress address = null;
UnsafeNclNativeMethods.OSSOCK.WSAMsg* PtrMessage = (UnsafeNclNativeMethods.OSSOCK.WSAMsg*)Marshal.UnsafeAddrOfPinnedArrayElement(m_WSAMessageBuffer, 0);
//ipv4
if(m_ControlBuffer.Length == s_ControlDataSize) {
UnsafeNclNativeMethods.OSSOCK.ControlData controlData = (UnsafeNclNativeMethods.OSSOCK.ControlData)Marshal.PtrToStructure(PtrMessage->controlBuffer.Pointer, typeof(UnsafeNclNativeMethods.OSSOCK.ControlData));
if(controlData.length != UIntPtr.Zero) {
address = new IPAddress((long)controlData.address);
}
m_ReceiveMessageFromPacketInfo = new IPPacketInformation(((address != null) ? address : IPAddress.None), (int)controlData.index);
}
//ipv6
else if(m_ControlBuffer.Length == s_ControlDataIPv6Size) {
UnsafeNclNativeMethods.OSSOCK.ControlDataIPv6 controlData = (UnsafeNclNativeMethods.OSSOCK.ControlDataIPv6)Marshal.PtrToStructure(PtrMessage->controlBuffer.Pointer, typeof(UnsafeNclNativeMethods.OSSOCK.ControlDataIPv6));
if(controlData.length != UIntPtr.Zero) {
address = new IPAddress(controlData.address);
}
m_ReceiveMessageFromPacketInfo = new IPPacketInformation(((address != null) ? address : IPAddress.IPv6None), (int)controlData.index);
}
//other
else {
m_ReceiveMessageFromPacketInfo = new IPPacketInformation();
}
}
break;
case SocketAsyncOperation.Send:
if (bytesTransferred > 0) {
// Log and Perf counters.
if (s_LoggingEnabled) LogBuffer(bytesTransferred);
if (Socket.s_PerfCountersEnabled) UpdatePerfCounters(bytesTransferred, true);
}
break;
case SocketAsyncOperation.SendPackets:
if(bytesTransferred > 0) {
// Log and Perf counters.
if(s_LoggingEnabled) LogSendPacketsBuffers(bytesTransferred);
if(Socket.s_PerfCountersEnabled) UpdatePerfCounters(bytesTransferred, true);
}
// Close the files if open
if (m_SendPacketsFileStreams != null) {
for(int i = 0; i < m_SendPacketsElementsFileCount; i++) {
// Dereference handles
m_SendPacketsFileHandles[i] = null;
// Close any open streams
if(m_SendPacketsFileStreams[i] != null) {
m_SendPacketsFileStreams[i].Close();
m_SendPacketsFileStreams[i] = null;
}
}
}
m_SendPacketsFileStreams = null;
m_SendPacketsFileHandles = null;
break;
case SocketAsyncOperation.SendTo:
if (bytesTransferred > 0) {
// Log and Perf counters.
if (s_LoggingEnabled) LogBuffer(bytesTransferred);
if (Socket.s_PerfCountersEnabled) UpdatePerfCounters(bytesTransferred, true);
}
break;
}
if(socketError != SocketError.Success) {
// Asynchronous failure or something went wrong after async success.
SetResults(socketError, bytesTransferred, flags);
m_CurrentSocket.UpdateStatusAfterSocketError(socketError);
}
// Complete the operation and raise completion event.
Complete();
if(m_ContextCopy == null) {
OnCompleted(this);
} else {
ExecutionContext.Run(m_ContextCopy, m_ExecutionCallback, null);
}
}
/// <devdoc>
/// <para>Receives a datagram into a specific location in the data buffer and stores
/// the end point.</para>
/// </devdoc>
public int ReceiveMessageFrom(byte[] buffer, int offset, int size, ref SocketFlags socketFlags, ref EndPoint remoteEP, out IPPacketInformation ipPacketInformation) {
if(s_LoggingEnabled)Logging.Enter(Logging.Sockets, this, "ReceiveMessageFrom", "");
if (CleanedUp) {
throw new ObjectDisposedException(this.GetType().FullName);
}
if (buffer==null) {
throw new ArgumentNullException("buffer");
}
if (remoteEP==null) {
throw new ArgumentNullException("remoteEP");
}
if (!CanTryAddressFamily(remoteEP.AddressFamily)) {
throw new ArgumentException(SR.GetString(SR.net_InvalidEndPointAddressFamily,
remoteEP.AddressFamily, addressFamily), "remoteEP");
}
if (offset<0 || offset>buffer.Length) {
throw new ArgumentOutOfRangeException("offset");
}
if (size<0 || size>buffer.Length-offset) {
throw new ArgumentOutOfRangeException("size");
}
if (m_RightEndPoint==null) {
throw new InvalidOperationException(SR.GetString(SR.net_sockets_mustbind));
}
ValidateBlockingMode();
// We don't do a CAS demand here because the contents of remoteEP aren't used by
// WSARecvMsg; all that matters is that we generate a unique-to-this-call SocketAddress
// with the right address family
EndPoint endPointSnapshot = remoteEP;
SocketAddress socketAddress = SnapshotAndSerialize(ref endPointSnapshot);
ReceiveMessageOverlappedAsyncResult asyncResult = new ReceiveMessageOverlappedAsyncResult(this,null,null);
asyncResult.SetUnmanagedStructures(buffer, offset, size, socketAddress, socketFlags);
// save a copy of the original EndPoint
SocketAddress socketAddressOriginal = endPointSnapshot.Serialize();
//setup structure
int bytesTransfered = 0;
SocketError errorCode = SocketError.Success;
SetReceivingPacketInformation();
try
{
// This can throw ObjectDisposedException (retrieving the delegate AND resolving the handle).
if (WSARecvMsg_Blocking(
m_Handle.DangerousGetHandle(),
Marshal.UnsafeAddrOfPinnedArrayElement(asyncResult.m_MessageBuffer,0),
out bytesTransfered,
IntPtr.Zero,
IntPtr.Zero) == SocketError.SocketError)
{
errorCode = (SocketError)Marshal.GetLastWin32Error();
}
}
finally {
asyncResult.SyncReleaseUnmanagedStructures();
}
//
// if the native call fails we'll throw a SocketException
//
if (errorCode!=SocketError.Success && errorCode != SocketError.MessageSize) {
//
// update our internal state after this socket error and throw
//
SocketException socketException = new SocketException(errorCode);
UpdateStatusAfterSocketError(socketException);
if(s_LoggingEnabled)Logging.Exception(Logging.Sockets, this, "ReceiveMessageFrom", socketException);
throw socketException;
}
if (!socketAddressOriginal.Equals(asyncResult.m_SocketAddress))
{
try {
remoteEP = endPointSnapshot.Create(asyncResult.m_SocketAddress);
}
catch {
}
if (m_RightEndPoint==null) {
//
// save a copy of the EndPoint so we can use it for Create()
//
m_RightEndPoint = endPointSnapshot;
}
}
socketFlags = asyncResult.m_flags;
ipPacketInformation = asyncResult.m_IPPacketInformation;
if(s_LoggingEnabled)Logging.Exit(Logging.Sockets, this, "ReceiveMessageFrom", errorCode);
return bytesTransfered;
}
public int EndReceiveMessageFrom(IAsyncResult asyncResult, ref SocketFlags socketFlags, ref System.Net.EndPoint endPoint, out IPPacketInformation ipPacketInformation)
{
ipPacketInformation = default(IPPacketInformation);
return(default(int));
}
public int ReceiveMessageFrom (byte[] buffer, int offset, int size, ref SocketFlags socketFlags, ref EndPoint remoteEP, out IPPacketInformation ipPacketInformation)
{
ThrowIfDisposedAndClosed ();
ThrowIfBufferNull (buffer);
ThrowIfBufferOutOfRange (buffer, offset, size);
if (remoteEP == null)
throw new ArgumentNullException ("remoteEP");
// FIXME: figure out how we get hold of the IPPacketInformation
throw new NotImplementedException ();
}
/// <summary>
/// Extends ReceiveMessageFrom so that buffer offset of 0 and call to Array.Length are not needed.
/// <example>
/// socket.ReceiveMessageFrom(buffer, socketFlags, remoteEP, ipPacketInformation);
/// </example>
/// </summary>
public static Int32 ReceiveMessageFrom(this Socket socket, Byte[] buffer, ref SocketFlags socketFlags, ref System.Net.EndPoint remoteEP, out IPPacketInformation ipPacketInformation)
{
if(socket == null) throw new ArgumentNullException("socket");
if(buffer == null) throw new ArgumentNullException("buffer");
return socket.ReceiveMessageFrom(buffer, 0, buffer.Length, ref socketFlags, ref remoteEP, out ipPacketInformation);
}
private void CompleteReceiveMessageFromOperation(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;
}
private void ReceiveMessageFromCompletionCallback(int bytesTransferred, byte[] socketAddress, int socketAddressSize, SocketFlags receivedFlags, IPPacketInformation ipPacketInformation, SocketError errorCode)
{
CompleteReceiveMessageFromOperation(bytesTransferred, socketAddress, socketAddressSize, receivedFlags, ipPacketInformation, errorCode);
CompletionCallback(bytesTransferred, receivedFlags, errorCode);
}
public static unsafe SocketError ReceiveMessageFrom(Socket socket, SafeSocketHandle handle, byte[] buffer, int offset, int size, ref SocketFlags socketFlags, Internals.SocketAddress socketAddress, out Internals.SocketAddress receiveAddress, out IPPacketInformation ipPacketInformation, out int bytesTransferred)
{
return(ReceiveMessageFrom(socket, handle, new Span <byte>(buffer, offset, size), ref socketFlags, socketAddress, out receiveAddress, out ipPacketInformation, out bytesTransferred));
}
private void ReceiveMessageFromCompletionCallback(int bytesTransferred, byte[] socketAddress, int socketAddressSize, SocketFlags receivedFlags, IPPacketInformation ipPacketInformation, SocketError errorCode)
{
Debug.Assert(_socketAddress != null);
Debug.Assert(socketAddress == null || _socketAddress.Buffer == socketAddress);
_socketAddressSize = socketAddressSize;
_receivedFlags = receivedFlags;
_receiveMessageFromPacketInfo = ipPacketInformation;
CompletionCallback(bytesTransferred, errorCode);
}
public void CompletionCallback(int numBytes, byte[] socketAddress, int socketAddressSize, SocketFlags receivedFlags, IPPacketInformation ipPacketInformation, SocketError errorCode)
{
Debug.Assert(_socketAddress != null, "_socketAddress was null");
Debug.Assert(socketAddress == null || _socketAddress.Buffer == socketAddress, $"Unexpected socketAddress: {socketAddress}");
_socketAddressSize = socketAddressSize;
_socketFlags = receivedFlags;
_ipPacketInformation = ipPacketInformation;
base.CompletionCallback(numBytes, errorCode);
}
public int ReceiveMessageFrom(byte[] buffer, int offset, int size, ref SocketFlags socketFlags, ref System.Net.EndPoint remoteEP, out IPPacketInformation ipPacketInformation)
{
ipPacketInformation = default(IPPacketInformation);
return(default(int));
}
int Utils.Wrappers.Interfaces.ISocket.EndReceiveMessageFrom(System.IAsyncResult asyncResult, ref SocketFlags socketFlags, ref System.Net.EndPoint endPoint, out System.Net.Sockets.IPPacketInformation ipPacketInformation)
{
return(InternalSocket.EndReceiveMessageFrom(asyncResult, ref socketFlags, ref endPoint, out ipPacketInformation));
}
// Receives a datagram into a specific location in the data buffer and stores
// the end point.
public int ReceiveMessageFrom(byte[] buffer, int offset, int size, ref SocketFlags socketFlags, ref EndPoint remoteEP, out IPPacketInformation ipPacketInformation)
{
if (s_loggingEnabled)
{
Logging.Enter(Logging.Sockets, this, "ReceiveMessageFrom", "");
}
if (CleanedUp)
{
throw new ObjectDisposedException(this.GetType().FullName);
}
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
if (remoteEP == null)
{
throw new ArgumentNullException("remoteEP");
}
if (!CanTryAddressFamily(remoteEP.AddressFamily))
{
throw new ArgumentException(SR.Format(SR.net_InvalidEndPointAddressFamily, remoteEP.AddressFamily, _addressFamily), "remoteEP");
}
if (offset < 0 || offset > buffer.Length)
{
throw new ArgumentOutOfRangeException("offset");
}
if (size < 0 || size > buffer.Length - offset)
{
throw new ArgumentOutOfRangeException("size");
}
if (_rightEndPoint == null)
{
throw new InvalidOperationException(SR.net_sockets_mustbind);
}
ValidateBlockingMode();
// We don't do a CAS demand here because the contents of remoteEP aren't used by
// WSARecvMsg; all that matters is that we generate a unique-to-this-call SocketAddress
// with the right address family.
EndPoint endPointSnapshot = remoteEP;
Internals.SocketAddress socketAddress = SnapshotAndSerialize(ref endPointSnapshot);
// Save a copy of the original EndPoint.
Internals.SocketAddress socketAddressOriginal = IPEndPointExtensions.Serialize(endPointSnapshot);
SetReceivingPacketInformation();
Internals.SocketAddress receiveAddress;
int bytesTransferred;
SocketError errorCode = SocketPal.ReceiveMessageFrom(this, _handle, buffer, offset, size, ref socketFlags, socketAddress, out receiveAddress, out ipPacketInformation, out bytesTransferred);
// Throw an appropriate SocketException if the native call fails.
if (errorCode != SocketError.Success && errorCode != SocketError.MessageSize)
{
// Update the internal state of this socket according to the error before throwing.
SocketException socketException = new SocketException((int)errorCode);
UpdateStatusAfterSocketError(socketException);
if (s_loggingEnabled)
{
Logging.Exception(Logging.Sockets, this, "ReceiveMessageFrom", socketException);
}
throw socketException;
}
if (!socketAddressOriginal.Equals(receiveAddress))
{
try
{
remoteEP = endPointSnapshot.Create(receiveAddress);
}
catch
{
}
if (_rightEndPoint == null)
{
// Save a copy of the EndPoint so we can use it for Create().
_rightEndPoint = endPointSnapshot;
}
}
if (s_loggingEnabled)
{
Logging.Exit(Logging.Sockets, this, "ReceiveMessageFrom", errorCode);
}
return bytesTransferred;
}
//
// Summary:
// Ends a pending asynchronous read from a specific endpoint. This method also reveals
// more information about the packet than System.Net.Sockets.Socket.EndReceiveFrom(System.IAsyncResult,System.Net.EndPoint@).
//
// Parameters:
// asyncResult:
// An System.IAsyncResult that stores state information and any user defined data
// for this asynchronous operation.
//
// socketFlags:
// A bitwise combination of the System.Net.Sockets.SocketFlags values for the received
// packet.
//
// endPoint:
// The source System.Net.EndPoint.
//
// ipPacketInformation:
// The System.Net.IPAddress and interface of the received packet.
//
// Returns:
// If successful, the number of bytes received. If unsuccessful, returns 0.
//
// Exceptions:
// T:System.ArgumentNullException:
// asyncResult is null-or- endPoint is null.
//
// T:System.ArgumentException:
// asyncResult was not returned by a call to the System.Net.Sockets.Socket.BeginReceiveMessageFrom(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint@,System.AsyncCallback,System.Object)
// method.
//
// T:System.InvalidOperationException:
// System.Net.Sockets.Socket.EndReceiveMessageFrom(System.IAsyncResult,System.Net.Sockets.SocketFlags@,System.Net.EndPoint@,System.Net.Sockets.IPPacketInformation@)
// was previously called for the asynchronous read.
//
// T:System.Net.Sockets.SocketException:
// An error occurred when attempting to access the socket. See the Remarks section
// for more information.
//
// T:System.ObjectDisposedException:
// The System.Net.Sockets.Socket has been closed.
public static int EndReceiveMessageFrom(this Socket socket, IAsyncResult asyncResult, ref SocketFlags socketFlags, ref EndPoint endPoint, out IPPacketInformation ipPacketInformation)
{
SocketReceiveMessageFromResult result = TaskToApm.End<SocketReceiveMessageFromResult>(asyncResult);
socketFlags = result.SocketFlags;
endPoint = result.RemoteEndPoint;
ipPacketInformation = result.PacketInformation;
return result.ReceivedBytes;
}
unsafe private void InitIPPacketInformation()
{
IPAddress address = null;
if (_controlBuffer.Length == s_controlDataSize)
{
// IPv4
Interop.Winsock.ControlData controlData = Marshal.PtrToStructure<Interop.Winsock.ControlData>(_message->controlBuffer.Pointer);
if (controlData.length != UIntPtr.Zero)
{
address = new IPAddress((long)controlData.address);
}
_ipPacketInformation = new IPPacketInformation(((address != null) ? address : IPAddress.None), (int)controlData.index);
}
else if (_controlBuffer.Length == s_controlDataIPv6Size)
{
// IPv6
Interop.Winsock.ControlDataIPv6 controlData = Marshal.PtrToStructure<Interop.Winsock.ControlDataIPv6>(_message->controlBuffer.Pointer);
if (controlData.length != UIntPtr.Zero)
{
address = new IPAddress(controlData.address);
}
_ipPacketInformation = new IPPacketInformation(((address != null) ? address : IPAddress.IPv6None), (int)controlData.index);
}
else
{
// Other
_ipPacketInformation = new IPPacketInformation();
}
}
public int ReceiveMessageFrom(byte[] buffer, int offset, int size, ref SocketFlags socketFlags, ref System.Net.EndPoint remoteEP, out IPPacketInformation ipPacketInformation)
{
ipPacketInformation = default(IPPacketInformation);
return default(int);
}
internal unsafe void FinishOperationSuccess(System.Net.Sockets.SocketError socketError, int bytesTransferred, System.Net.Sockets.SocketFlags flags)
{
this.SetResults(socketError, bytesTransferred, flags);
switch (this.m_CompletedOperation)
{
case SocketAsyncOperation.Accept:
{
if (bytesTransferred > 0)
{
if (s_LoggingEnabled)
{
this.LogBuffer(bytesTransferred);
}
if (Socket.s_PerfCountersEnabled)
{
this.UpdatePerfCounters(bytesTransferred, false);
}
}
SocketAddress socketAddress = this.m_CurrentSocket.m_RightEndPoint.Serialize();
try
{
IntPtr ptr;
int num;
IntPtr ptr2;
this.m_CurrentSocket.GetAcceptExSockaddrs((this.m_PtrSingleBuffer != IntPtr.Zero) ? this.m_PtrSingleBuffer : this.m_PtrAcceptBuffer, (this.m_Count != 0) ? (this.m_Count - this.m_AcceptAddressBufferCount) : 0, this.m_AcceptAddressBufferCount / 2, this.m_AcceptAddressBufferCount / 2, out ptr, out num, out ptr2, out socketAddress.m_Size);
Marshal.Copy(ptr2, socketAddress.m_Buffer, 0, socketAddress.m_Size);
IntPtr handle = this.m_CurrentSocket.SafeHandle.DangerousGetHandle();
socketError = UnsafeNclNativeMethods.OSSOCK.setsockopt(this.m_AcceptSocket.SafeHandle, SocketOptionLevel.Socket, SocketOptionName.UpdateAcceptContext, ref handle, Marshal.SizeOf(handle));
if (socketError == System.Net.Sockets.SocketError.SocketError)
{
socketError = (System.Net.Sockets.SocketError) Marshal.GetLastWin32Error();
}
}
catch (ObjectDisposedException)
{
socketError = System.Net.Sockets.SocketError.OperationAborted;
}
if (socketError == System.Net.Sockets.SocketError.Success)
{
this.m_AcceptSocket = this.m_CurrentSocket.UpdateAcceptSocket(this.m_AcceptSocket, this.m_CurrentSocket.m_RightEndPoint.Create(socketAddress), false);
if (s_LoggingEnabled)
{
Logging.PrintInfo(Logging.Sockets, this.m_AcceptSocket, SR.GetString("net_log_socket_accepted", new object[] { this.m_AcceptSocket.RemoteEndPoint, this.m_AcceptSocket.LocalEndPoint }));
}
}
else
{
this.SetResults(socketError, bytesTransferred, System.Net.Sockets.SocketFlags.None);
this.m_AcceptSocket = null;
}
break;
}
case SocketAsyncOperation.Connect:
if (bytesTransferred > 0)
{
if (s_LoggingEnabled)
{
this.LogBuffer(bytesTransferred);
}
if (Socket.s_PerfCountersEnabled)
{
this.UpdatePerfCounters(bytesTransferred, true);
}
}
try
{
socketError = UnsafeNclNativeMethods.OSSOCK.setsockopt(this.m_CurrentSocket.SafeHandle, SocketOptionLevel.Socket, SocketOptionName.UpdateConnectContext, (byte[]) null, 0);
if (socketError == System.Net.Sockets.SocketError.SocketError)
{
socketError = (System.Net.Sockets.SocketError) Marshal.GetLastWin32Error();
}
}
catch (ObjectDisposedException)
{
socketError = System.Net.Sockets.SocketError.OperationAborted;
}
if (socketError == System.Net.Sockets.SocketError.Success)
{
if (s_LoggingEnabled)
{
Logging.PrintInfo(Logging.Sockets, this.m_CurrentSocket, SR.GetString("net_log_socket_connected", new object[] { this.m_CurrentSocket.LocalEndPoint, this.m_CurrentSocket.RemoteEndPoint }));
}
this.m_CurrentSocket.SetToConnected();
this.m_ConnectSocket = this.m_CurrentSocket;
}
break;
case SocketAsyncOperation.Disconnect:
this.m_CurrentSocket.SetToDisconnected();
this.m_CurrentSocket.m_RemoteEndPoint = null;
break;
case SocketAsyncOperation.Receive:
if (bytesTransferred > 0)
{
if (s_LoggingEnabled)
{
this.LogBuffer(bytesTransferred);
}
if (Socket.s_PerfCountersEnabled)
{
this.UpdatePerfCounters(bytesTransferred, false);
}
}
break;
case SocketAsyncOperation.ReceiveFrom:
if (bytesTransferred > 0)
{
if (s_LoggingEnabled)
{
this.LogBuffer(bytesTransferred);
}
if (Socket.s_PerfCountersEnabled)
{
this.UpdatePerfCounters(bytesTransferred, false);
}
}
this.m_SocketAddress.SetSize(this.m_PtrSocketAddressBufferSize);
if (!this.m_RemoteEndPoint.Serialize().Equals(this.m_SocketAddress))
{
try
{
this.m_RemoteEndPoint = this.m_RemoteEndPoint.Create(this.m_SocketAddress);
}
catch
{
}
}
break;
case SocketAsyncOperation.ReceiveMessageFrom:
{
if (bytesTransferred > 0)
{
if (s_LoggingEnabled)
{
this.LogBuffer(bytesTransferred);
}
if (Socket.s_PerfCountersEnabled)
{
this.UpdatePerfCounters(bytesTransferred, false);
}
}
this.m_SocketAddress.SetSize(this.m_PtrSocketAddressBufferSize);
if (!this.m_RemoteEndPoint.Serialize().Equals(this.m_SocketAddress))
{
try
{
this.m_RemoteEndPoint = this.m_RemoteEndPoint.Create(this.m_SocketAddress);
}
catch
{
}
}
IPAddress address3 = null;
UnsafeNclNativeMethods.OSSOCK.WSAMsg* msgPtr = (UnsafeNclNativeMethods.OSSOCK.WSAMsg*) Marshal.UnsafeAddrOfPinnedArrayElement(this.m_WSAMessageBuffer, 0);
if (this.m_ControlBuffer.Length == s_ControlDataSize)
{
UnsafeNclNativeMethods.OSSOCK.ControlData data = (UnsafeNclNativeMethods.OSSOCK.ControlData) Marshal.PtrToStructure(msgPtr->controlBuffer.Pointer, typeof(UnsafeNclNativeMethods.OSSOCK.ControlData));
if (data.length != UIntPtr.Zero)
{
address3 = new IPAddress((long) data.address);
}
this.m_ReceiveMessageFromPacketInfo = new IPPacketInformation((address3 != null) ? address3 : IPAddress.None, (int) data.index);
}
else if (this.m_ControlBuffer.Length == s_ControlDataIPv6Size)
{
UnsafeNclNativeMethods.OSSOCK.ControlDataIPv6 pv = (UnsafeNclNativeMethods.OSSOCK.ControlDataIPv6) Marshal.PtrToStructure(msgPtr->controlBuffer.Pointer, typeof(UnsafeNclNativeMethods.OSSOCK.ControlDataIPv6));
if (pv.length != UIntPtr.Zero)
{
address3 = new IPAddress(pv.address);
}
this.m_ReceiveMessageFromPacketInfo = new IPPacketInformation((address3 != null) ? address3 : IPAddress.IPv6None, (int) pv.index);
}
else
{
this.m_ReceiveMessageFromPacketInfo = new IPPacketInformation();
}
break;
}
case SocketAsyncOperation.Send:
if (bytesTransferred > 0)
{
if (s_LoggingEnabled)
{
this.LogBuffer(bytesTransferred);
}
if (Socket.s_PerfCountersEnabled)
{
this.UpdatePerfCounters(bytesTransferred, true);
}
}
break;
case SocketAsyncOperation.SendPackets:
if (bytesTransferred > 0)
{
if (s_LoggingEnabled)
{
this.LogSendPacketsBuffers(bytesTransferred);
}
if (Socket.s_PerfCountersEnabled)
{
this.UpdatePerfCounters(bytesTransferred, true);
}
}
if (this.m_SendPacketsFileStreams != null)
{
for (int i = 0; i < this.m_SendPacketsElementsFileCount; i++)
{
this.m_SendPacketsFileHandles[i] = null;
if (this.m_SendPacketsFileStreams[i] != null)
{
this.m_SendPacketsFileStreams[i].Close();
this.m_SendPacketsFileStreams[i] = null;
}
}
}
this.m_SendPacketsFileStreams = null;
this.m_SendPacketsFileHandles = null;
break;
case SocketAsyncOperation.SendTo:
if (bytesTransferred > 0)
{
if (s_LoggingEnabled)
{
this.LogBuffer(bytesTransferred);
}
if (Socket.s_PerfCountersEnabled)
{
this.UpdatePerfCounters(bytesTransferred, true);
}
}
break;
}
if (socketError != System.Net.Sockets.SocketError.Success)
{
this.SetResults(socketError, bytesTransferred, flags);
this.m_CurrentSocket.UpdateStatusAfterSocketError(socketError);
}
this.Complete();
if (this.m_ContextCopy == null)
{
this.OnCompleted(this);
}
else
{
ExecutionContext.Run(this.m_ContextCopy, this.m_ExecutionCallback, null);
}
}
public static unsafe SocketError ReceiveMessageFrom(Socket socket, SafeCloseSocket handle, byte[] buffer, int offset, int size, ref SocketFlags socketFlags, Internals.SocketAddress socketAddress, out Internals.SocketAddress receiveAddress, out IPPacketInformation ipPacketInformation, out int bytesTransferred)
{
bool ipv4, ipv6;
Socket.GetIPProtocolInformation(socket.AddressFamily, socketAddress, out ipv4, out ipv6);
bytesTransferred = 0;
receiveAddress = socketAddress;
ipPacketInformation = default(IPPacketInformation);
fixed(byte *ptrBuffer = buffer)
fixed(byte *ptrSocketAddress = socketAddress.Buffer)
{
Interop.Winsock.WSAMsg wsaMsg;
wsaMsg.socketAddress = (IntPtr)ptrSocketAddress;
wsaMsg.addressLength = (uint)socketAddress.Size;
wsaMsg.flags = socketFlags;
WSABuffer wsaBuffer;
wsaBuffer.Length = size;
wsaBuffer.Pointer = (IntPtr)(ptrBuffer + offset);
wsaMsg.buffers = (IntPtr)(&wsaBuffer);
wsaMsg.count = 1;
if (ipv4)
{
Interop.Winsock.ControlData controlBuffer;
wsaMsg.controlBuffer.Pointer = (IntPtr)(&controlBuffer);
wsaMsg.controlBuffer.Length = sizeof(Interop.Winsock.ControlData);
if (socket.WSARecvMsgBlocking(
handle.DangerousGetHandle(),
(IntPtr)(&wsaMsg),
out bytesTransferred,
IntPtr.Zero,
IntPtr.Zero) == SocketError.SocketError)
{
return(GetLastSocketError());
}
ipPacketInformation = GetIPPacketInformation(&controlBuffer);
}
else if (ipv6)
{
Interop.Winsock.ControlDataIPv6 controlBuffer;
wsaMsg.controlBuffer.Pointer = (IntPtr)(&controlBuffer);
wsaMsg.controlBuffer.Length = sizeof(Interop.Winsock.ControlDataIPv6);
if (socket.WSARecvMsgBlocking(
handle.DangerousGetHandle(),
(IntPtr)(&wsaMsg),
out bytesTransferred,
IntPtr.Zero,
IntPtr.Zero) == SocketError.SocketError)
{
return(GetLastSocketError());
}
ipPacketInformation = GetIPPacketInformation(&controlBuffer);
}
else
{
wsaMsg.controlBuffer.Pointer = IntPtr.Zero;
wsaMsg.controlBuffer.Length = 0;
if (socket.WSARecvMsgBlocking(
handle.DangerousGetHandle(),
(IntPtr)(&wsaMsg),
out bytesTransferred,
IntPtr.Zero,
IntPtr.Zero) == SocketError.SocketError)
{
return(GetLastSocketError());
}
}
socketFlags = wsaMsg.flags;
}
return(SocketError.Success);
}
public static unsafe bool TryCompleteReceiveMessageFrom(SafeCloseSocket socket, byte[] buffer, int offset, int count, SocketFlags flags, byte[] socketAddress, ref int socketAddressLen, bool isIPv4, bool isIPv6, out int bytesReceived, out SocketFlags receivedFlags, out IPPacketInformation ipPacketInformation, out SocketError errorCode)
{
try
{
Interop.Error errno;
int received = ReceiveMessageFrom(socket, flags, buffer, offset, count, socketAddress, ref socketAddressLen, isIPv4, isIPv6, out receivedFlags, out ipPacketInformation, out errno);
if (received != -1)
{
bytesReceived = received;
errorCode = SocketError.Success;
return true;
}
bytesReceived = 0;
if (errno != Interop.Error.EAGAIN && errno != Interop.Error.EWOULDBLOCK)
{
errorCode = GetSocketErrorForErrorCode(errno);
return true;
}
errorCode = SocketError.Success;
return false;
}
catch (ObjectDisposedException)
{
// The socket was closed, or is closing.
bytesReceived = 0;
receivedFlags = 0;
ipPacketInformation = default(IPPacketInformation);
errorCode = SocketError.OperationAborted;
return true;
}
}
public static SocketError ReceiveMessageFrom(Socket socket, SafeCloseSocket handle, byte[] buffer, int offset, int size, ref SocketFlags socketFlags, Internals.SocketAddress socketAddress, out Internals.SocketAddress receiveAddress, out IPPacketInformation ipPacketInformation, out int bytesTransferred)
{
ReceiveMessageOverlappedAsyncResult asyncResult = new ReceiveMessageOverlappedAsyncResult(socket, null, null);
asyncResult.SetUnmanagedStructures(buffer, offset, size, socketAddress, socketFlags);
SocketError errorCode = SocketError.Success;
bytesTransferred = 0;
try
{
// This can throw ObjectDisposedException (retrieving the delegate AND resolving the handle).
if (socket.WSARecvMsgBlocking(
handle.DangerousGetHandle(),
Marshal.UnsafeAddrOfPinnedArrayElement(asyncResult._messageBuffer, 0),
out bytesTransferred,
IntPtr.Zero,
IntPtr.Zero) == SocketError.SocketError)
{
errorCode = (SocketError)Marshal.GetLastWin32Error();
}
}
finally
{
asyncResult.SyncReleaseUnmanagedStructures();
}
socketFlags = asyncResult.SocketFlags;
receiveAddress = asyncResult.SocketAddress;
ipPacketInformation = asyncResult.IPPacketInformation;
return(errorCode);
}
public int EndReceiveMessageFrom(IAsyncResult asyncResult, ref SocketFlags socketFlags, ref EndPoint endPoint, out IPPacketInformation ipPacketInformation) {
if(s_LoggingEnabled)Logging.Enter(Logging.Sockets, this, "EndReceiveMessageFrom", asyncResult);
if (CleanedUp) {
throw new ObjectDisposedException(this.GetType().FullName);
}
if (endPoint==null) {
throw new ArgumentNullException("endPoint");
}
if (!CanTryAddressFamily(endPoint.AddressFamily)) {
throw new ArgumentException(SR.GetString(SR.net_InvalidEndPointAddressFamily,
endPoint.AddressFamily, addressFamily), "endPoint");
}
if (asyncResult==null) {
throw new ArgumentNullException("asyncResult");
}
ReceiveMessageOverlappedAsyncResult castedAsyncResult = asyncResult as ReceiveMessageOverlappedAsyncResult;
if (castedAsyncResult==null || castedAsyncResult.AsyncObject!=this) {
throw new ArgumentException(SR.GetString(SR.net_io_invalidasyncresult), "asyncResult");
}
if (castedAsyncResult.EndCalled) {
throw new InvalidOperationException(SR.GetString(SR.net_io_invalidendcall, "EndReceiveMessageFrom"));
}
SocketAddress socketAddressOriginal = SnapshotAndSerialize(ref endPoint);
int bytesTransferred = (int)castedAsyncResult.InternalWaitForCompletion();
castedAsyncResult.EndCalled = true;
castedAsyncResult.ExtractCache(ref Caches.ReceiveOverlappedCache);
// Update socket address size
castedAsyncResult.SocketAddress.SetSize(castedAsyncResult.GetSocketAddressSizePtr());
if (!socketAddressOriginal.Equals(castedAsyncResult.SocketAddress)) {
try {
endPoint = endPoint.Create(castedAsyncResult.SocketAddress);
}
catch {
}
}
#if !FEATURE_PAL // perfcounter
if (s_PerfCountersEnabled)
{
if (bytesTransferred>0) {
NetworkingPerfCounters.Instance.Increment(NetworkingPerfCounterName.SocketBytesReceived, bytesTransferred);
if (Transport==TransportType.Udp) {
NetworkingPerfCounters.Instance.Increment(NetworkingPerfCounterName.SocketDatagramsReceived);
}
}
}
#endif //!FEATURE_PAL
GlobalLog.Print("Socket#" + ValidationHelper.HashString(this) + "::EndReceiveMessageFrom() bytesTransferred:" + bytesTransferred.ToString());
//
// if the asynchronous native call failed asynchronously
// we'll throw a SocketException
//
if ((SocketError)castedAsyncResult.ErrorCode!=SocketError.Success && (SocketError)castedAsyncResult.ErrorCode != SocketError.MessageSize) {
//
// update our internal state after this socket error and throw
//
SocketException socketException = new SocketException(castedAsyncResult.ErrorCode);
UpdateStatusAfterSocketError(socketException);
if(s_LoggingEnabled)Logging.Exception(Logging.Sockets, this, "EndReceiveMessageFrom", socketException);
throw socketException;
}
socketFlags = castedAsyncResult.m_flags;
ipPacketInformation = castedAsyncResult.m_IPPacketInformation;
if(s_LoggingEnabled)Logging.Exit(Logging.Sockets, this, "EndReceiveMessageFrom", bytesTransferred);
return bytesTransferred;
}
public int EndReceiveMessageFrom(IAsyncResult asyncResult, ref SocketFlags socketFlags, ref EndPoint endPoint, out IPPacketInformation ipPacketInformation)
{
if(Logging.On)Logging.Enter(Logging.Sockets, this, "EndReceiveMessageFrom", asyncResult);
if (CleanedUp) {
throw new ObjectDisposedException(this.GetType().FullName);
}
if (endPoint==null) {
throw new ArgumentNullException("endPoint");
}
if (asyncResult==null) {
throw new ArgumentNullException("asyncResult");
}
ReceiveMessageOverlappedAsyncResult castedAsyncResult = asyncResult as ReceiveMessageOverlappedAsyncResult;
if (castedAsyncResult==null || castedAsyncResult.AsyncObject!=this) {
throw new ArgumentException(SR.GetString(SR.net_io_invalidasyncresult), "asyncResult");
}
if (castedAsyncResult.EndCalled) {
throw new InvalidOperationException(SR.GetString(SR.net_io_invalidendcall, "EndReceiveMessageFrom"));
}
int bytesTransferred = (int)castedAsyncResult.InternalWaitForCompletion();
castedAsyncResult.EndCalled = true;
castedAsyncResult.ExtractCache(ref Caches.ReceiveOverlappedCache);
// Update socket address size
castedAsyncResult.SocketAddress.SetSize(castedAsyncResult.GetSocketAddressSizePtr());
// pick up the saved copy of the original EndPoint from the asyncResult
SocketAddress socketAddressOriginal = endPoint.Serialize();
if (!socketAddressOriginal.Equals(castedAsyncResult.SocketAddress)) {
try {
endPoint = endPoint.Create(castedAsyncResult.SocketAddress);
}
catch {
}
}
GlobalLog.Print("Socket#" + ValidationHelper.HashString(this) + "::EndReceiveMessageFrom() bytesTransferred:" + bytesTransferred.ToString());
//
// if the asynchronous native call failed asynchronously
// we'll throw a SocketException
//
if ((SocketError)castedAsyncResult.ErrorCode!=SocketError.Success && (SocketError)castedAsyncResult.ErrorCode != SocketError.MessageSize) {
//
// update our internal state after this socket error and throw
//
SocketException socketException = new SocketException(castedAsyncResult.ErrorCode);
UpdateStatusAfterSocketError(socketException);
if(Logging.On)Logging.Exception(Logging.Sockets, this, "EndReceiveMessageFrom", socketException);
throw socketException;
}
socketFlags = castedAsyncResult.m_flags;
ipPacketInformation = castedAsyncResult.m_IPPacketInformation;
if(Logging.On)Logging.Exit(Logging.Sockets, this, "EndReceiveMessageFrom", bytesTransferred);
return bytesTransferred;
}
private static unsafe int ReceiveMessageFrom(int fd, int flags, int available, byte[] buffer, int offset, int count, byte[] socketAddress, ref int socketAddressLen, bool isIPv4, bool isIPv6, out int receivedFlags, out IPPacketInformation ipPacketInformation, out Interop.Error errno)
{
Debug.Assert(socketAddress != null);
int cmsgBufferLen =
(isIPv4 ? AlignControlMessageSize(sizeof(Interop.libc.cmsghdr) + sizeof(Interop.libc.in_pktinfo)) : 0) +
(isIPv6 ? AlignControlMessageSize(sizeof(Interop.libc.cmsghdr) + sizeof(Interop.libc.in6_pktinfo)) : 0);
var cmsgBuffer = stackalloc byte[cmsgBufferLen];
var sockAddrLen = (uint)socketAddressLen;
int received;
fixed (byte* rawSocketAddress = socketAddress)
fixed (byte* b = buffer)
{
var sockAddr = (Interop.libc.sockaddr*)rawSocketAddress;
var iov = new Interop.libc.iovec {
iov_base = &b[offset],
iov_len = (IntPtr)count
};
var msghdr = new Interop.libc.msghdr(sockAddr, sockAddrLen, &iov, 1, cmsgBuffer, cmsgBufferLen, 0);
received = (int)Interop.libc.recvmsg(fd, &msghdr, flags);
receivedFlags = msghdr.msg_flags;
sockAddrLen = msghdr.msg_namelen;
cmsgBufferLen = (int)msghdr.msg_controllen;
}
ipPacketInformation = GetIPPacketInformation(cmsgBuffer, cmsgBufferLen, isIPv4, isIPv6);
if (received == -1)
{
errno = Interop.Sys.GetLastError();
return -1;
}
socketAddressLen = (int)sockAddrLen;
errno = Interop.Error.SUCCESS;
return received;
}
/// <devdoc>
/// <para>Receives a datagram into a specific location in the data buffer and stores
/// the end point.</para>
/// </devdoc>
public int ReceiveMessageFrom(byte[] buffer, int offset, int size, ref SocketFlags socketFlags, ref EndPoint remoteEP, out IPPacketInformation ipPacketInformation)
{
if(Logging.On)Logging.Enter(Logging.Sockets, this, "ReceiveMessageFrom", "");
if (CleanedUp) {
throw new ObjectDisposedException(this.GetType().FullName);
}
if (buffer==null) {
throw new ArgumentNullException("buffer");
}
if (remoteEP==null) {
throw new ArgumentNullException("remoteEP");
}
if (offset<0 || offset>buffer.Length) {
throw new ArgumentOutOfRangeException("offset");
}
if (size<0 || size>buffer.Length-offset) {
throw new ArgumentOutOfRangeException("size");
}
if (m_RightEndPoint==null) {
throw new InvalidOperationException(SR.GetString(SR.net_sockets_mustbind));
}
ValidateBlockingMode();
// This will check the permissions for connect.
EndPoint endPointSnapshot = remoteEP;
SocketAddress socketAddress = CheckCacheRemote(ref endPointSnapshot, false);
ReceiveMessageOverlappedAsyncResult asyncResult = new ReceiveMessageOverlappedAsyncResult(this,null,null);
asyncResult.SetUnmanagedStructures(buffer, offset, size, socketAddress, socketFlags);
// save a copy of the original EndPoint
SocketAddress socketAddressOriginal = endPointSnapshot.Serialize();
//setup structure
int bytesTransfered = 0;
SocketError errorCode = SocketError.Success;
if(addressFamily == AddressFamily.InterNetwork) {
SetSocketOption(SocketOptionLevel.IP,SocketOptionName.PacketInformation,true);
}
else if (addressFamily == AddressFamily.InterNetworkV6){
SetSocketOption(SocketOptionLevel.IPv6,SocketOptionName.PacketInformation,true);
}
try
{
// This can throw ObjectDisposedException (retrieving the delegate AND resolving the handle).
if (WSARecvMsg_Blocking(
m_Handle.DangerousGetHandle(),
Marshal.UnsafeAddrOfPinnedArrayElement(asyncResult.m_MessageBuffer,0),
out bytesTransfered,
IntPtr.Zero,
IntPtr.Zero) == SocketError.SocketError)
{
errorCode = (SocketError)Marshal.GetLastWin32Error();
}
}
finally {
asyncResult.SyncReleaseUnmanagedStructures();
}
//
// if the native call fails we'll throw a SocketException
//
if (errorCode!=SocketError.Success && errorCode != SocketError.MessageSize) {
//
// update our internal state after this socket error and throw
//
SocketException socketException = new SocketException(errorCode);
UpdateStatusAfterSocketError(socketException);
if(Logging.On)Logging.Exception(Logging.Sockets, this, "ReceiveMessageFrom", socketException);
throw socketException;
}
if (!socketAddressOriginal.Equals(asyncResult.m_SocketAddress))
{
try {
remoteEP = endPointSnapshot.Create(asyncResult.m_SocketAddress);
}
catch {
}
if (m_RightEndPoint==null) {
//
// save a copy of the EndPoint so we can use it for Create()
//
m_RightEndPoint = endPointSnapshot;
}
}
socketFlags = asyncResult.m_flags;
ipPacketInformation = asyncResult.m_IPPacketInformation;
if(Logging.On)Logging.Exit(Logging.Sockets, this, "ReceiveMessageFrom", errorCode);
return bytesTransfered;
}
public static unsafe bool TryCompleteReceiveMessageFrom(int fileDescriptor, byte[] buffer, int offset, int count, SocketFlags flags, byte[] socketAddress, ref int socketAddressLen, bool isIPv4, bool isIPv6, out int bytesReceived, out SocketFlags receivedFlags, out IPPacketInformation ipPacketInformation, out SocketError errorCode)
{
int available;
Interop.Error errno = Interop.Sys.GetBytesAvailable(fileDescriptor, &available);
if (errno != Interop.Error.SUCCESS)
{
bytesReceived = 0;
receivedFlags = 0;
ipPacketInformation = default(IPPacketInformation);
errorCode = GetSocketErrorForErrorCode(errno);
return true;
}
if (available == 0)
{
// Always request at least one byte.
available = 1;
}
int received = ReceiveMessageFrom(fileDescriptor, flags, available, buffer, offset, count, socketAddress, ref socketAddressLen, isIPv4, isIPv6, out receivedFlags, out ipPacketInformation, out errno);
if (received != -1)
{
bytesReceived = received;
errorCode = SocketError.Success;
return true;
}
bytesReceived = 0;
if (errno != Interop.Error.EAGAIN && errno != Interop.Error.EWOULDBLOCK)
{
errorCode = GetSocketErrorForErrorCode(errno);
return true;
}
errorCode = SocketError.Success;
return false;
}
/// <summary>
/// Ends a pending asynchronous read from a specific endpoint. This method also reveals more information about the packet than <see cref="M:System.Net.Sockets.Socket.EndReceiveFrom(System.IAsyncResult,System.Net.EndPoint@)"/>.
/// </summary>
///
/// <returns>
/// If successful, the number of bytes received. If unsuccessful, returns 0.
/// </returns>
/// <param name="asyncResult">An <see cref="T:System.IAsyncResult"/> that stores state information and any user defined data for this asynchronous operation.</param><param name="socketFlags">A bitwise combination of the <see cref="T:System.Net.Sockets.SocketFlags"/> values for the received packet.</param><param name="endPoint">The source <see cref="T:System.Net.EndPoint"/>.</param><param name="ipPacketInformation">The <see cref="T:System.Net.IPAddress"/> and interface of the received packet.</param><exception cref="T:System.ArgumentNullException"><paramref name="asyncResult"/> is null-or- <paramref name="endPoint"/> is null. </exception><exception cref="T:System.ArgumentException"><paramref name="asyncResult"/> was not returned by a call to the <see cref="M:System.Net.Sockets.Socket.BeginReceiveMessageFrom(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint@,System.AsyncCallback,System.Object)"/> method. </exception><exception cref="T:System.InvalidOperationException"><see cref="M:System.Net.Sockets.Socket.EndReceiveMessageFrom(System.IAsyncResult,System.Net.Sockets.SocketFlags@,System.Net.EndPoint@,System.Net.Sockets.IPPacketInformation@)"/> was previously called for the asynchronous read. </exception><exception cref="T:System.Net.Sockets.SocketException">An error occurred when attempting to access the socket. See the Remarks section for more information. </exception><exception cref="T:System.ObjectDisposedException">The <see cref="T:System.Net.Sockets.Socket"/> has been closed. </exception>
public int EndReceiveMessageFrom(IAsyncResult asyncResult, ref SocketFlags socketFlags, ref EndPoint endPoint, out IPPacketInformation ipPacketInformation)
{
if (Socket.s_LoggingEnabled)
Logging.Enter(Logging.Sockets, (object) this, "EndReceiveMessageFrom", (object) asyncResult);
if (this.CleanedUp)
throw new ObjectDisposedException(this.GetType().FullName);
if (endPoint == null)
throw new ArgumentNullException("endPoint");
if (!this.CanTryAddressFamily(endPoint.AddressFamily))
{
throw new ArgumentException(SR.GetString("net_InvalidEndPointAddressFamily", (object) endPoint.AddressFamily, (object) this.addressFamily), "endPoint");
}
else
{
if (asyncResult == null)
throw new ArgumentNullException("asyncResult");
ReceiveMessageOverlappedAsyncResult overlappedAsyncResult = asyncResult as ReceiveMessageOverlappedAsyncResult;
if (overlappedAsyncResult == null || overlappedAsyncResult.AsyncObject != this)
throw new ArgumentException(SR.GetString("net_io_invalidasyncresult"), "asyncResult");
if (overlappedAsyncResult.EndCalled)
{
throw new InvalidOperationException(SR.GetString("net_io_invalidendcall", new object[1]
{
(object) "EndReceiveMessageFrom"
}));
}
else
{
SocketAddress socketAddress = this.SnapshotAndSerialize(ref endPoint);
int num = (int) overlappedAsyncResult.InternalWaitForCompletion();
overlappedAsyncResult.EndCalled = true;
overlappedAsyncResult.ExtractCache(ref this.Caches.ReceiveOverlappedCache);
overlappedAsyncResult.SocketAddress.SetSize(overlappedAsyncResult.GetSocketAddressSizePtr());
if (!socketAddress.Equals((object) overlappedAsyncResult.SocketAddress))
{
try
{
endPoint = endPoint.Create(overlappedAsyncResult.SocketAddress);
}
catch
{
}
}
if (Socket.s_PerfCountersEnabled && num > 0)
{
NetworkingPerfCounters.Instance.Increment(NetworkingPerfCounterName.SocketBytesReceived, (long) num);
if (this.Transport == TransportType.Udp)
NetworkingPerfCounters.Instance.Increment(NetworkingPerfCounterName.SocketDatagramsReceived);
}
if (overlappedAsyncResult.ErrorCode != 0 && overlappedAsyncResult.ErrorCode != 10040)
{
SocketException socketException = new SocketException(overlappedAsyncResult.ErrorCode);
this.UpdateStatusAfterSocketError(socketException);
if (Socket.s_LoggingEnabled)
Logging.Exception(Logging.Sockets, (object) this, "EndReceiveMessageFrom", (Exception) socketException);
throw socketException;
}
else
{
socketFlags = overlappedAsyncResult.m_flags;
ipPacketInformation = overlappedAsyncResult.m_IPPacketInformation;
if (Socket.s_LoggingEnabled)
Logging.Exit(Logging.Sockets, (object) this, "EndReceiveMessageFrom", (object) num);
return num;
}
}
}
}
private unsafe void FinishOperationReceiveMessageFrom()
{
IPAddress address = null;
Interop.Winsock.WSAMsg* PtrMessage = (Interop.Winsock.WSAMsg*)Marshal.UnsafeAddrOfPinnedArrayElement(_wsaMessageBuffer, 0);
if (_controlBuffer.Length == s_controlDataSize)
{
// IPv4.
Interop.Winsock.ControlData controlData = Marshal.PtrToStructure<Interop.Winsock.ControlData>(PtrMessage->controlBuffer.Pointer);
if (controlData.length != UIntPtr.Zero)
{
address = new IPAddress((long)controlData.address);
}
_receiveMessageFromPacketInfo = new IPPacketInformation(((address != null) ? address : IPAddress.None), (int)controlData.index);
}
else if (_controlBuffer.Length == s_controlDataIPv6Size)
{
// IPv6.
Interop.Winsock.ControlDataIPv6 controlData = Marshal.PtrToStructure<Interop.Winsock.ControlDataIPv6>(PtrMessage->controlBuffer.Pointer);
if (controlData.length != UIntPtr.Zero)
{
address = new IPAddress(controlData.address);
}
_receiveMessageFromPacketInfo = new IPPacketInformation(((address != null) ? address : IPAddress.IPv6None), (int)controlData.index);
}
else
{
// Other.
_receiveMessageFromPacketInfo = new IPPacketInformation();
}
}
/// <summary>
/// Receives the specified number of bytes of data into the specified location of the data buffer, using the specified <see cref="T:System.Net.Sockets.SocketFlags"/>, and stores the endpoint and packet information.
/// </summary>
///
/// <returns>
/// The number of bytes received.
/// </returns>
/// <param name="buffer">An array of type <see cref="T:System.Byte"/> that is the storage location for received data.</param><param name="offset">The position in the <paramref name="buffer"/> parameter to store the received data.</param><param name="size">The number of bytes to receive.</param><param name="socketFlags">A bitwise combination of the <see cref="T:System.Net.Sockets.SocketFlags"/> values.</param><param name="remoteEP">An <see cref="T:System.Net.EndPoint"/>, passed by reference, that represents the remote server.</param><param name="ipPacketInformation">An <see cref="T:System.Net.Sockets.IPPacketInformation"/> holding address and interface information.</param><exception cref="T:System.ArgumentNullException"><paramref name="buffer"/> is null.- or- <paramref name="remoteEP"/> is null. </exception><exception cref="T:System.ArgumentOutOfRangeException"><paramref name="offset"/> is less than 0.-or- <paramref name="offset"/> is greater than the length of <paramref name="buffer"/>.-or- <paramref name="size"/> is less than 0.-or- <paramref name="size"/> is greater than the length of the <paramref name="buffer"/> minus the value of the offset parameter. </exception><exception cref="T:System.Net.Sockets.SocketException"><paramref name="socketFlags"/> is not a valid combination of values.-or- The <see cref="P:System.Net.Sockets.Socket.LocalEndPoint"/> property was not set.-or- The .NET Framework is running on an AMD 64-bit processor.-or- An error occurred when attempting to access the socket. See the Remarks section for more information. </exception><exception cref="T:System.ObjectDisposedException">The <see cref="T:System.Net.Sockets.Socket"/> has been closed. </exception><exception cref="T:System.NotSupportedException">The operating system is Windows 2000 or earlier, and this method requires Windows XP.</exception>
public int ReceiveMessageFrom(byte[] buffer, int offset, int size, ref SocketFlags socketFlags, ref EndPoint remoteEP, out IPPacketInformation ipPacketInformation)
{
if (Socket.s_LoggingEnabled)
Logging.Enter(Logging.Sockets, (object) this, "ReceiveMessageFrom", "");
if (this.CleanedUp)
throw new ObjectDisposedException(this.GetType().FullName);
if (buffer == null)
throw new ArgumentNullException("buffer");
if (remoteEP == null)
throw new ArgumentNullException("remoteEP");
if (!this.CanTryAddressFamily(remoteEP.AddressFamily))
{
throw new ArgumentException(SR.GetString("net_InvalidEndPointAddressFamily", (object) remoteEP.AddressFamily, (object) this.addressFamily), "remoteEP");
}
else
{
if (offset < 0 || offset > buffer.Length)
throw new ArgumentOutOfRangeException("offset");
if (size < 0 || size > buffer.Length - offset)
throw new ArgumentOutOfRangeException("size");
if (this.m_RightEndPoint == null)
throw new InvalidOperationException(SR.GetString("net_sockets_mustbind"));
this.ValidateBlockingMode();
EndPoint remoteEP1 = remoteEP;
SocketAddress socketAddress1 = this.SnapshotAndSerialize(ref remoteEP1);
ReceiveMessageOverlappedAsyncResult overlappedAsyncResult = new ReceiveMessageOverlappedAsyncResult(this, (object) null, (AsyncCallback) null);
overlappedAsyncResult.SetUnmanagedStructures(buffer, offset, size, socketAddress1, socketFlags);
SocketAddress socketAddress2 = remoteEP1.Serialize();
int bytesTransferred = 0;
SocketError socketError = SocketError.Success;
this.SetReceivingPacketInformation();
try
{
if (this.WSARecvMsg_Blocking(this.m_Handle.DangerousGetHandle(), Marshal.UnsafeAddrOfPinnedArrayElement((Array) overlappedAsyncResult.m_MessageBuffer, 0), out bytesTransferred, IntPtr.Zero, IntPtr.Zero) == SocketError.SocketError)
socketError = (SocketError) Marshal.GetLastWin32Error();
}
finally
{
overlappedAsyncResult.SyncReleaseUnmanagedStructures();
}
if (socketError != SocketError.Success && socketError != SocketError.MessageSize)
{
SocketException socketException = new SocketException(socketError);
this.UpdateStatusAfterSocketError(socketException);
if (Socket.s_LoggingEnabled)
Logging.Exception(Logging.Sockets, (object) this, "ReceiveMessageFrom", (Exception) socketException);
throw socketException;
}
else
{
if (!socketAddress2.Equals((object) overlappedAsyncResult.m_SocketAddress))
{
try
{
remoteEP = remoteEP1.Create(overlappedAsyncResult.m_SocketAddress);
}
catch
{
}
if (this.m_RightEndPoint == null)
this.m_RightEndPoint = remoteEP1;
}
socketFlags = overlappedAsyncResult.m_flags;
ipPacketInformation = overlappedAsyncResult.m_IPPacketInformation;
if (Socket.s_LoggingEnabled)
Logging.Exit(Logging.Sockets, (object) this, "ReceiveMessageFrom", (object) socketError);
return bytesTransferred;
}
}
}
public int ReceiveMessageFrom (byte[] buffer, int offset,
int size,
ref SocketFlags socketFlags,
ref EndPoint remoteEP,
out IPPacketInformation ipPacketInformation)
{
if (disposed && closed)
throw new ObjectDisposedException (GetType ().ToString ());
if (buffer == null)
throw new ArgumentNullException ("buffer");
if (remoteEP == null)
throw new ArgumentNullException ("remoteEP");
CheckRange (buffer, offset, size);
/* FIXME: figure out how we get hold of the
* IPPacketInformation
*/
throw new NotImplementedException ();
}
private void ReceiveMessageFromCompletionCallback(int bytesTransferred, byte[] socketAddress, int socketAddressSize, SocketFlags receivedFlags, IPPacketInformation ipPacketInformation, SocketError errorCode)
{
Debug.Assert(_socketAddress != null);
Debug.Assert(socketAddress == null || _socketAddress.Buffer == socketAddress);
_socketAddressSize = socketAddressSize;
_receivedFlags = receivedFlags;
_receiveMessageFromPacketInfo = ipPacketInformation;
CompletionCallback(bytesTransferred, errorCode);
}
int Utils.Wrappers.Interfaces.ISocket.ReceiveMessageFrom(byte[] buffer, int offset, int size, ref SocketFlags socketFlags, ref System.Net.EndPoint remoteEP, out System.Net.Sockets.IPPacketInformation ipPacketInformation)
{
return(InternalSocket.ReceiveMessageFrom(buffer, offset, size, ref socketFlags, ref remoteEP, out ipPacketInformation));
}
public int EndReceiveMessageFrom(IAsyncResult result, ref SocketFlags socketFlags, ref EndPoint endPoint, out IPPacketInformation ipPacketInformation)
{
return socket.EndReceiveMessageFrom(result, ref socketFlags, ref endPoint, out ipPacketInformation);
}
internal int EndReceiveMessageFrom(IAsyncResult asyncResult, ref SocketFlags socketFlags, ref EndPoint endPoint, out IPPacketInformation ipPacketInformation)
{
if (s_loggingEnabled)
{
Logging.Enter(Logging.Sockets, this, "EndReceiveMessageFrom", asyncResult);
}
if (CleanedUp)
{
throw new ObjectDisposedException(this.GetType().FullName);
}
if (endPoint == null)
{
throw new ArgumentNullException("endPoint");
}
if (!CanTryAddressFamily(endPoint.AddressFamily))
{
throw new ArgumentException(SR.Format(SR.net_InvalidEndPointAddressFamily, endPoint.AddressFamily, _addressFamily), "endPoint");
}
if (asyncResult == null)
{
throw new ArgumentNullException("asyncResult");
}
ReceiveMessageOverlappedAsyncResult castedAsyncResult = asyncResult as ReceiveMessageOverlappedAsyncResult;
if (castedAsyncResult == null || castedAsyncResult.AsyncObject != this)
{
throw new ArgumentException(SR.net_io_invalidasyncresult, "asyncResult");
}
if (castedAsyncResult.EndCalled)
{
throw new InvalidOperationException(SR.Format(SR.net_io_invalidendcall, "EndReceiveMessageFrom"));
}
Internals.SocketAddress socketAddressOriginal = SnapshotAndSerialize(ref endPoint);
int bytesTransferred = (int)castedAsyncResult.InternalWaitForCompletion();
castedAsyncResult.EndCalled = true;
// Update socket address size.
castedAsyncResult.SocketAddress.InternalSize = castedAsyncResult.GetSocketAddressSize();
if (!socketAddressOriginal.Equals(castedAsyncResult.SocketAddress))
{
try
{
endPoint = endPoint.Create(castedAsyncResult.SocketAddress);
}
catch
{
}
}
if (s_perfCountersEnabled)
{
if (bytesTransferred > 0)
{
SocketPerfCounter.Instance.Increment(SocketPerfCounterName.SocketBytesReceived, bytesTransferred);
if (Transport == TransportType.Udp)
{
SocketPerfCounter.Instance.Increment(SocketPerfCounterName.SocketDatagramsReceived);
}
}
}
GlobalLog.Print("Socket#" + Logging.HashString(this) + "::EndReceiveMessageFrom() bytesTransferred:" + bytesTransferred.ToString());
// Throw an appropriate SocketException if the native call failed asynchronously.
if ((SocketError)castedAsyncResult.ErrorCode != SocketError.Success && (SocketError)castedAsyncResult.ErrorCode != SocketError.MessageSize)
{
// Update the internal state of this socket according to the error before throwing.
SocketException socketException = new SocketException(castedAsyncResult.ErrorCode);
UpdateStatusAfterSocketError(socketException);
if (s_loggingEnabled)
{
Logging.Exception(Logging.Sockets, this, "EndReceiveMessageFrom", socketException);
}
throw socketException;
}
socketFlags = castedAsyncResult.SocketFlags;
ipPacketInformation = castedAsyncResult.IPPacketInformation;
if (s_loggingEnabled)
{
Logging.Exit(Logging.Sockets, this, "EndReceiveMessageFrom", bytesTransferred);
}
return bytesTransferred;
}
public static SocketError ReceiveMessageFrom(Socket socket, SafeCloseSocket handle, byte[] buffer, int offset, int size, ref SocketFlags socketFlags, Internals.SocketAddress socketAddress, out Internals.SocketAddress receiveAddress, out IPPacketInformation ipPacketInformation, out int bytesTransferred)
{
ReceiveMessageOverlappedAsyncResult asyncResult = new ReceiveMessageOverlappedAsyncResult(socket, null, null);
asyncResult.SetUnmanagedStructures(buffer, offset, size, socketAddress, socketFlags);
SocketError errorCode = SocketError.Success;
bytesTransferred = 0;
try
{
// This can throw ObjectDisposedException (retrieving the delegate AND resolving the handle).
if (socket.WSARecvMsgBlocking(
handle.DangerousGetHandle(),
Marshal.UnsafeAddrOfPinnedArrayElement(asyncResult._messageBuffer, 0),
out bytesTransferred,
IntPtr.Zero,
IntPtr.Zero) == SocketError.SocketError)
{
errorCode = (SocketError)Marshal.GetLastWin32Error();
}
}
finally
{
asyncResult.SyncReleaseUnmanagedStructures();
}
socketFlags = asyncResult.SocketFlags;
receiveAddress = asyncResult.SocketAddress;
ipPacketInformation = asyncResult.IPPacketInformation;
return errorCode;
}
public int EndReceiveMessageFrom (IAsyncResult asyncResult, ref SocketFlags socketFlags, ref EndPoint endPoint, out IPPacketInformation ipPacketInformation)
{
ThrowIfDisposedAndClosed ();
if (endPoint == null)
throw new ArgumentNullException ("endPoint");
SocketAsyncResult sockares = ValidateEndIAsyncResult (asyncResult, "EndReceiveMessageFrom", "asyncResult");
throw new NotImplementedException ();
}
public void CompletionCallback(int numBytes, byte[] socketAddress, int socketAddressSize, int receivedFlags, IPPacketInformation ipPacketInformation, SocketError errorCode)
{
Debug.Assert(_socketAddress != null);
Debug.Assert(socketAddress == null || _socketAddress.Buffer == socketAddress);
_socketAddressSize = socketAddressSize;
_socketFlags = SocketPal.GetSocketFlags(receivedFlags);
_ipPacketInformation = ipPacketInformation;
base.CompletionCallback(numBytes, errorCode);
}