예제 #1
0
 public static void PutTCB(String ipAndPort, TCB tcb)
 {
     lock (tcbCache)
     {
         tcbCache.Put(ipAndPort, tcb);
     }
 }
예제 #2
0
        private void processFIN(TCB tcb, TCPHeader tcpHeader, ByteBuffer responseBuffer)
        {
            lock (tcb)
            {
                Packet referencePacket = tcb.referencePacket;
                tcb.myAcknowledgementNum    = tcpHeader.sequenceNumber + 1;
                tcb.theirAcknowledgementNum = tcpHeader.acknowledgementNumber;

                if (tcb.waitingForNetworkData)
                {
                    tcb.status = TCB.TCBStatus.CLOSE_WAIT;
                    referencePacket.updateTCPBuffer(responseBuffer, (byte)TCPHeader.ACK,
                                                    tcb.mySequenceNum, tcb.myAcknowledgementNum, 0);
                }
                else
                {
                    tcb.status = TCB.TCBStatus.LAST_ACK;
                    referencePacket.updateTCPBuffer(responseBuffer, (byte)(TCPHeader.FIN | TCPHeader.ACK),
                                                    tcb.mySequenceNum, tcb.myAcknowledgementNum, 0);
                    tcb.mySequenceNum++; // FIN counts as a byte
                }
            }

            outputQueue.Offer(responseBuffer);
        }
예제 #3
0
        private void ProcessConnect(SelectionKey key, List <SelectionKey> keyIterator)
        {
            TCB    tcb             = (TCB)key.Attachment();
            Packet referencePacket = tcb.referencePacket;

            try
            {
                if (tcb.channel.FinishConnect())
                {
                    if (keyIterator[0] != null)
                    {
                        keyIterator.RemoveAt(0);
                    }
                    tcb.status = TCBStatus.SYN_RECEIVED;

                    // TODO: Set MSS for receiving larger packets from the device
                    ByteBuffer responseBuffer = ByteBufferPool.acquire();
                    referencePacket.updateTCPBuffer(responseBuffer, (byte)(Packet.TCPHeader.SYN | Packet.TCPHeader.ACK),
                                                    tcb.mySequenceNum, tcb.myAcknowledgementNum, 0);
                    outputQueue.Offer(responseBuffer);

                    tcb.mySequenceNum++; // SYN counts as a byte
                    //key.InterestOps(Operations.Read);
                    key.InterestOps();
                }
            }
            catch (IOException e)
            {
                Log.Error(TAG, "Connection error: " + tcb.ipAndPort, e);
                ByteBuffer responseBuffer = ByteBufferPool.acquire();
                referencePacket.updateTCPBuffer(responseBuffer, (byte)Packet.TCPHeader.RST, 0, tcb.myAcknowledgementNum, 0);
                outputQueue.Offer(responseBuffer);
                TCB.CloseTCB(tcb);
            }
        }
예제 #4
0
 public static void CloseTCB(TCB tcb)
 {
     tcb.CloseChannel();
     lock (tcbCache)
     {
         tcbCache.Remove(tcb.ipAndPort);
     }
 }
예제 #5
0
        private void processDuplicateSYN(TCB tcb, TCPHeader tcpHeader, ByteBuffer responseBuffer)
        {
            lock (tcb)
            {
                if (tcb.status == TCB.TCBStatus.SYN_SENT)
                {
                    tcb.myAcknowledgementNum = tcpHeader.sequenceNumber + 1;
                    return;
                }
            }

            SendRST(tcb, 1, responseBuffer);
        }
예제 #6
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);
        }
예제 #7
0
        private void processInput(SelectionKey key, List <SelectionKey> keyIterator)
        {
            System.Console.WriteLine("TCP In");

            try
            {
                if (keyIterator[0] != null)
                {
                    keyIterator.RemoveAt(0);
                }

                ByteBuffer receiveBuffer = ByteBufferPool.acquire();
                // Leave space for the header
                receiveBuffer.Position(HEADER_SIZE);

                TCB tcb = (TCB)key.Attachment();
                lock (tcb)
                {
                    Packet        referencePacket = tcb.referencePacket;
                    SocketChannel inputChannel    = (SocketChannel)key.Channel();
                    int           readBytes;
                    try
                    {
                        readBytes = inputChannel.Read(receiveBuffer);
                    }
                    catch (IOException e)
                    {
                        Log.Error(TAG, "Network read error: " + tcb.ipAndPort, e);
                        referencePacket.updateTCPBuffer(receiveBuffer, (byte)Packet.TCPHeader.RST, 0, tcb.myAcknowledgementNum, 0);
                        outputQueue.Offer(receiveBuffer);
                        TCB.CloseTCB(tcb);
                        return;
                    }

                    if (readBytes == -1)
                    {
                        // End of stream, stop waiting until we push more data
                        //key.InterestOps(0);
                        key.InterestOps();
                        tcb.waitingForNetworkData = false;

                        if (tcb.status != TCBStatus.CLOSE_WAIT)
                        {
                            ByteBufferPool.Release(receiveBuffer);
                            return;
                        }

                        tcb.status = TCBStatus.LAST_ACK;
                        referencePacket.updateTCPBuffer(receiveBuffer, (byte)Packet.TCPHeader.FIN, tcb.mySequenceNum, tcb.myAcknowledgementNum, 0);
                        tcb.mySequenceNum++; // FIN counts as a byte
                    }
                    else
                    {
                        // XXX: We should ideally be splitting segments by MTU/MSS, but this seems to work without
                        referencePacket.updateTCPBuffer(receiveBuffer, (byte)(Packet.TCPHeader.PSH | Packet.TCPHeader.ACK),
                                                        tcb.mySequenceNum, tcb.myAcknowledgementNum, readBytes);
                        tcb.mySequenceNum += readBytes; // Next sequence number
                        receiveBuffer.Position(HEADER_SIZE + readBytes);
                    }
                }

                outputQueue.Offer(receiveBuffer);
            }
            catch (Java.Lang.Exception ex)
            {
                System.Console.WriteLine(ex.Message);
            }
        }
예제 #8
0
        public void Run()
        {
            Log.Info(TAG, "Started");
            try
            {
                Thread currentThread = Thread.CurrentThread();
                while (true)
                {
                    Packet currentPacket;
                    // TODO: Block when not connected
                    do
                    {
                        currentPacket = (Packet)inputQueue.Poll();
                        if (currentPacket != null)
                        {
                            break;
                        }
                        Thread.Sleep(10);
                    } while (!currentThread.IsInterrupted);

                    if (currentThread.IsInterrupted)
                    {
                        break;
                    }

                    ByteBuffer payloadBuffer = currentPacket.backingBuffer;
                    currentPacket.backingBuffer = null;
                    ByteBuffer responseBuffer = ByteBufferPool.acquire();

                    InetAddress destinationAddress = currentPacket.ip4Header.destinationAddress;

                    TCPHeader tcpHeader       = currentPacket.tcpHeader;
                    int       destinationPort = tcpHeader.destinationPort;
                    int       sourcePort      = tcpHeader.sourcePort;

                    Java.Lang.String ipAndPort = new Java.Lang.String(destinationAddress.HostAddress + ":" +
                                                                      destinationPort + ":" + sourcePort);

                    System.Console.WriteLine("TCP Out: " + ipAndPort);

                    TCB tcb = TCB.GetTCB(ipAndPort);
                    if (tcb == null)
                    {
                        InitializeConnection(ipAndPort, destinationAddress, destinationPort,
                                             currentPacket, tcpHeader, responseBuffer);
                    }
                    else if (tcpHeader.isSYN())
                    {
                        processDuplicateSYN(tcb, tcpHeader, responseBuffer);
                    }
                    else if (tcpHeader.isRST())
                    {
                        CloseCleanly(tcb, responseBuffer);
                    }
                    else if (tcpHeader.isFIN())
                    {
                        processFIN(tcb, tcpHeader, responseBuffer);
                    }
                    else if (tcpHeader.isACK())
                    {
                        processACK(tcb, tcpHeader, payloadBuffer, responseBuffer);
                    }

                    // XXX: cleanup later
                    if (responseBuffer.Position() == 0)
                    {
                        ByteBufferPool.Release(responseBuffer);
                    }
                    ByteBufferPool.Release(payloadBuffer);
                }
            }
            catch (InterruptedException e)
            {
                Log.Info(TAG, "Stopping");
            }
            catch (IOException e)
            {
                Log.Error(TAG, e.ToString(), e);
            }
            finally
            {
                TCB.CloseAll();
            }
        }
예제 #9
0
 private void CloseCleanly(TCB tcb, ByteBuffer buffer)
 {
     ByteBufferPool.Release(buffer);
     TCB.CloseTCB(tcb);
 }
예제 #10
0
 private void SendRST(TCB tcb, int prevPayloadSize, ByteBuffer buffer)
 {
     tcb.referencePacket.updateTCPBuffer(buffer, (byte)TCPHeader.RST, 0, tcb.myAcknowledgementNum + prevPayloadSize, 0);
     outputQueue.Offer(buffer);
     TCB.CloseTCB(tcb);
 }
예제 #11
0
        private void processACK(TCB tcb, TCPHeader tcpHeader, ByteBuffer payloadBuffer, ByteBuffer responseBuffer)
        {
            try
            {
                int payloadSize = payloadBuffer.Limit() - payloadBuffer.Position();

                lock (tcb)
                {
                    SocketChannel outputChannel = tcb.channel;
                    if (tcb.status == TCB.TCBStatus.SYN_RECEIVED)
                    {
                        tcb.status = TCB.TCBStatus.ESTABLISHED;

                        selector.Wakeup();
                        tcb.selectionKey          = outputChannel.Register(selector, SelectionKey.OpRead, tcb);
                        tcb.waitingForNetworkData = true;
                    }
                    else if (tcb.status == TCB.TCBStatus.LAST_ACK)
                    {
                        CloseCleanly(tcb, responseBuffer);
                        return;
                    }

                    if (payloadSize == 0)
                    {
                        return;                   // Empty ACK, ignore
                    }
                    if (!tcb.waitingForNetworkData)
                    {
                        selector.Wakeup();
                        // tcb.selectionKey.InterestOps(SelectionKey.OpRead);
                        tcb.selectionKey.InterestOps();
                        tcb.waitingForNetworkData = true;
                    }

                    // Forward to remote server
                    try
                    {
                        while (payloadBuffer.HasRemaining)
                        {
                            outputChannel.Write(payloadBuffer);
                        }
                    }
                    catch (IOException e)
                    {
                        Log.Error(TAG, "Network write error: " + tcb.ipAndPort, e);
                        SendRST(tcb, payloadSize, responseBuffer);
                        return;
                    }

                    // TODO: We don't expect out-of-order packets, but verify
                    tcb.myAcknowledgementNum    = tcpHeader.sequenceNumber + payloadSize;
                    tcb.theirAcknowledgementNum = tcpHeader.acknowledgementNumber;
                    Packet referencePacket = tcb.referencePacket;
                    referencePacket.updateTCPBuffer(responseBuffer, (byte)TCPHeader.ACK, tcb.mySequenceNum, tcb.myAcknowledgementNum, 0);
                }

                outputQueue.Offer(responseBuffer);
            }
            catch (Exception ex)
            {
                System.Console.WriteLine(ex.Message);
            }
        }