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); } }