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);
}
}
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 Run()
{
try
{
Log.Info(TAG, "Started");
while (!Thread.Interrupted())
{
int readyChannels = selector.Select();
if (readyChannels == 0)
{
Thread.Sleep(10);
continue;
}
System.Console.WriteLine("UDP In");
var keys = selector.SelectedKeys().ToList();
foreach (var key in keys)
{
if (!Thread.Interrupted())
{
if (key.IsValid && key.IsReadable)
{
selector.SelectedKeys().Remove(key);
ByteBuffer receiveBuffer = ByteBufferPool.acquire();
// Leave space for the header
receiveBuffer.Position(HEADER_SIZE);
DatagramChannel inputChannel = (DatagramChannel)key.Channel();
// XXX: We should handle any IOExceptions here immediately,
// but that probably won't happen with UDP
int readBytes = inputChannel.Read(receiveBuffer);
Packet referencePacket = (Packet)key.Attachment();
referencePacket.updateUDPBuffer(receiveBuffer, readBytes);
receiveBuffer.Position(HEADER_SIZE + readBytes);
outputQueue.Offer(receiveBuffer);
}
}
}
}
}
catch (InterruptedException e)
{
Log.Info(TAG, "Stopping");
}
catch (IOException e)
{
Log.Warn(TAG, e.ToString(), e);
}
}
public void Enqueue(AsyncOperation asyncOperation)
{
_operations.Offer(asyncOperation);
_operationsAvailable.Release();
}
public static void Release(ByteBuffer buffer)
{
buffer.Clear();
pool.Offer(buffer);
}
public void Run()
{
Log.Info(TAG, "Started");
FileChannel vpnInput = new FileInputStream(vpnFileDescriptor).Channel;
FileChannel vpnOutput = new FileOutputStream(vpnFileDescriptor).Channel;
try
{
ByteBuffer bufferToNetwork = null;
bool dataSent = true;
bool dataReceived;
while (!Thread.Interrupted())
{
if (dataSent)
{
bufferToNetwork = ByteBufferPool.acquire();
}
else
{
bufferToNetwork.Clear();
}
// TODO: Block when not connected
int readBytes = vpnInput.Read(bufferToNetwork);
if (readBytes > 0)
{
dataSent = true;
bufferToNetwork.Flip();
Packet packet = new Packet(bufferToNetwork);
if (packet.IsUDP)
{
deviceToNetworkUDPQueue.Offer(packet);
System.Console.WriteLine("-> Device (UDP) to network write");
}
else if (packet.IsTCP)
{
deviceToNetworkTCPQueue.Offer(packet);
System.Console.WriteLine("-> Device (TCP) to network write");
}
else
{
Log.Warn(TAG, "Unknown packet type");
Log.Warn(TAG, packet.ip4Header.ToString());
dataSent = false;
}
}
else
{
dataSent = false;
}
ByteBuffer bufferFromNetwork = (ByteBuffer)networkToDeviceQueue.Poll();
if (bufferFromNetwork != null)
{
bufferFromNetwork.Flip();
while (bufferFromNetwork.HasRemaining)
{
try
{
vpnOutput.Write(bufferFromNetwork);
}
catch (Exception ex)
{
bufferFromNetwork.Clear();
System.Console.WriteLine(ex.Message);
}
}
dataReceived = true;
System.Console.WriteLine("<- Network to device write");
ByteBufferPool.Release(bufferFromNetwork);
}
else
{
dataReceived = false;
}
// TODO: Sleep-looping is not very battery-friendly, consider blocking instead
// Confirm if throughput with ConcurrentQueue is really higher compared to BlockingQueue
if (!dataSent && !dataReceived)
{
Thread.Sleep(10);
}
}
}
catch (InterruptedException e)
{
Log.Info(TAG, "Stopping");
}
catch (IOException e)
{
Log.Warn(TAG, e.ToString(), e);
}
finally
{
CloseResources(vpnInput, vpnOutput);
}
}
