23 KiB
23 KiB
System.Net.Sockets
+namespace System.Net.Sockets {
+ public enum AddressFamily {
+ AppleTalk = 16,
+ Atm = 22,
+ Banyan = 21,
+ Ccitt = 10,
+ Chaos = 5,
+ Cluster = 24,
+ DataKit = 9,
+ DataLink = 13,
+ DecNet = 12,
+ Ecma = 8,
+ FireFox = 19,
+ HyperChannel = 15,
+ Ieee12844 = 25,
+ ImpLink = 3,
+ InterNetwork = 2,
+ InterNetworkV6 = 23,
+ Ipx = 6,
+ Irda = 26,
+ Iso = 7,
+ Lat = 14,
+ NetBios = 17,
+ NetworkDesigners = 28,
+ NS = 6,
+ Osi = 7,
+ Pup = 4,
+ Sna = 11,
+ Unix = 1,
+ Unknown = -1,
+ Unspecified = 0,
+ VoiceView = 18,
+ }
+ public enum IOControlCode : long {
+ AbsorbRouterAlert = (long)2550136837,
+ AddMulticastGroupOnInterface = (long)2550136842,
+ AddressListChange = (long)671088663,
+ AddressListQuery = (long)1207959574,
+ AddressListSort = (long)3355443225,
+ AssociateHandle = (long)2281701377,
+ AsyncIO = (long)2147772029,
+ BindToInterface = (long)2550136840,
+ DataToRead = (long)1074030207,
+ DeleteMulticastGroupFromInterface = (long)2550136843,
+ EnableCircularQueuing = (long)671088642,
+ Flush = (long)671088644,
+ GetBroadcastAddress = (long)1207959557,
+ GetExtensionFunctionPointer = (long)3355443206,
+ GetGroupQos = (long)3355443208,
+ GetQos = (long)3355443207,
+ KeepAliveValues = (long)2550136836,
+ LimitBroadcasts = (long)2550136839,
+ MulticastInterface = (long)2550136841,
+ MulticastScope = (long)2281701386,
+ MultipointLoopback = (long)2281701385,
+ NamespaceChange = (long)2281701401,
+ NonBlockingIO = (long)2147772030,
+ OobDataRead = (long)1074033415,
+ QueryTargetPnpHandle = (long)1207959576,
+ ReceiveAll = (long)2550136833,
+ ReceiveAllIgmpMulticast = (long)2550136835,
+ ReceiveAllMulticast = (long)2550136834,
+ RoutingInterfaceChange = (long)2281701397,
+ RoutingInterfaceQuery = (long)3355443220,
+ SetGroupQos = (long)2281701388,
+ SetQos = (long)2281701387,
+ TranslateHandle = (long)3355443213,
+ UnicastInterface = (long)2550136838,
+ }
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+ public struct IPPacketInformation {
+ public IPAddress Address { get; }
+ public int Interface { get; }
+ public override bool Equals(object comparand);
+ public override int GetHashCode();
+ public static bool operator ==(IPPacketInformation packetInformation1, IPPacketInformation packetInformation2);
+ public static bool operator !=(IPPacketInformation packetInformation1, IPPacketInformation packetInformation2);
+ }
+ public enum IPProtectionLevel {
+ EdgeRestricted = 20,
+ Restricted = 30,
+ Unrestricted = 10,
+ Unspecified = -1,
+ }
+ public class IPv6MulticastOption {
+ public IPv6MulticastOption(IPAddress group);
+ public IPv6MulticastOption(IPAddress group, long ifindex);
+ public IPAddress Group { get; set; }
+ public long InterfaceIndex { get; set; }
+ }
+ public class LingerOption {
+ public LingerOption(bool enable, int seconds);
+ public bool Enabled { get; set; }
+ public int LingerTime { get; set; }
+ }
+ public class MulticastOption {
+ public MulticastOption(IPAddress group);
+ public MulticastOption(IPAddress group, int interfaceIndex);
+ public MulticastOption(IPAddress group, IPAddress mcint);
+ public IPAddress Group { get; set; }
+ public int InterfaceIndex { get; set; }
+ public IPAddress LocalAddress { get; set; }
+ }
+ public class NetworkStream : Stream {
+ public NetworkStream(Socket socket);
+ public NetworkStream(Socket socket, bool ownsSocket);
+ public override bool CanRead { get; }
+ public override bool CanSeek { get; }
+ public override bool CanTimeout { get; }
+ public override bool CanWrite { get; }
+ public virtual bool DataAvailable { get; }
+ public override long Length { get; }
+ public override long Position { get; set; }
+ public override int ReadTimeout { get; set; }
+ public override int WriteTimeout { get; set; }
+ protected override void Dispose(bool disposing);
+ ~NetworkStream();
+ public override void Flush();
+ public override Task FlushAsync(CancellationToken cancellationToken);
+ public override int Read(byte[] buffer, int offset, int size);
+ public override Task<int> ReadAsync(byte[] buffer, int offset, int size, CancellationToken cancellationToken);
+ public override long Seek(long offset, SeekOrigin origin);
+ public override void SetLength(long value);
+ public override void Write(byte[] buffer, int offset, int size);
+ public override Task WriteAsync(byte[] buffer, int offset, int size, CancellationToken cancellationToken);
+ }
+ public enum ProtocolType {
+ Ggp = 3,
+ Icmp = 1,
+ IcmpV6 = 58,
+ Idp = 22,
+ Igmp = 2,
+ IP = 0,
+ IPSecAuthenticationHeader = 51,
+ IPSecEncapsulatingSecurityPayload = 50,
+ IPv4 = 4,
+ IPv6 = 41,
+ IPv6DestinationOptions = 60,
+ IPv6FragmentHeader = 44,
+ IPv6HopByHopOptions = 0,
+ IPv6NoNextHeader = 59,
+ IPv6RoutingHeader = 43,
+ Ipx = 1000,
+ ND = 77,
+ Pup = 12,
+ Raw = 255,
+ Spx = 1256,
+ SpxII = 1257,
+ Tcp = 6,
+ Udp = 17,
+ Unknown = -1,
+ Unspecified = 0,
+ }
+ public enum SelectMode {
+ SelectError = 2,
+ SelectRead = 0,
+ SelectWrite = 1,
+ }
+ public class SendPacketsElement {
+ public SendPacketsElement(byte[] buffer);
+ public SendPacketsElement(byte[] buffer, int offset, int count);
+ public SendPacketsElement(byte[] buffer, int offset, int count, bool endOfPacket);
+ public SendPacketsElement(string filepath);
+ public SendPacketsElement(string filepath, int offset, int count);
+ public SendPacketsElement(string filepath, int offset, int count, bool endOfPacket);
+ public byte[] Buffer { get; }
+ public int Count { get; }
+ public bool EndOfPacket { get; }
+ public string FilePath { get; }
+ public int Offset { get; }
+ }
+ public class Socket : IDisposable {
+ public Socket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType);
+ public Socket(SocketType socketType, ProtocolType protocolType);
+ public AddressFamily AddressFamily { get; }
+ public int Available { get; }
+ public bool Blocking { get; set; }
+ public bool Connected { get; }
+ public bool DontFragment { get; set; }
+ public bool DualMode { get; set; }
+ public bool EnableBroadcast { get; set; }
+ public bool ExclusiveAddressUse { get; set; }
+ public bool IsBound { get; }
+ public LingerOption LingerState { get; set; }
+ public EndPoint LocalEndPoint { get; }
+ public bool MulticastLoopback { get; set; }
+ public bool NoDelay { get; set; }
+ public static bool OSSupportsIPv4 { get; }
+ public static bool OSSupportsIPv6 { get; }
+ public ProtocolType ProtocolType { get; }
+ public int ReceiveBufferSize { get; set; }
+ public int ReceiveTimeout { get; set; }
+ public EndPoint RemoteEndPoint { get; }
+ public int SendBufferSize { get; set; }
+ public int SendTimeout { get; set; }
+ public SocketType SocketType { get; }
+ public short Ttl { get; set; }
+ public Socket Accept();
+ public bool AcceptAsync(SocketAsyncEventArgs e);
+ public void Bind(EndPoint localEP);
+ public static void CancelConnectAsync(SocketAsyncEventArgs e);
+ public void Connect(EndPoint remoteEP);
+ public void Connect(IPAddress address, int port);
+ public void Connect(IPAddress[] addresses, int port);
+ public void Connect(string host, int port);
+ public bool ConnectAsync(SocketAsyncEventArgs e);
+ public static bool ConnectAsync(SocketType socketType, ProtocolType protocolType, SocketAsyncEventArgs e);
+ public void Dispose();
+ protected virtual void Dispose(bool disposing);
+ ~Socket();
+ public object GetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName);
+ public void GetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, byte[] optionValue);
+ public byte[] GetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, int optionLength);
+ public int IOControl(int ioControlCode, byte[] optionInValue, byte[] optionOutValue);
+ public int IOControl(IOControlCode ioControlCode, byte[] optionInValue, byte[] optionOutValue);
+ public void Listen(int backlog);
+ public bool Poll(int microSeconds, SelectMode mode);
+ public int Receive(byte[] buffer);
+ public int Receive(byte[] buffer, int offset, int size, SocketFlags socketFlags);
+ public int Receive(byte[] buffer, int offset, int size, SocketFlags socketFlags, out SocketError errorCode);
+ public int Receive(byte[] buffer, int size, SocketFlags socketFlags);
+ public int Receive(byte[] buffer, SocketFlags socketFlags);
+ public int Receive(IList<ArraySegment<byte>> buffers);
+ public int Receive(IList<ArraySegment<byte>> buffers, SocketFlags socketFlags);
+ public int Receive(IList<ArraySegment<byte>> buffers, SocketFlags socketFlags, out SocketError errorCode);
+ public bool ReceiveAsync(SocketAsyncEventArgs e);
+ public int ReceiveFrom(byte[] buffer, int offset, int size, SocketFlags socketFlags, ref EndPoint remoteEP);
+ public int ReceiveFrom(byte[] buffer, int size, SocketFlags socketFlags, ref EndPoint remoteEP);
+ public int ReceiveFrom(byte[] buffer, ref EndPoint remoteEP);
+ public int ReceiveFrom(byte[] buffer, SocketFlags socketFlags, ref EndPoint remoteEP);
+ public bool ReceiveFromAsync(SocketAsyncEventArgs e);
+ public int ReceiveMessageFrom(byte[] buffer, int offset, int size, ref SocketFlags socketFlags, ref EndPoint remoteEP, out IPPacketInformation ipPacketInformation);
+ public bool ReceiveMessageFromAsync(SocketAsyncEventArgs e);
+ public static void Select(IList checkRead, IList checkWrite, IList checkError, int microSeconds);
+ public int Send(byte[] buffer);
+ public int Send(byte[] buffer, int offset, int size, SocketFlags socketFlags);
+ public int Send(byte[] buffer, int offset, int size, SocketFlags socketFlags, out SocketError errorCode);
+ public int Send(byte[] buffer, int size, SocketFlags socketFlags);
+ public int Send(byte[] buffer, SocketFlags socketFlags);
+ public int Send(IList<ArraySegment<byte>> buffers);
+ public int Send(IList<ArraySegment<byte>> buffers, SocketFlags socketFlags);
+ public int Send(IList<ArraySegment<byte>> buffers, SocketFlags socketFlags, out SocketError errorCode);
+ public bool SendAsync(SocketAsyncEventArgs e);
+ public bool SendPacketsAsync(SocketAsyncEventArgs e);
+ public int SendTo(byte[] buffer, int offset, int size, SocketFlags socketFlags, EndPoint remoteEP);
+ public int SendTo(byte[] buffer, int size, SocketFlags socketFlags, EndPoint remoteEP);
+ public int SendTo(byte[] buffer, EndPoint remoteEP);
+ public int SendTo(byte[] buffer, SocketFlags socketFlags, EndPoint remoteEP);
+ public bool SendToAsync(SocketAsyncEventArgs e);
+ public void SetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, bool optionValue);
+ public void SetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, byte[] optionValue);
+ public void SetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, int optionValue);
+ public void SetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, object optionValue);
+ public void Shutdown(SocketShutdown how);
+ }
+ public class SocketAsyncEventArgs : EventArgs, IDisposable {
+ public SocketAsyncEventArgs();
+ public Socket AcceptSocket { get; set; }
+ public byte[] Buffer { get; }
+ public IList<ArraySegment<byte>> BufferList { get; set; }
+ public int BytesTransferred { get; }
+ public Exception ConnectByNameError { get; }
+ public Socket ConnectSocket { get; }
+ public int Count { get; }
+ public SocketAsyncOperation LastOperation { get; }
+ public int Offset { get; }
+ public IPPacketInformation ReceiveMessageFromPacketInfo { get; }
+ public EndPoint RemoteEndPoint { get; set; }
+ public SendPacketsElement[] SendPacketsElements { get; set; }
+ public int SendPacketsSendSize { get; set; }
+ public SocketError SocketError { get; set; }
+ public SocketFlags SocketFlags { get; set; }
+ public object UserToken { get; set; }
+ public event EventHandler<SocketAsyncEventArgs> Completed;
+ public void Dispose();
+ ~SocketAsyncEventArgs();
+ protected virtual void OnCompleted(SocketAsyncEventArgs e);
+ public void SetBuffer(byte[] buffer, int offset, int count);
+ public void SetBuffer(int offset, int count);
+ }
+ public enum SocketAsyncOperation {
+ Accept = 1,
+ Connect = 2,
+ Disconnect = 3,
+ None = 0,
+ Receive = 4,
+ ReceiveFrom = 5,
+ ReceiveMessageFrom = 6,
+ Send = 7,
+ SendPackets = 8,
+ SendTo = 9,
+ }
+ public enum SocketError {
+ AccessDenied = 10013,
+ AddressAlreadyInUse = 10048,
+ AddressFamilyNotSupported = 10047,
+ AddressNotAvailable = 10049,
+ AlreadyInProgress = 10037,
+ ConnectionAborted = 10053,
+ ConnectionRefused = 10061,
+ ConnectionReset = 10054,
+ DestinationAddressRequired = 10039,
+ Disconnecting = 10101,
+ Fault = 10014,
+ HostDown = 10064,
+ HostNotFound = 11001,
+ HostUnreachable = 10065,
+ InProgress = 10036,
+ Interrupted = 10004,
+ InvalidArgument = 10022,
+ IOPending = 997,
+ IsConnected = 10056,
+ MessageSize = 10040,
+ NetworkDown = 10050,
+ NetworkReset = 10052,
+ NetworkUnreachable = 10051,
+ NoBufferSpaceAvailable = 10055,
+ NoData = 11004,
+ NoRecovery = 11003,
+ NotConnected = 10057,
+ NotInitialized = 10093,
+ NotSocket = 10038,
+ OperationAborted = 995,
+ OperationNotSupported = 10045,
+ ProcessLimit = 10067,
+ ProtocolFamilyNotSupported = 10046,
+ ProtocolNotSupported = 10043,
+ ProtocolOption = 10042,
+ ProtocolType = 10041,
+ Shutdown = 10058,
+ SocketError = -1,
+ SocketNotSupported = 10044,
+ Success = 0,
+ SystemNotReady = 10091,
+ TimedOut = 10060,
+ TooManyOpenSockets = 10024,
+ TryAgain = 11002,
+ TypeNotFound = 10109,
+ VersionNotSupported = 10092,
+ WouldBlock = 10035,
+ }
+ public class SocketException : Exception {
+ public SocketException();
+ public SocketException(int errorCode);
+ public override string Message { get; }
+ public SocketError SocketErrorCode { get; }
+ }
+ public enum SocketFlags {
+ Broadcast = 1024,
+ ControlDataTruncated = 512,
+ DontRoute = 4,
+ Multicast = 2048,
+ None = 0,
+ OutOfBand = 1,
+ Partial = 32768,
+ Peek = 2,
+ Truncated = 256,
+ }
+ public enum SocketOptionLevel {
+ IP = 0,
+ IPv6 = 41,
+ Socket = 65535,
+ Tcp = 6,
+ Udp = 17,
+ }
+ public enum SocketOptionName {
+ AcceptConnection = 2,
+ AddMembership = 12,
+ AddSourceMembership = 15,
+ BlockSource = 17,
+ Broadcast = 32,
+ BsdUrgent = 2,
+ ChecksumCoverage = 20,
+ Debug = 1,
+ DontFragment = 14,
+ DontLinger = -129,
+ DontRoute = 16,
+ DropMembership = 13,
+ DropSourceMembership = 16,
+ Error = 4103,
+ ExclusiveAddressUse = -5,
+ Expedited = 2,
+ HeaderIncluded = 2,
+ HopLimit = 21,
+ IPOptions = 1,
+ IPProtectionLevel = 23,
+ IpTimeToLive = 4,
+ IPv6Only = 27,
+ KeepAlive = 8,
+ Linger = 128,
+ MaxConnections = 2147483647,
+ MulticastInterface = 9,
+ MulticastLoopback = 11,
+ MulticastTimeToLive = 10,
+ NoChecksum = 1,
+ NoDelay = 1,
+ OutOfBandInline = 256,
+ PacketInformation = 19,
+ ReceiveBuffer = 4098,
+ ReceiveLowWater = 4100,
+ ReceiveTimeout = 4102,
+ ReuseAddress = 4,
+ ReuseUnicastPort = 12295,
+ SendBuffer = 4097,
+ SendLowWater = 4099,
+ SendTimeout = 4101,
+ Type = 4104,
+ TypeOfService = 3,
+ UnblockSource = 18,
+ UpdateAcceptContext = 28683,
+ UpdateConnectContext = 28688,
+ UseLoopback = 64,
+ }
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+ public struct SocketReceiveFromResult {
+ public int ReceivedBytes;
+ public EndPoint RemoteEndPoint;
+ }
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+ public struct SocketReceiveMessageFromResult {
+ public int ReceivedBytes;
+ public EndPoint RemoteEndPoint;
+ public IPPacketInformation PacketInformation;
+ public SocketFlags SocketFlags;
+ }
+ public enum SocketShutdown {
+ Both = 2,
+ Receive = 0,
+ Send = 1,
+ }
+ public static class SocketTaskExtensions {
+ public static Task<Socket> AcceptAsync(this Socket socket);
+ public static Task<Socket> AcceptAsync(this Socket socket, Socket acceptSocket);
+ public static Task ConnectAsync(this Socket socket, EndPoint remoteEP);
+ public static Task ConnectAsync(this Socket socket, IPAddress address, int port);
+ public static Task ConnectAsync(this Socket socket, IPAddress[] addresses, int port);
+ public static Task ConnectAsync(this Socket socket, string host, int port);
+ public static Task<int> ReceiveAsync(this Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags);
+ public static Task<int> ReceiveAsync(this Socket socket, IList<ArraySegment<byte>> buffers, SocketFlags socketFlags);
+ public static Task<SocketReceiveFromResult> ReceiveFromAsync(this Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags, EndPoint remoteEndPoint);
+ public static Task<SocketReceiveMessageFromResult> ReceiveMessageFromAsync(this Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags, EndPoint remoteEndPoint);
+ public static Task<int> SendAsync(this Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags);
+ public static Task<int> SendAsync(this Socket socket, IList<ArraySegment<byte>> buffers, SocketFlags socketFlags);
+ public static Task<int> SendToAsync(this Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags, EndPoint remoteEP);
+ }
+ public enum SocketType {
+ Dgram = 2,
+ Raw = 3,
+ Rdm = 4,
+ Seqpacket = 5,
+ Stream = 1,
+ Unknown = -1,
+ }
+ public class TcpClient : IDisposable {
+ public TcpClient();
+ public TcpClient(AddressFamily family);
+ protected bool Active { get; set; }
+ public int Available { get; }
+ public Socket Client { get; set; }
+ public bool Connected { get; }
+ public bool ExclusiveAddressUse { get; set; }
+ public LingerOption LingerState { get; set; }
+ public bool NoDelay { get; set; }
+ public int ReceiveBufferSize { get; set; }
+ public int ReceiveTimeout { get; set; }
+ public int SendBufferSize { get; set; }
+ public int SendTimeout { get; set; }
+ public Task ConnectAsync(IPAddress address, int port);
+ public Task ConnectAsync(IPAddress[] addresses, int port);
+ public Task ConnectAsync(string host, int port);
+ public void Dispose();
+ protected virtual void Dispose(bool disposing);
+ ~TcpClient();
+ public NetworkStream GetStream();
+ }
+ public class TcpListener {
+ public TcpListener(IPAddress localaddr, int port);
+ public TcpListener(IPEndPoint localEP);
+ protected bool Active { get; }
+ public bool ExclusiveAddressUse { get; set; }
+ public EndPoint LocalEndpoint { get; }
+ public Socket Server { get; }
+ public Task<Socket> AcceptSocketAsync();
+ public Task<TcpClient> AcceptTcpClientAsync();
+ public bool Pending();
+ public void Start();
+ public void Start(int backlog);
+ public void Stop();
+ }
+ public class UdpClient : IDisposable {
+ public UdpClient();
+ public UdpClient(int port);
+ public UdpClient(int port, AddressFamily family);
+ public UdpClient(IPEndPoint localEP);
+ public UdpClient(AddressFamily family);
+ protected bool Active { get; set; }
+ public int Available { get; }
+ public Socket Client { get; set; }
+ public bool DontFragment { get; set; }
+ public bool EnableBroadcast { get; set; }
+ public bool ExclusiveAddressUse { get; set; }
+ public bool MulticastLoopback { get; set; }
+ public short Ttl { get; set; }
+ public void Dispose();
+ protected virtual void Dispose(bool disposing);
+ public void DropMulticastGroup(IPAddress multicastAddr);
+ public void DropMulticastGroup(IPAddress multicastAddr, int ifindex);
+ public void JoinMulticastGroup(int ifindex, IPAddress multicastAddr);
+ public void JoinMulticastGroup(IPAddress multicastAddr);
+ public void JoinMulticastGroup(IPAddress multicastAddr, int timeToLive);
+ public void JoinMulticastGroup(IPAddress multicastAddr, IPAddress localAddress);
+ public Task<UdpReceiveResult> ReceiveAsync();
+ public Task<int> SendAsync(byte[] datagram, int bytes, IPEndPoint endPoint);
+ public Task<int> SendAsync(byte[] datagram, int bytes, string hostname, int port);
+ }
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+ public struct UdpReceiveResult : IEquatable<UdpReceiveResult> {
+ public UdpReceiveResult(byte[] buffer, IPEndPoint remoteEndPoint);
+ public byte[] Buffer { get; }
+ public IPEndPoint RemoteEndPoint { get; }
+ public bool Equals(UdpReceiveResult other);
+ public override bool Equals(object obj);
+ public override int GetHashCode();
+ public static bool operator ==(UdpReceiveResult left, UdpReceiveResult right);
+ public static bool operator !=(UdpReceiveResult left, UdpReceiveResult right);
+ }
+}