mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
582 lines
23 KiB
C#
582 lines
23 KiB
C#
//----------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//----------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel.Channels
|
|
{
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Net;
|
|
using System.Net.NetworkInformation;
|
|
using System.Net.Sockets;
|
|
using System.Runtime;
|
|
using System.Xml;
|
|
|
|
static class UdpUtility
|
|
{
|
|
public static Uri AppendRelativePath(Uri basepath, string relativePath)
|
|
{
|
|
// Ensure that baseAddress Path does end with a slash if we have a relative address
|
|
if (!string.IsNullOrEmpty(relativePath))
|
|
{
|
|
if (!basepath.AbsolutePath.EndsWith("/", StringComparison.Ordinal))
|
|
{
|
|
UriBuilder uriBuilder = new UriBuilder(basepath);
|
|
uriBuilder.Path = uriBuilder.Path + "/";
|
|
basepath = uriBuilder.Uri;
|
|
}
|
|
|
|
basepath = new Uri(basepath, relativePath);
|
|
}
|
|
|
|
return basepath;
|
|
}
|
|
|
|
public static MessageEncoderFactory GetEncoder(BindingContext context)
|
|
{
|
|
MessageEncodingBindingElement messageEncoderBindingElement = context.BindingParameters.Remove<MessageEncodingBindingElement>();
|
|
MessageEncoderFactory factory = null;
|
|
if (messageEncoderBindingElement != null)
|
|
{
|
|
factory = messageEncoderBindingElement.CreateMessageEncoderFactory();
|
|
}
|
|
else
|
|
{
|
|
factory = UdpConstants.Defaults.MessageEncoderFactory;
|
|
}
|
|
|
|
return factory;
|
|
}
|
|
|
|
//there are some errors on the server side that we should just ignore because the server will not need
|
|
//to change its behavior if it sees the exception. These errors are not ignored on the client
|
|
//because it may need to adjust settings (e.g. TTL, send smaller messages, double check server address for correctness)
|
|
internal static bool CanIgnoreServerException(Exception ex)
|
|
{
|
|
SocketError error;
|
|
if (UdpUtility.TryGetSocketError(ex, out error))
|
|
{
|
|
switch (error)
|
|
{
|
|
case SocketError.ConnectionReset: //"ICMP Destination Unreachable" error - client closed the socket
|
|
case SocketError.NetworkReset: //ICMP: Time Exceeded (TTL expired)
|
|
case SocketError.MessageSize: //client sent a message larger than the max message size allowed.
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
public static void CheckSocketSupport(out bool ipV4Supported, out bool ipV6Supported)
|
|
{
|
|
ipV4Supported = Socket.OSSupportsIPv4;
|
|
ipV6Supported = Socket.OSSupportsIPv6;
|
|
|
|
ThrowIfNoSocketSupport(ipV4Supported, ipV6Supported);
|
|
}
|
|
|
|
public static bool TryGetLoopbackInterfaceIndex(NetworkInterface adapter, bool ipv4, out int interfaceIndex)
|
|
{
|
|
Fx.Assert(adapter != null, "adapter can't be null");
|
|
Fx.Assert(adapter.NetworkInterfaceType == NetworkInterfaceType.Loopback, "adapter type must be loopback adapter");
|
|
|
|
interfaceIndex = -1;
|
|
bool result = false;
|
|
|
|
if (ipv4 && adapter.Supports(NetworkInterfaceComponent.IPv4))
|
|
{
|
|
interfaceIndex = NetworkInterface.LoopbackInterfaceIndex;
|
|
result = true;
|
|
}
|
|
else if (!ipv4 && adapter.Supports(NetworkInterfaceComponent.IPv6))
|
|
{
|
|
IPInterfaceProperties properties = adapter.GetIPProperties();
|
|
IPv6InterfaceProperties ipv6Properties = properties.GetIPv6Properties();
|
|
interfaceIndex = ipv6Properties.Index;
|
|
result = true;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static UdpSocket CreateUnicastListenSocket(IPAddress ipAddress, ref int port, int receiveBufferSize, int timeToLive)
|
|
{
|
|
return CreateListenSocket(ipAddress, ref port, receiveBufferSize, timeToLive, UdpConstants.Defaults.InterfaceIndex, false, false);
|
|
}
|
|
|
|
public static UdpSocket CreateListenSocket(IPAddress ipAddress, ref int port, int receiveBufferSize, int timeToLive,
|
|
int interfaceIndex, bool allowMulticastLoopback, bool isLoopbackAdapter)
|
|
{
|
|
bool isIPv6 = (ipAddress.AddressFamily == AddressFamily.InterNetworkV6);
|
|
Socket socket = null;
|
|
|
|
bool listenMulticast = IsMulticastAddress(ipAddress);
|
|
|
|
IPEndPoint localEndpoint;
|
|
|
|
if (listenMulticast)
|
|
{
|
|
IPAddress bindAddress = (isIPv6 ? IPAddress.IPv6Any : IPAddress.Any);
|
|
localEndpoint = new IPEndPoint(bindAddress, port);
|
|
}
|
|
else
|
|
{
|
|
localEndpoint = new IPEndPoint(ipAddress, port);
|
|
}
|
|
|
|
socket = new Socket(localEndpoint.AddressFamily, SocketType.Dgram, ProtocolType.Udp);
|
|
|
|
SetPreBindSocketOptions(socket, listenMulticast, receiveBufferSize, (short)timeToLive, interfaceIndex, allowMulticastLoopback, isLoopbackAdapter);
|
|
|
|
BindSocket(socket, localEndpoint);
|
|
|
|
SetPostBindSocketOptions(socket, listenMulticast, ipAddress, interfaceIndex);
|
|
|
|
if (port == 0)
|
|
{
|
|
//update the port to be the actual one the socket is bound to...
|
|
port = ((IPEndPoint)socket.LocalEndPoint).Port;
|
|
}
|
|
|
|
|
|
return new UdpSocket(socket, interfaceIndex);
|
|
}
|
|
|
|
//returns the port number used...
|
|
public static int CreateListenSocketsOnUniquePort(IPAddress ipv4Address, IPAddress ipv6Address, int receiveBufferSize, int timeToLive, out UdpSocket ipv4Socket, out UdpSocket ipv6Socket)
|
|
{
|
|
// We need both IPv4 and IPv6 on the same port. We can't atomicly bind for IPv4 and IPv6,
|
|
// so we try 10 times, which even with a 50% failure rate will statistically succeed 99.9% of the time.
|
|
//
|
|
// We look in the range of 49152-65534 for Vista default behavior parity.
|
|
// http://www.iana.org/assignments/port-numbers
|
|
//
|
|
// We also grab the 10 random numbers in a row to reduce collisions between multiple people somehow
|
|
// colliding on the same seed.
|
|
const int retries = 10;
|
|
const int lowWatermark = 49152;
|
|
const int highWatermark = 65535;
|
|
|
|
ipv4Socket = null;
|
|
ipv6Socket = null;
|
|
|
|
int[] portNumbers = new int[retries];
|
|
|
|
Random randomNumberGenerator = new Random(AppDomain.CurrentDomain.GetHashCode() | Environment.TickCount);
|
|
|
|
for (int i = 0; i < retries; i++)
|
|
{
|
|
portNumbers[i] = randomNumberGenerator.Next(lowWatermark, highWatermark);
|
|
}
|
|
|
|
|
|
int port = -1;
|
|
for (int i = 0; i < retries; i++)
|
|
{
|
|
port = portNumbers[i];
|
|
try
|
|
{
|
|
ipv4Socket = UdpUtility.CreateUnicastListenSocket(ipv4Address, ref port, receiveBufferSize, timeToLive);
|
|
ipv6Socket = UdpUtility.CreateUnicastListenSocket(ipv6Address, ref port, receiveBufferSize, timeToLive);
|
|
break;
|
|
}
|
|
catch (AddressAlreadyInUseException)
|
|
{
|
|
if (ipv4Socket != null)
|
|
{
|
|
ipv4Socket.Close();
|
|
ipv4Socket = null;
|
|
}
|
|
ipv6Socket = null;
|
|
}
|
|
catch (AddressAccessDeniedException)
|
|
{
|
|
if (ipv4Socket != null)
|
|
{
|
|
ipv4Socket.Close();
|
|
ipv4Socket = null;
|
|
}
|
|
ipv6Socket = null;
|
|
}
|
|
}
|
|
|
|
if (ipv4Socket == null)
|
|
{
|
|
throw FxTrace.Exception.AsError(new AddressAlreadyInUseException(SR.UniquePortNotAvailable));
|
|
}
|
|
|
|
Fx.Assert(ipv4Socket != null, "An exception should have been thrown if the ipv4Socket socket is null");
|
|
Fx.Assert(ipv6Socket != null, "An exception should have been thrown if the ipv6Socket socket is null");
|
|
Fx.Assert(port > 0, "The port number should have been greater than 0. Actual value was " + port);
|
|
|
|
return port;
|
|
}
|
|
|
|
public static void ValidateDuplicateDetectionAndRetransmittionSupport(MessageEncoderFactory messageEncoderFactory, bool retransmissionEnabled, bool duplicateDetectionEnabled)
|
|
{
|
|
Fx.Assert(messageEncoderFactory != null, "messageEncoderFactory shouldn't be null");
|
|
|
|
MessageVersion encoderMessageVersion = messageEncoderFactory.MessageVersion;
|
|
|
|
if (encoderMessageVersion.Addressing == AddressingVersion.None)
|
|
{
|
|
if (retransmissionEnabled)
|
|
{
|
|
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.TransportRequiresAddressingOnEncoderForRetransmission(encoderMessageVersion, "RetransmissionSettings", typeof(UdpTransportBindingElement).Name)));
|
|
}
|
|
|
|
if (duplicateDetectionEnabled)
|
|
{
|
|
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.TransportRequiresAddressingOnEncoderForDuplicateDetection(encoderMessageVersion, "DuplicateMessageHistoryLength", typeof(UdpTransportBindingElement).Name)));
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void ThrowIfNoSocketSupport()
|
|
{
|
|
ThrowIfNoSocketSupport(Socket.OSSupportsIPv4, Socket.OSSupportsIPv6);
|
|
}
|
|
|
|
public static void ThrowOnUnsupportedHostNameType(Uri uri)
|
|
{
|
|
bool ipV4, ipV6;
|
|
CheckSocketSupport(out ipV4, out ipV6);
|
|
if (!ipV4 && uri.HostNameType == UriHostNameType.IPv4 || !ipV6 && uri.HostNameType == UriHostNameType.IPv6)
|
|
{
|
|
throw FxTrace.Exception.AsError(new ArgumentException(SR.UriHostNameTypeNotSupportedByOS(uri.Host, uri.HostNameType.ToString())));
|
|
}
|
|
}
|
|
|
|
static void ThrowIfNoSocketSupport(bool ipv4Supported, bool ipv6Supported)
|
|
{
|
|
if (!ipv4Supported && !ipv6Supported)
|
|
{
|
|
throw FxTrace.Exception.AsError(new NotSupportedException(SR.IPv4OrIPv6Required));
|
|
}
|
|
}
|
|
|
|
public static NetworkInterface[] GetMulticastInterfaces(string multicastInterfaceIdentifier)
|
|
{
|
|
NetworkInterface[] adapters = NetworkInterface.GetAllNetworkInterfaces();
|
|
|
|
Fx.Assert(adapters != null, "NetworkInterface.GetAllNetworkInterfaces() should never return null");
|
|
|
|
NetworkInterface[] results = null;
|
|
|
|
if (string.IsNullOrEmpty(multicastInterfaceIdentifier)) //find all supported NICs
|
|
{
|
|
List<NetworkInterface> supportedAdapters = new List<NetworkInterface>();
|
|
|
|
for (int i = 0; i < adapters.Length; i++)
|
|
{
|
|
NetworkInterface adapter = adapters[i];
|
|
|
|
if (IsSuitableForMulticast(adapter))
|
|
{
|
|
supportedAdapters.Add(adapter);
|
|
}
|
|
}
|
|
|
|
//OK to return an empty array in this case, the calling code will throw an exception
|
|
//with better context information that what we have here...
|
|
results = supportedAdapters.ToArray();
|
|
}
|
|
else //Only looking for one interface...
|
|
{
|
|
for (int i = 0; i < adapters.Length; i++)
|
|
{
|
|
NetworkInterface adapter = adapters[i];
|
|
|
|
if (string.Equals(adapter.Id, multicastInterfaceIdentifier, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
if (IsSuitableForMulticast(adapter))
|
|
{
|
|
OperationalStatus status = adapter.OperationalStatus;
|
|
if (status != OperationalStatus.Up)
|
|
{
|
|
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.UdpAdapterSpecifiedNotConnected(multicastInterfaceIdentifier, status)));
|
|
}
|
|
|
|
results = new NetworkInterface[] { adapter };
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.UdpAdapterSpecifiedNotSuitableForMulticast(multicastInterfaceIdentifier)));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (results == null || results.Length == 0)
|
|
{
|
|
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.UdpInterfaceIndexMatchNotFound(multicastInterfaceIdentifier)));
|
|
}
|
|
}
|
|
|
|
Fx.Assert(results != null, "A null list of network adapters should never be returned. It should either be an empty list or an exception should have been thrown.");
|
|
return results;
|
|
}
|
|
|
|
public static bool IsMulticastAddress(IPAddress address)
|
|
{
|
|
if (address.AddressFamily == AddressFamily.InterNetwork)
|
|
{
|
|
// 224.0.0.0 through 239.255.255.255
|
|
int firstAddressByte = (int)address.GetAddressBytes()[0];
|
|
return (firstAddressByte >= 224 && firstAddressByte <= 239);
|
|
}
|
|
else
|
|
{
|
|
return address.IsIPv6Multicast;
|
|
}
|
|
}
|
|
|
|
public static bool IsSuitableForMulticast(NetworkInterface networkInterface)
|
|
{
|
|
bool result = false;
|
|
|
|
if (networkInterface.SupportsMulticast &&
|
|
!networkInterface.IsReceiveOnly &&
|
|
networkInterface.NetworkInterfaceType != NetworkInterfaceType.Tunnel &&
|
|
networkInterface.NetworkInterfaceType != NetworkInterfaceType.Unknown)
|
|
{
|
|
result = true;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static bool IsSupportedHostNameType(UriHostNameType hostNameType)
|
|
{
|
|
return hostNameType == UriHostNameType.Dns ||
|
|
hostNameType == UriHostNameType.IPv4 ||
|
|
hostNameType == UriHostNameType.IPv6;
|
|
}
|
|
|
|
public static void ValidateBufferBounds(byte[] buffer, int offset, int size)
|
|
{
|
|
if (buffer == null)
|
|
{
|
|
throw FxTrace.Exception.ArgumentNull("buffer");
|
|
}
|
|
|
|
ValidateBufferBounds(buffer.Length, offset, size);
|
|
}
|
|
|
|
public static void ValidateBufferBounds(int bufferSize, int offset, int size)
|
|
{
|
|
if (offset < 0)
|
|
{
|
|
throw FxTrace.Exception.ArgumentOutOfRange("offset", offset, SR.ValueMustBeNonNegative(offset));
|
|
}
|
|
|
|
if (offset > bufferSize)
|
|
{
|
|
throw FxTrace.Exception.ArgumentOutOfRange("offset", offset, SR.OffsetExceedsBufferSize(bufferSize));
|
|
}
|
|
|
|
if (size <= 0)
|
|
{
|
|
throw FxTrace.Exception.ArgumentOutOfRange("size", size, SR.ValueMustBePositive);
|
|
}
|
|
|
|
int remainingBufferSpace = bufferSize - offset;
|
|
if (size > remainingBufferSpace)
|
|
{
|
|
throw FxTrace.Exception.ArgumentOutOfRange("size", size, SR.SizeExceedsRemainingBufferSpace(remainingBufferSpace));
|
|
}
|
|
}
|
|
|
|
public static Exception WrapAsyncException(Exception ex)
|
|
{
|
|
if (ex is TimeoutException)
|
|
{
|
|
return new TimeoutException(SR.AsynchronousExceptionOccurred, ex);
|
|
}
|
|
else if (ex is AddressAlreadyInUseException)
|
|
{
|
|
return new AddressAlreadyInUseException(SR.AsynchronousExceptionOccurred, ex);
|
|
}
|
|
else if (ex is AddressAccessDeniedException)
|
|
{
|
|
return new AddressAccessDeniedException(SR.AsynchronousExceptionOccurred, ex);
|
|
}
|
|
else if (ex is EndpointNotFoundException)
|
|
{
|
|
return new EndpointNotFoundException(SR.AsynchronousExceptionOccurred, ex);
|
|
}
|
|
else if (ex is XmlException)
|
|
{
|
|
return new XmlException(SR.AsynchronousExceptionOccurred, ex);
|
|
}
|
|
else if (ex is CommunicationException)
|
|
{
|
|
return new CommunicationException(SR.AsynchronousExceptionOccurred, ex);
|
|
}
|
|
else
|
|
{
|
|
return ex;
|
|
}
|
|
}
|
|
|
|
static void BindSocket(Socket socket, IPEndPoint localEndpoint)
|
|
{
|
|
try
|
|
{
|
|
socket.Bind(localEndpoint);
|
|
}
|
|
catch (SocketException ex)
|
|
{
|
|
if (ex.SocketErrorCode == SocketError.AddressAlreadyInUse)
|
|
{
|
|
throw FxTrace.Exception.AsError(new AddressAlreadyInUseException(SR.SocketAddressInUse(localEndpoint.ToString()), ex));
|
|
}
|
|
else if (ex.SocketErrorCode == SocketError.AccessDenied)
|
|
{
|
|
throw FxTrace.Exception.AsError(new AddressAccessDeniedException(SR.SocketAddressAccessDenied(localEndpoint.ToString()), ex));
|
|
}
|
|
else
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void SetPreBindSocketOptions(Socket socket, bool listenMulticast, int receiveBufferSize, short timeToLive, int interfaceIndex,
|
|
bool allowMulticastLoopback, bool isLoopbackAdapter)
|
|
{
|
|
bool isIPv4 = socket.AddressFamily == AddressFamily.InterNetwork;
|
|
SocketOptionLevel ipOptionLevel = (isIPv4 ? ipOptionLevel = SocketOptionLevel.IP : ipOptionLevel = SocketOptionLevel.IPv6);
|
|
|
|
//sets only the unicast TTL
|
|
socket.Ttl = timeToLive;
|
|
|
|
//set send related multicast options even if not listening multicast,
|
|
//we might be sending multicast (e.g. client side or due to manual addressing on server).
|
|
socket.SetSocketOption(ipOptionLevel, SocketOptionName.MulticastTimeToLive, timeToLive);
|
|
|
|
if (interfaceIndex != UdpConstants.Defaults.InterfaceIndex)
|
|
{
|
|
int index = (isIPv4 ? IPAddress.HostToNetworkOrder(interfaceIndex) : interfaceIndex);
|
|
|
|
//sets the outbound interface index
|
|
socket.SetSocketOption(ipOptionLevel, SocketOptionName.MulticastInterface, index);
|
|
}
|
|
|
|
if (listenMulticast)
|
|
{
|
|
//don't set this socket option if the socket is bound to the
|
|
//loopback adapter because it will throw an argument exception.
|
|
if (!isLoopbackAdapter)
|
|
{
|
|
socket.SetSocketOption(ipOptionLevel, SocketOptionName.MulticastLoopback, allowMulticastLoopback);
|
|
}
|
|
|
|
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1);
|
|
}
|
|
else
|
|
{
|
|
socket.ExclusiveAddressUse = true;
|
|
}
|
|
|
|
if (receiveBufferSize >= 0)
|
|
{
|
|
socket.ReceiveBufferSize = receiveBufferSize;
|
|
}
|
|
}
|
|
|
|
static void SetPostBindSocketOptions(Socket socket, bool listenMulticast, IPAddress ipAddress, int interfaceIndex)
|
|
{
|
|
bool isIPv6 = socket.AddressFamily == AddressFamily.InterNetworkV6;
|
|
|
|
if (listenMulticast)
|
|
{
|
|
//Win2k3 requires that the joining of the multicast group be after the socket is bound (not true on Vista).
|
|
if (isIPv6)
|
|
{
|
|
IPv6MulticastOption multicastGroup = (interfaceIndex == UdpConstants.Defaults.InterfaceIndex ?
|
|
new IPv6MulticastOption(ipAddress)
|
|
: new IPv6MulticastOption(ipAddress, interfaceIndex));
|
|
|
|
socket.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.AddMembership,
|
|
multicastGroup);
|
|
}
|
|
else
|
|
{
|
|
MulticastOption multicastGroup = (interfaceIndex == UdpConstants.Defaults.InterfaceIndex ?
|
|
new MulticastOption(ipAddress)
|
|
: new MulticastOption(ipAddress, interfaceIndex));
|
|
|
|
socket.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.AddMembership,
|
|
multicastGroup);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static bool TryGetSocketError(Exception ex, out SocketError error)
|
|
{
|
|
error = SocketError.SocketError;
|
|
|
|
while (ex != null)
|
|
{
|
|
SocketException socketException = ex as SocketException;
|
|
if (socketException != null)
|
|
{
|
|
error = socketException.SocketErrorCode;
|
|
return true;
|
|
}
|
|
|
|
ex = ex.InnerException;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public static Message DecodeMessage(DuplicateMessageDetector duplicateDetector, MessageEncoder encoder, BufferManager bufferManager, ArraySegment<byte> data, IPEndPoint remoteEndPoint, int interfaceIndex, bool ignoreSerializationException, out string messageHash)
|
|
{
|
|
Fx.Assert(data != null, "data can't be null");
|
|
Fx.Assert(remoteEndPoint != null, "remoteEndPoint can't be null");
|
|
Fx.Assert(encoder != null, "encoder can't be null");
|
|
Fx.Assert(bufferManager != null, "bufferManager can't be null");
|
|
|
|
Message message = null;
|
|
|
|
messageHash = null;
|
|
|
|
if (duplicateDetector == null || !duplicateDetector.IsDuplicate(data, out messageHash))
|
|
{
|
|
try
|
|
{
|
|
message = encoder.ReadMessage(data, bufferManager);
|
|
}
|
|
catch (XmlException error)
|
|
{
|
|
// Don't throw serialization exceptions when the channel supports Multicast
|
|
if (!ignoreSerializationException)
|
|
{
|
|
throw;
|
|
}
|
|
|
|
FxTrace.Exception.AsWarning(error);
|
|
}
|
|
|
|
if (message != null)
|
|
{
|
|
message.Properties.Add(RemoteEndpointMessageProperty.Name,
|
|
new RemoteEndpointMessageProperty(remoteEndPoint.Address.ToString(), remoteEndPoint.Port));
|
|
|
|
NetworkInterfaceMessageProperty networkInterfaceMessageProperty = new NetworkInterfaceMessageProperty(interfaceIndex);
|
|
networkInterfaceMessageProperty.AddTo(message);
|
|
}
|
|
}
|
|
|
|
return message;
|
|
}
|
|
|
|
public static int ComputeMessageBufferSize(int maxReceivedMessageSize)
|
|
{
|
|
return Math.Min(UdpConstants.MaxMessageSizeOverIPv4, maxReceivedMessageSize);
|
|
}
|
|
}
|
|
}
|