// Initialize all of the default certificates and protocols public SslServer() { // Initialize the Socket serverSocketType = SocketType.Stream; serverProtocolType = ProtocolType.Tcp; if (Microsoft.SPOT.Hardware.SystemInfo.SystemID.SKU == 3) { cert = new X509Certificate(CertificatesAndCAs.emuCert, "NetMF"); ca = new X509Certificate[] { new X509Certificate(CertificatesAndCAs.caEmuCert) }; } else { // Initialize the SslStream cert = new X509Certificate(CertificatesAndCAs.newCert); ca = new X509Certificate[] { new X509Certificate(CertificatesAndCAs.caCert) }; } verify = SslVerification.NoVerification; sslProtocols = new SslProtocols[] { SslProtocols.Default }; // Create a TCP/IP (IPv4) socket and listen for incoming connections. serverSocket = new Socket(AddressFamily.InterNetwork, serverSocketType, serverProtocolType); serverSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, false); serverSocket.Bind(new IPEndPoint(IPAddress.Loopback, 0)); serverEp = (IPEndPoint)serverSocket.LocalEndPoint; Debug.Print("Listening for a client to connect..."); serverSocket.Listen(1); }
public NetworkDevice(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType, EndPoint endPoint) { _AddressFamily = addressFamily; _SocketType = socketType; _ProtocolType = protocolType; _EndPoint = endPoint; }
public BINLSocket(IPEndPoint endpoint, bool broadcast = false, bool enableMulticast = false, int buffersize = 1024, SocketType type = SocketType.BINL) { try { this.localEndPoint = endpoint; this.broadcast = broadcast; this.buffersize = buffersize; this.type = type; this.reuseAddress = Settings.ReUseAddress; this.socket = new Socket(AddressFamily.InterNetwork, System.Net.Sockets.SocketType.Dgram, ProtocolType.Udp); this.socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Broadcast, this.broadcast); this.socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, this.reuseAddress); this.state = new SocketState(); this.state.Type = this.type; this.state.Buffer = new byte[this.buffersize]; this.state.Buffersize = this.buffersize; this.state.Socket = this.socket; this.socket.Bind(this.localEndPoint); this.socket.BeginReceiveFrom(this.state.Buffer, 0, this.state.Buffersize, 0, ref this.localEndPoint, new AsyncCallback(this.Received), this.state); } catch (SocketException ex) { Errorhandler.Report(LogTypes.Error, "[BINL] Socket Error {0}: {1}".F(ex.ErrorCode, ex.Message)); } }
/// <summary> /// Initializes a new instance of the ProxySocket class. /// </summary> /// <param name="addressFamily">One of the AddressFamily values.</param> /// <param name="socketType">One of the SocketType values.</param> /// <param name="protocolType">One of the ProtocolType values.</param> /// <param name="proxyUsername">The username to use when authenticating with the proxy server.</param> /// <param name="proxyPassword">The password to use when authenticating with the proxy server.</param> /// <exception cref="SocketException">The combination of addressFamily, socketType, and protocolType results in an invalid socket.</exception> /// <exception cref="ArgumentNullException"><c>proxyUsername</c> -or- <c>proxyPassword</c> is null.</exception> public ProxySocket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType, string proxyUsername, string proxyPassword) : base(addressFamily, socketType, protocolType) { ProxyUser = proxyUsername; ProxyPass = proxyPassword; ToThrow = new InvalidOperationException(); }
public P2PClient(string ip,int point,SocketType socketType=SocketType.Dgram,ProtocolType protocolType=ProtocolType.Udp) { this.ip=ip; this.point=point; this.protocolType =protocolType; this.socketType=socketType; }
private IntPtr Socket_internal(AddressFamily family, SocketType type, ProtocolType proto, out int error) { throw new System.NotImplementedException(); }
public static unsafe SafeCloseSocket CreateSocket(SocketInformation socketInformation, out AddressFamily addressFamily, out SocketType socketType, out ProtocolType protocolType) { SafeCloseSocket handle; Interop.Winsock.WSAPROTOCOL_INFO protocolInfo; fixed (byte* pinnedBuffer = socketInformation.ProtocolInformation) { handle = SafeCloseSocket.CreateWSASocket(pinnedBuffer); protocolInfo = (Interop.Winsock.WSAPROTOCOL_INFO)Marshal.PtrToStructure<Interop.Winsock.WSAPROTOCOL_INFO>((IntPtr)pinnedBuffer); } if (handle.IsInvalid) { SocketException e = new SocketException(); if (e.SocketErrorCode == SocketError.InvalidArgument) { throw new ArgumentException(SR.net_sockets_invalid_socketinformation, "socketInformation"); } else { throw e; } } addressFamily = protocolInfo.iAddressFamily; socketType = (SocketType)protocolInfo.iSocketType; protocolType = (ProtocolType)protocolInfo.iProtocol; return handle; }
private Socket(AddressFamily family, SocketType type, ProtocolType proto, IntPtr native) { this.family = family; this.type = type; this.proto = proto; this.native = native; }
public SocketManager(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType) { _addressFamily = addressFamily; _socketType = socketType; _protocolType = protocolType; _listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); }
public TZmqServer (TProcessor processor, Context ctx, String endpoint, SocketType sockType) { new TSimpleServer (processor,null); _socket = ctx.Socket (sockType); _socket.Bind (endpoint); _processor = processor; }
public static async Task<IDisposableConnection<ArraySegment<byte>>> CreateConnection( EndPoint endpoint, SocketType socketType = SocketType.Stream, ProtocolType protocolType = ProtocolType.Tcp) { var socket = new Socket(socketType, protocolType); bool disposeSocket = false; try { using (SocketAwaitableEventArgs args = new SocketAwaitableEventArgs()) { args.RemoteEndPoint = endpoint; await socket.ConnectSocketAsync(args); } } catch (Exception) { disposeSocket = true; throw; } finally { if (disposeSocket) { socket.Dispose(); socket = null; } } return socket.ToConnection(); }
public Socket CreateSocket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType) { SetAddressFamily(addressFamily); SetProtocolType(protocolType); SetSocketType(socketType); return new Socket(this.addressFamily, this.socketType, this.protocolType); }
protected SingleReceiveLoopProxyReactor(IPAddress localAddress, int localPort, NetworkEventLoop eventLoop, IMessageEncoder encoder, IMessageDecoder decoder, IByteBufAllocator allocator, SocketType socketType = SocketType.Stream, ProtocolType protocol = ProtocolType.Tcp, int bufferSize = NetworkConstants.DEFAULT_BUFFER_SIZE) : base(localAddress, localPort, eventLoop, encoder, decoder, allocator, socketType, protocol, bufferSize) { }
public P2PServer(int point,SocketType socketType=SocketType.Dgram,ProtocolType protocolType=ProtocolType.Udp) { this.point=point; this.protocolType =protocolType; this.socketType=socketType; }
public void Reset (Socket socket, IPEndPoint ip) { this.addressFamily = socket.AddressFamily; this.socketType = socket.SocketType; this.protocolTtype = socket.ProtocolType; this.RemoteEndPoint = ip; }
public TCPClient(string ip,int point,SocketType socketType=SocketType.Stream,ProtocolType protocolType=ProtocolType.Tcp) { this.ip=ip; this.point=point; this.protocolType =protocolType; this.socketType=socketType; }
public ServerAcceptor(SocketType socketType, ProtocolType protocolType, ISocketAsyncEventArgsPool acceptorPool, Func<SocketAsyncEventArgs> acceptorFactory) { this.socketType = socketType; this.protocolType = protocolType; this.acceptorPool = acceptorPool; this.acceptorFactory = acceptorFactory; }
public SocketServer(int portNumber, AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType) { this.portNumber = portNumber; this.addressFamily = addressFamily; this.socketType = socketType; this.protocolType = protocolType; clientAddresses = new List<string>(); clientTable = new Dictionary<string, StateObject>(); recentlyReceivedStates = new List<StateObject>(); removeList = new List<string>(); listenEvent = new ManualResetEvent(false); shutDownEvent = new ManualResetEvent(false); sendEvent = new ManualResetEvent(false); listener = null; sendBufferSize = INITIAL_BUFFER_SIZE; recvBufferSize = INITIAL_BUFFER_SIZE; ShutdownWaitTimeout = 5000; enableEncryption = false; initialized = false; copyingRecvBuffer = false; isShuttingDown = false; transmittingData = false; receivingData = false; }
/// <summary> /// Initializes the socket /// </summary>` public void init(int offset, string ipAddress) { socketType = SocketType.Stream; protocolType = ProtocolType.Tcp; //addressFamily = AddressFamily.InterNetwork; addressFamily = AddressFamily.InterNetwork; try { ipEntry = Dns.GetHostEntry(Dns.GetHostName()); IPAddress[] addr = ipEntry.AddressList; //endpoint = new IPEndPoint(addr[0], port); for (int i = 0; i < addr.Length; i++) { Console.WriteLine("IP Address {0}: {1} ", i, addr[i].ToString()); } if (ipAddress == "") { address = addr[addr.Length - offset]; } else { address = IPAddress.Parse(ipAddress); } Console.WriteLine("Using the Address {0}: {1}", address.ToString(), port); endpoint = new IPEndPoint(address, port); } catch (SocketException ex) { System.Console.WriteLine(ex.Message); } createSocket(); }
/// <summary> /// /// </summary> public SocketAsyncClient(IPEndPoint remoteEndPoint, int bufferSize, AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType) { _remoteEndPoint = remoteEndPoint; _client = new Socket(addressFamily, socketType, protocolType); socketObject = new SocketObject(Guid.NewGuid(), _client); int maxConnection = 1; int numOfSaeaForRecSend = maxConnection * OpsToPreAlloc; _readWritePool = new SocketAsyncPool(numOfSaeaForRecSend); int numSize = numOfSaeaForRecSend * bufferSize; _bufferManager = new BufferManager(numSize, bufferSize); _bufferManager.InitBuffer(); _saeaProxy = new SocketAsyncEventArgsProxy(bufferSize); _saeaProxy.ReceiveCompleted += OnReceiveCompleted; _saeaProxy.SendCompleted += OnSendCompleted; _saeaProxy.ClosedHandle += OnSocketClosing; SocketAsyncEventArgs saea; for (int i = 0; i < numOfSaeaForRecSend; i++) { saea = _saeaProxy.CreateNewSaea(); _bufferManager.SetBuffer(saea); saea.UserToken = new DataToken(saea.Offset); _readWritePool.Push(saea); } }
/// <summary> /// Accepts the specified number of incoming connection attempts and creates new <see cref="Socket"/> objects. /// </summary> /// <param name="addressFamily">One of the <see cref="AddressFamily"/> values.</param> /// <param name="socketType">One of the <see cref="SocketType"/> values.</param> /// <param name="protocolType">One of the <see cref="ProtocolType"/> values.</param> /// <param name="localEndPoint">The local <see cref="EndPoint"/> to associate with the <see cref="Socket"/> that /// will be accepting connections.</param> /// <param name="count">The maximum number of connections to accept.</param> /// <param name="acceptSocketFactory">Called when ready to accept a new <see cref="Socket"/>, up to the specified <paramref name="count"/>. /// This function may return <see langword="null"/> to create new sockets automatically.</param> /// <returns>An observable sequence containing the connected <see cref="Socket"/> objects.</returns> public static IObservable<Socket> Accept( AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType, IPEndPoint localEndPoint, int count, Func<Socket> acceptSocketFactory) { Contract.Requires(localEndPoint != null); Contract.Requires(count > 0); Contract.Requires(acceptSocketFactory != null); Contract.Ensures(Contract.Result<IObservable<Socket>>() != null); return Observable.Using( () => new Socket(addressFamily, socketType, protocolType), socket => { socket.Bind(localEndPoint); socket.Listen(count); var e = new SocketAsyncEventArgs(); return Observable .Defer(() => { e.AcceptSocket = acceptSocketFactory(); // Work item 23871 return socket.AcceptObservable(e); }) .Select(r => r.AcceptSocket) .Repeat(count); }); }
/// <summary> /// Creates client connector. /// </summary> public ClientConnector(SocketType socketType, ProtocolType protocolType, SocketAsyncEventArgs connector) { this.socketType = socketType; this.protocolType = protocolType; this.connector = connector; connector.Completed += OnConnectCompleted; }
public void Connect(IPEndPoint p, AddressFamily family = AddressFamily.InterNetwork, SocketType type = SocketType.Stream, ProtocolType protoType = ProtocolType.Tcp) { _ClientProfSocket = new Socket(family, type, protoType); _ClientProfSocket.Connect(p); }
public CreateEvent(EventInformation eventInformation, AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType, uint result) : base(eventInformation) { m_addressFamily = addressFamily; m_socketType = socketType; m_protocolType = protocolType; m_result = result; }
public AsyncSocket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType) { m_addressFamily = addressFamily; m_socketType = socketType; m_protocolType = protocolType; InitSocket(); InitDynamicMethods(); }
public Socket(AddressFamily family, SocketType type, ProtocolType proto) { this.family = family; this.type = type; this.proto = proto; int error; this.native = Internal_CreateSocket((int)family, (int)type, (int)proto, out error); this.CheckError(error); }
//--// public StressSocketPair(ProtocolType prot, SocketType st) : base(prot, st) { if (prot == ProtocolType.Tcp) { socketClient.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, false); socketServer.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, false); } evt = new AutoResetEvent( false ); }
public static SafeCloseSocket CreateSocket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType) { SafeCloseSocket handle = SafeCloseSocket.CreateWSASocket(addressFamily, socketType, protocolType); if (handle.IsInvalid) { // Failed to create the win32 socket, throw. throw new SocketException(); } return handle; }
public ConnectionManager(Dictionary<Byte[], Action> opList, IPAddress listenIP, UInt16 listenPort, SocketType sockType = SocketType.Stream, ProtocolType protoType = ProtocolType.Tcp, AddressFamily addrFamily = AddressFamily.InterNetwork) { actions = opList; ip = listenIP; port = listenPort; this.sockType = sockType; this.protoType = protoType; this.addrFamily = addrFamily; StartListener(); }
public IZmqSocket CreateSocket(SocketType type) { if (_disposed) throw new ObjectDisposedException("StubContext disposed"); var socket = _creator(type); this.LastSocketCreatedByType[type] = socket; return socket; }
public ISocket New_Socket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType) { return(client.aClient.GetSharedClass <ISocket>(typeof(Lite_Socket), addressFamily, socketType, protocolType)); }
public void Ctor_Failure(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType) { Assert.Throws <SocketException>(() => new Socket(addressFamily, socketType, protocolType)); }
internal static partial Error GetSocketType(SafeSocketHandle socket, out AddressFamily addressFamily, out SocketType socketType, out ProtocolType protocolType, out bool isListening);
public static extern IntPtr WSASocket([In] AddressFamilies af, [In] SocketType type, [In] Protocol protocol, [In] IntPtr lpProtocolInfo, [In] Int32 group, [In] SocketFlags dwFlags);
public MdoSocket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType) : base(addressFamily, socketType, protocolType) { allDone = new ManualResetEvent(false); }
static NeuronSource CreateConnection(string address, int port, int commandServerPort, SocketType socketType) { NeuronSource source = null; IntPtr socketReference = IntPtr.Zero; IntPtr commandSocketReference = IntPtr.Zero; if (socketType == SocketType.TCP) { socketReference = NeuronDataReader.BRConnectTo(address, port); if (socketReference != IntPtr.Zero) { Debug.Log(string.Format("[NeuronConnection] Connected to {0}:{1}.", address, port)); } else { Debug.LogError(string.Format("[NeuronConnection] Connecting to {0}:{1} failed.", address, port)); } } else { socketReference = NeuronDataReader.BRStartUDPServiceAt(port); if (socketReference != IntPtr.Zero) { Debug.Log(string.Format("[NeuronConnection] Start listening at {0}.", port)); } else { Debug.LogError(string.Format("[NeuronConnection] Start listening at {0} failed.", port)); } } if (socketReference != IntPtr.Zero) { if (connections.Count == 0) { RegisterReaderCallbacks(); } if (commandServerPort > 0) { // connect to command server commandSocketReference = NeuronDataReader.BRConnectTo(address, commandServerPort); if (commandSocketReference != IntPtr.Zero) { Debug.Log(string.Format("[NeuronConnection] Connected to command server {0}:{1}.", address, commandServerPort)); } else { Debug.LogError(string.Format("[NeuronConnection] Connected to command server {0}:{1} failed.", address, commandServerPort)); } } source = new NeuronSource(address, port, commandServerPort, socketType, socketReference, commandSocketReference); connections.Add(source.guid, source); socketReferencesIndex.Add(socketReference, source); if (commandSocketReference != IntPtr.Zero) { commandSocketReferenceIndex.Add(commandSocketReference, source); } } return(source); }
protected ReactorBase(IPAddress localAddress, int localPort, NetworkEventLoop eventLoop, IMessageEncoder encoder, IMessageDecoder decoder, IByteBufAllocator allocator, SocketType socketType = SocketType.Stream, ProtocolType protocol = ProtocolType.Tcp, int bufferSize = NetworkConstants.DEFAULT_BUFFER_SIZE) { Decoder = decoder; Encoder = encoder; Allocator = allocator; LocalEndpoint = new IPEndPoint(localAddress, localPort); Listener = new Socket(AddressFamily.InterNetwork, socketType, protocol); if (protocol == ProtocolType.Tcp) { Transport = TransportType.Tcp; } else if (protocol == ProtocolType.Udp) { Transport = TransportType.Udp; } Backlog = NetworkConstants.DefaultBacklog; EventLoop = eventLoop; ConnectionAdapter = new ReactorConnectionAdapter(this); BufferSize = bufferSize; }
public ProxyEncryptSocket(AddressFamily af, SocketType type, ProtocolType protocol) { _socket = new Socket(af, type, protocol); }
public XSocket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType) : base(addressFamily, socketType, protocolType) { }
public void DualMode_Success(SocketType socketType, ProtocolType protocolType) { using (new Socket(socketType, protocolType)) { } }
#pragma warning disable IDE1006 // Naming Styles - these are Win32 function names internal static extern int socket(AddressFamily af, SocketType type, ProtocolType protocol);
public SocketListener(SocketType type, IPEndPoint host, Func <IProtocol> factory) { _type = type; _host = host; _factory = factory; }
public void DualMode_Failure(SocketType socketType, ProtocolType protocolType) { Assert.Throws <SocketException>(() => new Socket(socketType, protocolType)); }
public SocketListener(SocketType type, IPEndPoint host, IProtocolFactory factory) : this(type, host, factory.Create) { // _context = this.CreateContext(type, host); }
public TZmqClient(Context ctx, String endpoint, SocketType sockType) { _sock = ctx.Socket(sockType); _endpoint = endpoint; }
public async Task Ctor_SafeHandle_Tcp_SendReceive_Success(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType) { using var orig = new Socket(addressFamily, socketType, protocolType); using var listener = new Socket(addressFamily, socketType, protocolType); listener.Bind(new IPEndPoint(addressFamily == AddressFamily.InterNetwork ? IPAddress.Loopback : IPAddress.IPv6Loopback, 0)); listener.Listen(1); await orig.ConnectAsync(listener.LocalEndPoint); using var server = await listener.AcceptAsync(); using var client = new Socket(orig.SafeHandle); Assert.True(client.Connected); Assert.Equal(orig.AddressFamily, client.AddressFamily); Assert.Equal(orig.SocketType, client.SocketType); Assert.Equal(orig.ProtocolType, client.ProtocolType); // Validate accessing end points Assert.Equal(orig.LocalEndPoint, client.LocalEndPoint); Assert.Equal(orig.RemoteEndPoint, client.RemoteEndPoint); // Validating accessing other properties Assert.Equal(orig.Available, client.Available); Assert.True(orig.Blocking); Assert.True(client.Blocking); AssertEqualOrSameException(() => orig.DontFragment, () => client.DontFragment); AssertEqualOrSameException(() => orig.EnableBroadcast, () => client.EnableBroadcast); Assert.Equal(orig.ExclusiveAddressUse, client.ExclusiveAddressUse); Assert.Equal(orig.Handle, client.Handle); Assert.Equal(orig.IsBound, client.IsBound); Assert.Equal(orig.LingerState.Enabled, client.LingerState.Enabled); Assert.Equal(orig.LingerState.LingerTime, client.LingerState.LingerTime); AssertEqualOrSameException(() => orig.MulticastLoopback, () => client.MulticastLoopback); Assert.Equal(orig.NoDelay, client.NoDelay); Assert.Equal(orig.ReceiveBufferSize, client.ReceiveBufferSize); Assert.Equal(orig.ReceiveTimeout, client.ReceiveTimeout); Assert.Equal(orig.SendBufferSize, client.SendBufferSize); Assert.Equal(orig.SendTimeout, client.SendTimeout); Assert.Equal(orig.Ttl, client.Ttl); Assert.Equal(orig.UseOnlyOverlappedIO, client.UseOnlyOverlappedIO); // Validate setting various properties on the new instance and seeing them roundtrip back to the original. client.ReceiveTimeout = 42; Assert.Equal(client.ReceiveTimeout, orig.ReceiveTimeout); // Validate sending and receiving Assert.Equal(1, await client.SendAsync(new byte[1] { 42 }, SocketFlags.None)); var buffer = new byte[1]; Assert.Equal(1, await server.ReceiveAsync(buffer, SocketFlags.None)); Assert.Equal(42, buffer[0]); Assert.Equal(1, await server.SendAsync(new byte[1] { 42 }, SocketFlags.None)); buffer[0] = 0; Assert.Equal(1, await client.ReceiveAsync(buffer, SocketFlags.None)); Assert.Equal(42, buffer[0]); }
public ProxySocketTunLocal(AddressFamily af, SocketType type, ProtocolType protocol) : base(af, type, protocol) { }
public void Ctor_SafeHandle_BasicPropertiesPropagate_Success(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType) { bool isRawPacket = (addressFamily == AddressFamily.Packet) && (socketType == SocketType.Raw); if (isRawPacket) { // protocol is the IEEE 802.3 protocol number in network byte order. const short ETH_P_ARP = 0x0806; protocolType = (ProtocolType)IPAddress.HostToNetworkOrder(ETH_P_ARP); } Socket tmpOrig; try { tmpOrig = new Socket(addressFamily, socketType, protocolType); } catch (SocketException e) when( e.SocketErrorCode == SocketError.AccessDenied || e.SocketErrorCode == SocketError.ProtocolNotSupported || e.SocketErrorCode == SocketError.AddressFamilyNotSupported) { // We can't test this combination on this platform. return; } using Socket orig = tmpOrig; using var copy = new Socket(orig.SafeHandle); Assert.False(orig.Connected); Assert.False(copy.Connected); Assert.Null(orig.LocalEndPoint); Assert.Null(orig.RemoteEndPoint); Assert.False(orig.IsBound); if (copy.IsBound) { // On Unix, we may successfully obtain an (empty) local end point, even though Bind wasn't called. Debug.Assert(!RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) // OSX gets some strange results in some cases, e.g. "@\0\0\0\0\0\0\0\0\0\0\0\0\0" for a UDS { switch (addressFamily) { case AddressFamily.InterNetwork: Assert.Equal(new IPEndPoint(IPAddress.Any, 0), copy.LocalEndPoint); break; case AddressFamily.InterNetworkV6: Assert.Equal(new IPEndPoint(IPAddress.IPv6Any, 0), copy.LocalEndPoint); break; case AddressFamily.Unix: Assert.IsType <UnixDomainSocketEndPoint>(copy.LocalEndPoint); Assert.Equal("", copy.LocalEndPoint.ToString()); break; default: Assert.Null(copy.LocalEndPoint); break; } } Assert.Null(copy.RemoteEndPoint); } else { Assert.Equal(orig.LocalEndPoint, copy.LocalEndPoint); Assert.Equal(orig.LocalEndPoint, copy.RemoteEndPoint); } Assert.Equal(addressFamily, orig.AddressFamily); Assert.Equal(socketType, orig.SocketType); Assert.Equal(protocolType, orig.ProtocolType); Assert.Equal(addressFamily, copy.AddressFamily); Assert.Equal(socketType, copy.SocketType); ProtocolType expectedProtocolType = protocolType; if (isRawPacket) { // raw packet doesn't support getting the protocol using getsockopt SO_PROTOCOL. expectedProtocolType = ProtocolType.Unspecified; } Assert.Equal(expectedProtocolType, copy.ProtocolType); Assert.True(orig.Blocking); Assert.True(copy.Blocking); if (orig.AddressFamily == copy.AddressFamily) { AssertEqualOrSameException(() => orig.DontFragment, () => copy.DontFragment); AssertEqualOrSameException(() => orig.MulticastLoopback, () => copy.MulticastLoopback); AssertEqualOrSameException(() => orig.Ttl, () => copy.Ttl); } AssertEqualOrSameException(() => orig.EnableBroadcast, () => copy.EnableBroadcast); AssertEqualOrSameException(() => orig.LingerState.Enabled, () => copy.LingerState.Enabled); AssertEqualOrSameException(() => orig.LingerState.LingerTime, () => copy.LingerState.LingerTime); AssertEqualOrSameException(() => orig.NoDelay, () => copy.NoDelay); Assert.Equal(orig.Available, copy.Available); Assert.Equal(orig.ExclusiveAddressUse, copy.ExclusiveAddressUse); Assert.Equal(orig.Handle, copy.Handle); Assert.Equal(orig.ReceiveBufferSize, copy.ReceiveBufferSize); Assert.Equal(orig.ReceiveTimeout, copy.ReceiveTimeout); Assert.Equal(orig.SendBufferSize, copy.SendBufferSize); Assert.Equal(orig.SendTimeout, copy.SendTimeout); Assert.Equal(orig.UseOnlyOverlappedIO, copy.UseOnlyOverlappedIO); }
public AsyncSocket(AddressFamily family, SocketType type, ProtocolType protocol) { _socket = new Socket(family, type, protocol); }
/// <summary> /// Create a new instance of the <see cref="ProtoServer{T}" />. /// Use <see cref="Start" /> to bind and start the socket. /// </summary> /// <param name="family"> /// The <see cref="AddressFamily" /> /// this <see cref="System.Net.Sockets.Socket" /> should use /// </param> /// <param name="type"> /// The <see cref="SocketType" /> this /// <see cref="System.Net.Sockets.Socket" /> should use /// </param> /// <param name="address">The <see cref="IPAddress" /> to start this Protocol on</param> /// <param name="port">The Port to start this Protocol on</param> public ProtoServer(IPAddress address, int port, AddressFamily family, SocketType type) { Sockets = new Dictionary <IPEndPoint, Socket>(); EndPoint = new IPEndPoint(address, port); Socket = new Socket(family, type, ProtocolType.Tcp); }
public static NeuronSource Connect(string address, int port, int commandServerPort, SocketType socketType) { NeuronSource source = FindConnection(address, port, socketType); if (source != null) { source.Grab(); return(source); } source = CreateConnection(address, port, commandServerPort, socketType); if (source != null) { source.Grab(); return(source); } return(null); }
private static Socket CreateSocket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType) { var socket = new Socket(addressFamily, SocketType.Stream, ProtocolType.Tcp); return(socket); }
/// <summary> /// This is the main routine that parses the command line and invokes the server with the /// given parameters. For TCP, it creates a listening socket and waits to accept a client /// connection. Once a client connects, it waits to receive a "request" message. The /// request is terminated by the client shutting down the connection. After the request is /// received, the server sends a response followed by shutting down its connection and /// closing the socket. For UDP, the socket simply listens for incoming packets. The "request" /// message is a single datagram received. Once the request is received, a number of datagrams /// are sent in return followed by sending a few zero byte datagrams. This way the client /// can determine that the response has completed when it receives a zero byte datagram. /// </summary> /// <param name="args">Command line arguments</param> public static void Main(string[] args) { string textMessage = "Server: ServerResponse"; int localPort = 5150, sendCount = 10, bufferSize = 4096; IPAddress localAddress = IPAddress.Any; SocketType sockType = SocketType.Stream; ProtocolType sockProtocol = ProtocolType.Tcp; // Parse the command line for (int i = 0; i < args.Length; i++) { try { if ((args[i][0] == '-') || (args[i][0] == '/')) { switch (Char.ToLower(args[i][1])) { case 'l': // Local interface to bind to localAddress = IPAddress.Parse(args[++i]); break; case 'm': // Text message to put into the send buffer textMessage = args[++i]; break; case 'n': // Number of times to send the response sendCount = System.Convert.ToInt32(args[++i]); break; case 'p': // Port number for the destination localPort = System.Convert.ToInt32(args[++i]); break; case 't': // Specified TCP or UDP i++; if (String.Compare(args[i], "tcp", true) == 0) { sockType = SocketType.Stream; sockProtocol = ProtocolType.Tcp; } else if (String.Compare(args[i], "udp", true) == 0) { sockType = SocketType.Dgram; sockProtocol = ProtocolType.Udp; } else { FillServerUsage(); return; } break; case 'x': // Size of the send and receive buffers bufferSize = System.Convert.ToInt32(args[++i]); break; default: //queueSocketServer = FillServerUsage(); return; } } } catch { //MainForm.queueSocketServer = FillServerUsage(); return; } } Socket serverSocket = null; try { IPEndPoint localEndPoint = new IPEndPoint(localAddress, localPort), senderAddress = new IPEndPoint(localAddress, 0); Console.WriteLine("Server: IPEndPoint is OK..."); EndPoint castSenderAddress; Socket clientSocket; byte[] receiveBuffer = new byte[bufferSize], sendBuffer = new byte[bufferSize]; int rc; FormatBuffer(sendBuffer, textMessage); // Create the server socket serverSocket = new Socket(localAddress.AddressFamily, sockType, sockProtocol); Console.WriteLine("Server: Socket() is OK..."); // Bind the socket to the local interface specified serverSocket.Bind(localEndPoint); Console.WriteLine("Server: {0} server socket bound to {1}", sockProtocol.ToString(), localEndPoint.ToString()); if (sockProtocol == ProtocolType.Tcp) { // If TCP socket, set the socket to listening serverSocket.Listen(1); Console.WriteLine("Server: Listen() is OK, I'm listening for connection buddy!"); } else { byte[] byteTrue = new byte[4]; // Set the SIO_UDP_CONNRESET ioctl to true for this UDP socket. If this UDP socket // ever sends a UDP packet to a remote destination that exists but there is // no socket to receive the packet, an ICMP port unreachable message is returned // to the sender. By default, when this is received the next operation on the // UDP socket that send the packet will receive a SocketException. The native // (Winsock) error that is received is WSAECONNRESET (10054). Since we don't want // to wrap each UDP socket operation in a try/except, we'll disable this error // for the socket with this ioctl call. byteTrue[byteTrue.Length - 1] = 1; serverSocket.IOControl(ServerSocket.SIO_UDP_CONNRESET, byteTrue, null); Console.WriteLine("Server: IOControl() is OK..."); } // Service clients in a loop while (true) { if (sockProtocol == ProtocolType.Tcp) { // Wait for a client connection clientSocket = serverSocket.Accept(); Console.WriteLine("Server: Accept() is OK..."); Console.WriteLine("Server: Accepted connection from: {0}", clientSocket.RemoteEndPoint.ToString()); // Receive the request from the client in a loop until the client shuts // the connection down via a Shutdown. Console.WriteLine("Server: Preparing to receive using Receive()..."); while (true) { rc = clientSocket.Receive(receiveBuffer); Console.WriteLine("Server: Read {0} bytes", rc); if (rc == 0) { break; } } // Send the indicated number of response messages Console.WriteLine("Server: Preparing to send using Send()..."); for (int i = 0; i < sendCount; i++) { rc = clientSocket.Send(sendBuffer); Console.WriteLine("Server: Sent {0} bytes", rc); } // Shutdown the client connection clientSocket.Shutdown(SocketShutdown.Send); Console.WriteLine("Server: Shutdown() is OK..."); clientSocket.Close(); Console.WriteLine("Server: Close() is OK..."); } else { castSenderAddress = (EndPoint)senderAddress; // Receive the initial request from the client rc = serverSocket.ReceiveFrom(receiveBuffer, ref castSenderAddress); Console.WriteLine("Server: ReceiveFrom() is OK..."); senderAddress = (IPEndPoint)castSenderAddress; Console.WriteLine("Server: Received {0} bytes from {1}", rc, senderAddress.ToString()); // Send the response to the client the requested number of times for (int i = 0; i < sendCount; i++) { try { rc = serverSocket.SendTo(sendBuffer, senderAddress); Console.WriteLine("Server: SendTo() is OK..."); } catch { // If the sender's address is being spoofed we may get an error when sending // the response. You can test this by using IPv6 and using the RawSocket // sample to spoof a UDP packet with an invalid link local source address. continue; } Console.WriteLine("Server: Sent {0} bytes to {1}", rc, senderAddress.ToString()); } // Send several zero byte datagrams to indicate to client that no more data // will be sent from the server. Multiple packets are sent since UDP // is not guaranteed and we want to try to make an effort the client // gets at least one. Console.WriteLine("Server: Preparing to send using SendTo(), on the way do sleeping, Sleep(250)..."); for (int i = 0; i < 3; i++) { serverSocket.SendTo(sendBuffer, 0, 0, SocketFlags.None, senderAddress); // Space out sending the zero byte datagrams a bit. UDP is unreliable and // the local stack can even drop them before even hitting the wire! System.Threading.Thread.Sleep(250); } } } } catch (SocketException err) { Console.WriteLine("Server: Socket error occurred: {0}", err.Message); } finally { // Close the socket if necessary if (serverSocket != null) { Console.WriteLine("Server: Closing using Close()..."); serverSocket.Close(); } } }
public Socket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType) { _socket = new Java.Net.Socket(); }
public static void Create(AddressFamily addressFamily = AddressFamily.InterNetwork, SocketType socketType = SocketType.Stream, ProtocolType protocolType = ProtocolType.Tcp) { if (Created) { return; } mDefaultAddressFamily = addressFamily; mDefaultSocketType = socketType; mDefaultProtocolType = protocolType; CConsole.StatusLine("Creating {0} Sockets...", mInitialCapacity); mFreeSockets = new Queue <Socket>(mInitialCapacity); LoadPool(addressFamily, socketType, protocolType); Created = true; }
/// <summary> /// Initializes a new instance of the <see cref="SocketProxy"/> class. /// </summary> /// <param name="addressFamily">The address family.</param> /// <param name="socketType">Type of the socket.</param> /// <param name="protocolType">Type of the protocol.</param> internal SocketProxy(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType) { _socket = new Socket(addressFamily, socketType, protocolType); }
internal static extern IntPtr socket( [In] AddressFamily addressFamily, [In] SocketType socketType, [In] ProtocolType protocolType );
/// <summary> /// 构造函数、参数选填。当不填写参数,采用默认值: /// AddressFamily.InterNetwork、SocketType.Stream、ProtocolType.Tcp /// </summary> /// <param name="addressFamily">当不填写参数,采用默认值:AddressFamily.InterNetwork</param> /// <param name="soketType">当不填写参数,采用默认值:SocketType.Stream</param> /// <param name="protocolType">当不填写参数,采用默认值:ProtocolType.Tcp</param> public ClientSocket(AddressFamily addressFamily = AddressFamily.InterNetwork, SocketType soketType = SocketType.Stream, ProtocolType protocolType = ProtocolType.Tcp) { m_clientSocket = new Socket(addressFamily, soketType, protocolType); }
public SocketListener(SocketType type, IPEndPoint host, Action <Byte[], WritebackHandle> dataReceivedCallback) : this(type, host, () => { return(new BinaryComm(dataReceivedCallback)); }) { }
public void Ctor_Success(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType) { using (new Socket(addressFamily, socketType, protocolType)) { } }