Пример #1
0
 /// <summary>
 /// Consumes the test server's connection backlog by spamming non-blocking
 /// SocketChannel client connections.
 /// </summary>
 /// <remarks>
 /// Consumes the test server's connection backlog by spamming non-blocking
 /// SocketChannel client connections.  We never do anything with these sockets
 /// beyond just initiaing the connections.  The method saves a reference to each
 /// new SocketChannel so that it can be closed during tearDown.  We define a
 /// very small connection backlog, but the OS may silently enforce a larger
 /// minimum backlog than requested.  To work around this, we create far more
 /// client connections than our defined backlog.
 /// </remarks>
 /// <exception cref="System.IO.IOException">thrown for any I/O error</exception>
 private void ConsumeConnectionBacklog()
 {
     for (int i = 0; i < ClientsToConsumeBacklog; ++i)
     {
         SocketChannel client = SocketChannel.Open();
         client.ConfigureBlocking(false);
         client.Connect(nnHttpAddress);
         clients.AddItem(client);
     }
 }
Пример #2
0
        // does not reach here.
        /// <summary>
        /// The contract is similar to
        /// <see cref="SocketChannel.Connect(System.Net.EndPoint)"/>
        ///
        /// with a timeout.
        /// </summary>
        /// <seealso cref="SocketChannel.Connect(System.Net.EndPoint)"/>
        /// <param name="channel">
        /// - this should be a
        /// <see cref="SelectableChannel"/>
        /// </param>
        /// <param name="endpoint"/>
        /// <exception cref="System.IO.IOException"/>
        internal static void Connect(SocketChannel channel, EndPoint endpoint, int timeout
                                     )
        {
            bool blockingOn = channel.IsBlocking();

            if (blockingOn)
            {
                channel.ConfigureBlocking(false);
            }
            try
            {
                if (channel.Connect(endpoint))
                {
                    return;
                }
                long timeoutLeft = timeout;
                long endTime     = (timeout > 0) ? (Time.Now() + timeout) : 0;
                while (true)
                {
                    // we might have to call finishConnect() more than once
                    // for some channels (with user level protocols)
                    int ret = selector.Select((SelectableChannel)channel, SelectionKey.OpConnect, timeoutLeft
                                              );
                    if (ret > 0 && channel.FinishConnect())
                    {
                        return;
                    }
                    if (ret == 0 || (timeout > 0 && (timeoutLeft = (endTime - Time.Now())) <= 0))
                    {
                        throw new SocketTimeoutException(TimeoutExceptionString(channel, timeout, SelectionKey
                                                                                .OpConnect));
                    }
                }
            }
            catch (IOException e)
            {
                // javadoc for SocketChannel.connect() says channel should be closed.
                try
                {
                    channel.Close();
                }
                catch (IOException)
                {
                }
                throw;
            }
            finally
            {
                if (blockingOn && channel.IsOpen())
                {
                    channel.ConfigureBlocking(true);
                }
            }
        }
Пример #3
0
 public void connect(InetSocketAddress destAddress)
 {
     if (VpnServiceHelper.protect(mInnerChannel.Socket()))
     {
         mDestAddress = destAddress;
         mInnerChannel.Register(mSelector, Operations.Connect, this);
         mInnerChannel.Connect(mServerEP);
         Debug.WriteLine($"Connecting to {mServerEP}");
     }
     else
     {
         throw new Exception("VPN protect socket failed.");
     }
 }
Пример #4
0
        private void InitializeConnection(Java.Lang.String ipAndPort, InetAddress destinationAddress, int destinationPort,
                                          Packet currentPacket, TCPHeader tcpHeader, ByteBuffer responseBuffer)

        {
            currentPacket.SwapSourceAndDestination();
            if (tcpHeader.isSYN())
            {
                SocketChannel outputChannel = SocketChannel.Open();
                outputChannel.ConfigureBlocking(false);
                vpnService.Protect(outputChannel.Socket());

                TCB tcb = new TCB(ipAndPort, random.NextInt(Short.MaxValue + 1), tcpHeader.sequenceNumber, tcpHeader.sequenceNumber + 1,
                                  tcpHeader.acknowledgementNumber, outputChannel, currentPacket);
                TCB.PutTCB(ipAndPort, tcb);

                try
                {
                    outputChannel.Connect(new InetSocketAddress(destinationAddress, destinationPort));
                    if (outputChannel.FinishConnect())
                    {
                        tcb.status = TCB.TCBStatus.SYN_RECEIVED;
                        // TODO: Set MSS for receiving larger packets from the device
                        currentPacket.updateTCPBuffer(responseBuffer, (byte)(TCPHeader.SYN | TCPHeader.ACK),
                                                      tcb.mySequenceNum, tcb.myAcknowledgementNum, 0);
                        tcb.mySequenceNum++; // SYN counts as a byte
                    }
                    else
                    {
                        tcb.status = TCB.TCBStatus.SYN_SENT;
                        selector.Wakeup();
                        tcb.selectionKey = outputChannel.Register(selector, SelectionKey.OpConnect, tcb);
                        return;
                    }
                }
                catch (IOException e)
                {
                    Log.Error(TAG, "Connection error: " + ipAndPort, e);
                    currentPacket.updateTCPBuffer(responseBuffer, (byte)TCPHeader.RST, 0, tcb.myAcknowledgementNum, 0);
                    TCB.CloseTCB(tcb);
                }
            }
            else
            {
                currentPacket.updateTCPBuffer(responseBuffer, (byte)TCPHeader.RST,
                                              0, tcpHeader.sequenceNumber + 1, 0);
            }

            outputQueue.Offer(responseBuffer);
        }
        public void Options()
        {
            var socket = new SocketChannel(_settings.IpAddress, _settings.Port);

            socket.Connect();
            var beaconId = new BeaconId {
                InternalId = Guid.NewGuid()
            };

            _manager.AddChannel(beaconId, socket);

            // TODO: Implement more robust request/response configuration
            HttpContext.Response.Headers.Add("X-Id-Header", IdHeader);
            HttpContext.Response.Headers.Add("X-Identifier", beaconId.InternalId.ToString());
        }
Пример #6
0
        /// <summary>
        ///     Called when [connected].
        /// </summary>
        /// <param name="socket">The socket.</param>
        /// <returns></returns>
        public override async Task OnConnected(WebSocket socket)
        {
            await base.OnConnected(socket);

            var socketId = WebSocketManager.GetId(socket);

            Console.WriteLine($"Beacon connected: {socketId}");

            var serverChannel = new SocketChannel(_settings.IpAddress, _settings.Port);

            serverChannel.Connect();
            _socketManager.AddChannel(socketId, serverChannel);

            Console.WriteLine("Sending connect acknowledgement");
            var frame = new WebSocketFrame(FrameType.Connect, socketId.InternalId, new byte[] { 0x00 });

            await SendMessageAsync(socketId, frame.Encode());
        }