Log.w(TAG, "Unexpected packet IP version: " + version);
}
} else {
Log.d(TAG, "Empty read");
}
}
Log.d(TAG, "Device to tunnel forwarding stopped");
}
private void forwardTunnelToDevice(Tunnel tunnel) throws IOException {
Log.d(TAG, "Tunnel to device forwarding started");
FileOutputStream vpnOutput = new FileOutputStream(vpnFileDescriptor);
IPPacketOutputStream packetOutputStream = new IPPacketOutputStream(vpnOutput);
byte[] buffer = new byte[BUFSIZE];
while (true) {
// blocking receive
int w = tunnel.receive(buffer);
if (w == -1) {
Log.d(TAG, "Tunnel closed");
break;
}
if (w > 0) {
// blocking write
packetOutputStream.write(buffer, 0, w);
} else {
Log.d(TAG, "Empty write");
}
}
Log.d(TAG, "Tunnel to device forwarding stopped");
}
/**
* Neither vpnInterface.close() nor vpnInputStream.close() wake up a blocking
* vpnInputStream.read().
*
* Therefore, we need to make Android send a packet to the VPN interface (here by sending a UDP
* packet), so that any blocking read will be woken up.
*
* Since the tunnel is closed at this point, it will never reach the network.
*/
private void wakeUpReadWorkaround() {
// network actions may not be called from the main thread
EXECUTOR_SERVICE.execute(new Runnable() {
@Override
public void run() {
try {
DatagramSocket socket = new DatagramSocket();
InetAddress dummyAddr = InetAddress.getByAddress(DUMMY_ADDRESS);
DatagramPacket packet = new DatagramPacket(new byte[0], 0, dummyAddr, DUMMY_PORT);
socket.send(packet);
} catch (IOException e) {
// ignore
}
}
});
}
}
================================================
FILE: app/src/main/java/com/genymobile/gnirehtet/GnirehtetActivity.java
================================================
package com.genymobile.gnirehtet;
import android.app.Activity;
import android.content.Intent;
import android.net.VpnService;
import android.os.Bundle;
import android.util.Log;
/**
* This (invisible) activity receives the {@link #ACTION_GNIREHTET_START START} and
* {@link #ACTION_GNIREHTET_STOP} actions from the command line.
*
* Recent versions of Android refuse to directly start a {@link android.app.Service Service} or a
* {@link android.content.BroadcastReceiver BroadcastReceiver}, so actions are always managed by
* this activity.
*/
public class GnirehtetActivity extends Activity {
private static final String TAG = GnirehtetActivity.class.getSimpleName();
public static final String ACTION_GNIREHTET_START = "com.genymobile.gnirehtet.START";
public static final String ACTION_GNIREHTET_STOP = "com.genymobile.gnirehtet.STOP";
public static final String EXTRA_DNS_SERVERS = "dnsServers";
public static final String EXTRA_ROUTES = "routes";
private static final int VPN_REQUEST_CODE = 0;
private VpnConfiguration requestedConfig;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
handleIntent(getIntent());
}
private void handleIntent(Intent intent) {
String action = intent.getAction();
Log.d(TAG, "Received request " + action);
boolean finish = true;
if (ACTION_GNIREHTET_START.equals(action)) {
VpnConfiguration config = createConfig(intent);
finish = startGnirehtet(config);
} else if (ACTION_GNIREHTET_STOP.equals(action)) {
stopGnirehtet();
}
if (finish) {
finish();
}
}
private static VpnConfiguration createConfig(Intent intent) {
String[] dnsServers = intent.getStringArrayExtra(EXTRA_DNS_SERVERS);
if (dnsServers == null) {
dnsServers = new String[0];
}
String[] routes = intent.getStringArrayExtra(EXTRA_ROUTES);
if (routes == null) {
routes = new String[0];
}
return new VpnConfiguration(Net.toInetAddresses(dnsServers), Net.toCIDRs(routes));
}
private boolean startGnirehtet(VpnConfiguration config) {
Intent vpnIntent = VpnService.prepare(this);
if (vpnIntent == null) {
Log.d(TAG, "VPN was already authorized");
// we got the permission, start the service now
GnirehtetService.start(this, config);
return true;
}
Log.w(TAG, "VPN requires the authorization from the user, requesting...");
requestAuthorization(vpnIntent, config);
return false; // do not finish now
}
private void stopGnirehtet() {
GnirehtetService.stop(this);
}
private void requestAuthorization(Intent vpnIntent, VpnConfiguration config) {
this.requestedConfig = config;
startActivityForResult(vpnIntent, VPN_REQUEST_CODE);
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
if (requestCode == VPN_REQUEST_CODE && resultCode == RESULT_OK) {
GnirehtetService.start(this, requestedConfig);
}
requestedConfig = null;
finish();
}
}
================================================
FILE: app/src/main/java/com/genymobile/gnirehtet/GnirehtetService.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet;
import android.content.Context;
import android.content.Intent;
import android.net.ConnectivityManager;
import android.net.LinkAddress;
import android.net.LinkProperties;
import android.net.Network;
import android.net.VpnService;
import android.os.Build;
import android.os.Handler;
import android.os.Message;
import android.os.ParcelFileDescriptor;
import android.util.Log;
import java.io.IOException;
import java.net.InetAddress;
import java.util.List;
public class GnirehtetService extends VpnService {
public static final boolean VERBOSE = false;
private static final String ACTION_START_VPN = "com.genymobile.gnirehtet.START_VPN";
private static final String ACTION_CLOSE_VPN = "com.genymobile.gnirehtet.CLOSE_VPN";
private static final String EXTRA_VPN_CONFIGURATION = "vpnConfiguration";
private static final String TAG = GnirehtetService.class.getSimpleName();
private static final InetAddress VPN_ADDRESS = Net.toInetAddress(new byte[] {10, 0, 0, 2});
// magic value: higher (like 0x8000 or 0xffff) or lower (like 1500) values show poorer performances
private static final int MTU = 0x4000;
private final Notifier notifier = new Notifier(this);
private final Handler handler = new RelayTunnelConnectionStateHandler(this);
private ParcelFileDescriptor vpnInterface = null;
private Forwarder forwarder;
public static void start(Context context, VpnConfiguration config) {
Intent intent = new Intent(context, GnirehtetService.class);
intent.setAction(ACTION_START_VPN);
intent.putExtra(GnirehtetService.EXTRA_VPN_CONFIGURATION, config);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
context.startForegroundService(intent);
} else {
context.startService(intent);
}
}
public static void stop(Context context) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
context.startForegroundService(createStopIntent(context));
} else {
context.startService(createStopIntent(context));
}
}
static Intent createStopIntent(Context context) {
Intent intent = new Intent(context, GnirehtetService.class);
intent.setAction(ACTION_CLOSE_VPN);
return intent;
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
String action = intent.getAction();
Log.d(TAG, "Received request " + action);
if (ACTION_START_VPN.equals(action)) {
if (isRunning()) {
Log.d(TAG, "VPN already running, ignore START request");
} else {
VpnConfiguration config = intent.getParcelableExtra(EXTRA_VPN_CONFIGURATION);
if (config == null) {
config = new VpnConfiguration();
}
startVpn(config);
}
} else if (ACTION_CLOSE_VPN.equals(action)) {
close();
}
return START_NOT_STICKY;
}
private boolean isRunning() {
return vpnInterface != null;
}
private void startVpn(VpnConfiguration config) {
notifier.start();
if (setupVpn(config)) {
startForwarding();
}
}
@SuppressWarnings("checkstyle:MagicNumber")
private boolean setupVpn(VpnConfiguration config) {
Builder builder = new Builder();
builder.addAddress(VPN_ADDRESS, 32);
builder.setSession(getString(R.string.app_name));
CIDR[] routes = config.getRoutes();
if (routes.length == 0) {
// no routes defined, redirect the whole network traffic
builder.addRoute("0.0.0.0", 0);
} else {
for (CIDR route : routes) {
builder.addRoute(route.getAddress(), route.getPrefixLength());
}
}
InetAddress[] dnsServers = config.getDnsServers();
if (dnsServers.length == 0) {
// no DNS server defined, use Google DNS
builder.addDnsServer("8.8.8.8");
} else {
for (InetAddress dnsServer : dnsServers) {
builder.addDnsServer(dnsServer);
}
}
// non-blocking by default, but FileChannel is not selectable, that's stupid!
// so switch to synchronous I/O to avoid polling
builder.setBlocking(true);
builder.setMtu(MTU);
vpnInterface = builder.establish();
if (vpnInterface == null) {
Log.w(TAG, "VPN starting failed, please retry");
// establish() may return null if the application is not prepared or is revoked
return false;
}
setAsUndernlyingNetwork();
return true;
}
@SuppressWarnings("checkstyle:MagicNumber")
private void setAsUndernlyingNetwork() {
if (Build.VERSION.SDK_INT >= 22) {
Network vpnNetwork = findVpnNetwork();
if (vpnNetwork != null) {
// so that applications knows that network is available
setUnderlyingNetworks(new Network[] {vpnNetwork});
}
} else {
Log.w(TAG, "Cannot set underlying network, API version " + Build.VERSION.SDK_INT + " < 22");
}
}
private Network findVpnNetwork() {
ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
Network[] networks = cm.getAllNetworks();
for (Network network : networks) {
LinkProperties linkProperties = cm.getLinkProperties(network);
List addresses = linkProperties.getLinkAddresses();
for (LinkAddress addr : addresses) {
if (addr.getAddress().equals(VPN_ADDRESS)) {
return network;
}
}
}
return null;
}
private void startForwarding() {
forwarder = new Forwarder(this, vpnInterface.getFileDescriptor(), new RelayTunnelListener(handler));
forwarder.forward();
}
private void close() {
if (!isRunning()) {
// already closed
return;
}
notifier.stop();
try {
forwarder.stop();
forwarder = null;
vpnInterface.close();
vpnInterface = null;
} catch (IOException e) {
Log.w(TAG, "Cannot close VPN file descriptor", e);
}
}
private static final class RelayTunnelConnectionStateHandler extends Handler {
private final GnirehtetService vpnService;
private RelayTunnelConnectionStateHandler(GnirehtetService vpnService) {
this.vpnService = vpnService;
}
@Override
public void handleMessage(Message message) {
if (!vpnService.isRunning()) {
// if the VPN is not running anymore, ignore obsolete events
return;
}
switch (message.what) {
case RelayTunnelListener.MSG_RELAY_TUNNEL_CONNECTED:
Log.d(TAG, "Relay tunnel connected");
vpnService.notifier.setFailure(false);
break;
case RelayTunnelListener.MSG_RELAY_TUNNEL_DISCONNECTED:
Log.d(TAG, "Relay tunnel disconnected");
vpnService.notifier.setFailure(true);
break;
default:
}
}
}
}
================================================
FILE: app/src/main/java/com/genymobile/gnirehtet/IPPacketOutputStream.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet;
import android.util.Log;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.ByteBuffer;
/**
* Wrapper for writing one IP packet at a time to an {@link OutputStream}.
*/
@SuppressWarnings("checkstyle:MagicNumber")
public class IPPacketOutputStream extends OutputStream {
private static final String TAG = IPPacketOutputStream.class.getSimpleName();
private static final int MAX_IP_PACKET_LENGTH = 1 << 16; // packet length is stored on 16 bits
private final OutputStream target;
// must always accept 1 full packet + any partial packet
private final ByteBuffer buffer = ByteBuffer.allocate(2 * MAX_IP_PACKET_LENGTH);
public IPPacketOutputStream(OutputStream target) {
this.target = target;
}
@Override
public void close() throws IOException {
target.close();
}
@Override
public void flush() throws IOException {
target.flush();
}
@Override
public void write(byte[] b, int off, int len) throws IOException {
if (len > MAX_IP_PACKET_LENGTH) {
throw new IOException("IPPacketOutputStream does not support writing more than one packet at a time");
}
// by design, the buffer must always have enough space for one packet
if (BuildConfig.DEBUG && len > buffer.remaining()) {
Log.e(TAG, len + " must be <= than " + buffer.remaining());
Log.e(TAG, buffer.toString());
throw new AssertionError("Buffer is unexpectedly full");
}
buffer.put(b, off, len);
buffer.flip();
sink();
buffer.compact();
}
@Override
public void write(int b) throws IOException {
if (!buffer.hasRemaining()) {
throw new IOException("IPPacketOutputStream buffer is full");
}
buffer.put((byte) b);
buffer.flip();
sink();
buffer.compact();
}
private void sink() throws IOException {
// sink all packets
while (sinkPacket()) {
// continue
}
}
private boolean sinkPacket() throws IOException {
int version = readPacketVersion(buffer);
if (version == -1) {
// no packet at all
return false;
}
if (version != 4) {
Log.e(TAG, "Unsupported packet received, IP version is:" + version);
Log.d(TAG, "Clearing buffer");
buffer.clear();
return false;
}
int packetLength = readPacketLength(buffer);
if (packetLength == -1 || packetLength > buffer.remaining()) {
// no packet
return false;
}
target.write(buffer.array(), buffer.arrayOffset() + buffer.position(), packetLength);
buffer.position(buffer.position() + packetLength);
return true;
}
/**
* Read the packet IP version, assuming that an IP packets is stored at absolute position 0.
*
* @param buffer the buffer
* @return the IP version, or {@code -1} if not available
*/
public static int readPacketVersion(ByteBuffer buffer) {
if (!buffer.hasRemaining()) {
// buffer is empty
return -1;
}
// version is stored in the 4 first bits
byte versionAndIHL = buffer.get(buffer.position());
return (versionAndIHL & 0xf0) >> 4;
}
/**
* Read the packet length, assuming thatan IP packet is stored at absolute position 0.
*
* @param buffer the buffer
* @return the packet length, or {@code -1} if not available
*/
public static int readPacketLength(ByteBuffer buffer) {
if (buffer.limit() < buffer.position() + 4) {
// buffer does not even contains the length field
return -1;
}
// packet length is 16 bits starting at offset 2
return Binary.unsigned(buffer.getShort(buffer.position() + 2));
}
}
================================================
FILE: app/src/main/java/com/genymobile/gnirehtet/InvalidCIDRException.java
================================================
/*
* Copyright (C) 2018 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet;
public class InvalidCIDRException extends Exception {
private String cidr;
private static String createMessage(String cidr) {
return "Invalid CIDR:" + cidr;
}
public InvalidCIDRException(String cidr, Throwable cause) {
super(createMessage(cidr), cause);
this.cidr = cidr;
}
public InvalidCIDRException(String cidr) {
super(createMessage(cidr));
this.cidr = cidr;
}
public String getCIDR() {
return cidr;
}
}
================================================
FILE: app/src/main/java/com/genymobile/gnirehtet/Net.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet;
import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.UnknownHostException;
public final class Net {
private Net() {
// not instantiable
}
public static InetAddress[] toInetAddresses(String... addresses) {
InetAddress[] result = new InetAddress[addresses.length];
for (int i = 0; i < result.length; ++i) {
result[i] = toInetAddress(addresses[i]);
}
return result;
}
public static InetAddress toInetAddress(String address) {
try {
return InetAddress.getByName(address);
} catch (UnknownHostException e) {
throw new IllegalArgumentException(e);
}
}
public static InetAddress toInetAddress(byte[] raw) {
try {
return InetAddress.getByAddress(raw);
} catch (UnknownHostException e) {
throw new IllegalArgumentException(e);
}
}
public static CIDR toCIDR(String cidr) {
try {
return CIDR.parse(cidr);
} catch (InvalidCIDRException e) {
throw new IllegalArgumentException(e);
}
}
public static CIDR[] toCIDRs(String... cidrs) {
CIDR[] result = new CIDR[cidrs.length];
for (int i = 0; i < result.length; ++i) {
result[i] = toCIDR(cidrs[i]);
}
return result;
}
@SuppressWarnings("checkstyle:MagicNumber")
public static Inet4Address getLocalhostIPv4() {
byte[] localhost = {127, 0, 0, 1};
return (Inet4Address) toInetAddress(localhost);
}
}
================================================
FILE: app/src/main/java/com/genymobile/gnirehtet/Notifier.java
================================================
package com.genymobile.gnirehtet;
import android.annotation.TargetApi;
import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
/**
* Manage the notification necessary for the foreground service (mandatory since Android O).
*/
public class Notifier {
private static final int NOTIFICATION_ID = 42;
private static final String CHANNEL_ID = "Gnirehtet";
private final Service context;
private boolean failure;
public Notifier(Service context) {
this.context = context;
}
private Notification createNotification(boolean failure) {
Notification.Builder notificationBuilder = createNotificationBuilder();
notificationBuilder.setContentTitle(context.getString(R.string.app_name));
if (failure) {
notificationBuilder.setContentText(context.getString(R.string.relay_disconnected));
notificationBuilder.setSmallIcon(R.drawable.ic_report_problem_24dp);
} else {
notificationBuilder.setContentText(context.getString(R.string.relay_connected));
notificationBuilder.setSmallIcon(R.drawable.ic_usb_24dp);
}
notificationBuilder.addAction(createStopAction());
return notificationBuilder.build();
}
@SuppressWarnings("deprecation")
private Notification.Builder createNotificationBuilder() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
return new Notification.Builder(context, CHANNEL_ID);
}
return new Notification.Builder(context);
}
@TargetApi(26)
private void createNotificationChannel() {
NotificationChannel channel = new NotificationChannel(CHANNEL_ID, context.getString(R.string.app_name), NotificationManager
.IMPORTANCE_DEFAULT);
getNotificationManager().createNotificationChannel(channel);
}
@TargetApi(26)
private void deleteNotificationChannel() {
getNotificationManager().deleteNotificationChannel(CHANNEL_ID);
}
public void start() {
failure = false; // reset failure flag
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
createNotificationChannel();
}
context.startForeground(NOTIFICATION_ID, createNotification(false));
}
public void stop() {
context.stopForeground(true);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
deleteNotificationChannel();
}
}
public void setFailure(boolean failure) {
if (this.failure != failure) {
this.failure = failure;
Notification notification = createNotification(failure);
getNotificationManager().notify(NOTIFICATION_ID, notification);
}
}
private Notification.Action createStopAction() {
Intent stopIntent = GnirehtetService.createStopIntent(context);
PendingIntent stopPendingIntent = PendingIntent.getService(context, 0, stopIntent, PendingIntent.FLAG_ONE_SHOT);
// the non-deprecated constructor is not available in API 21
@SuppressWarnings("deprecation")
Notification.Action.Builder actionBuilder = new Notification.Action.Builder(R.drawable.ic_close_24dp, context.getString(R.string.stop_vpn),
stopPendingIntent);
return actionBuilder.build();
}
private NotificationManager getNotificationManager() {
return (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
}
}
================================================
FILE: app/src/main/java/com/genymobile/gnirehtet/PersistentRelayTunnel.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet;
import android.net.VpnService;
import android.util.Log;
import java.io.IOException;
import java.io.InterruptedIOException;
import java.util.concurrent.atomic.AtomicBoolean;
/**
* Expose a {@link Tunnel} that automatically handles {@link RelayTunnel} reconnections.
*/
public class PersistentRelayTunnel implements Tunnel {
private static final String TAG = PersistentRelayTunnel.class.getSimpleName();
private final RelayTunnelProvider provider;
private final AtomicBoolean stopped = new AtomicBoolean();
public PersistentRelayTunnel(VpnService vpnService, RelayTunnelListener listener) {
provider = new RelayTunnelProvider(vpnService, listener);
}
@Override
public void send(byte[] packet, int len) throws IOException {
while (!stopped.get()) {
Tunnel tunnel = null;
try {
tunnel = provider.getCurrentTunnel();
tunnel.send(packet, len);
return;
} catch (IOException | InterruptedException e) {
Log.e(TAG, "Cannot send to tunnel", e);
if (tunnel != null) {
provider.invalidateTunnel(tunnel);
}
}
}
throw new InterruptedIOException("Persistent tunnel stopped");
}
@Override
public int receive(byte[] packet) throws IOException {
while (!stopped.get()) {
Tunnel tunnel = null;
try {
tunnel = provider.getCurrentTunnel();
int r = tunnel.receive(packet);
if (r == -1) {
Log.d(TAG, "Tunnel read EOF");
provider.invalidateTunnel(tunnel);
continue;
}
return r;
} catch (IOException | InterruptedException e) {
Log.e(TAG, "Cannot receive from tunnel", e);
if (tunnel != null) {
provider.invalidateTunnel(tunnel);
}
}
}
throw new InterruptedIOException("Persistent tunnel stopped");
}
@Override
public void close() {
stopped.set(true);
provider.invalidateTunnel();
}
}
================================================
FILE: app/src/main/java/com/genymobile/gnirehtet/RelayTunnel.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet;
import android.net.LocalSocket;
import android.net.LocalSocketAddress;
import android.net.VpnService;
import android.util.Log;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
public final class RelayTunnel implements Tunnel {
private static final String TAG = RelayTunnel.class.getSimpleName();
private static final String LOCAL_ABSTRACT_NAME = "gnirehtet";
private final LocalSocket localSocket = new LocalSocket();
private RelayTunnel() {
// exposed through open() static method
}
@SuppressWarnings("unused")
public static RelayTunnel open(VpnService vpnService) throws IOException {
Log.d(TAG, "Opening a new relay tunnel...");
// since we use a local socket, we don't need to protect the socket from the vpnService anymore
// but this is an implementation detail, so keep the method signature
return new RelayTunnel();
}
public void connect() throws IOException {
localSocket.connect(new LocalSocketAddress(LOCAL_ABSTRACT_NAME));
readClientId(localSocket.getInputStream());
}
/**
* The relay server is accessible through an "adb reverse" port redirection.
*
* If the port redirection is enabled but the relay server is not started, then the call to
* channel.connect() will succeed, but the first read() will return -1.
*
* As a consequence, the connection state of the relay server would be invalid temporarily (we
* would switch to CONNECTED state then switch back to DISCONNECTED).
*
* To avoid this problem, we must actually read from the server, so that an error occurs
* immediately if the relay server is not accessible.
*
* Therefore, the relay server immediately sends the client id: consume it and log it.
*
* @param inputStream the input stream to receive data from the relay server
* @throws IOException if an I/O error occurs
*/
private static void readClientId(InputStream inputStream) throws IOException {
Log.d(TAG, "Requesting client id");
int clientId = new DataInputStream(inputStream).readInt();
Log.d(TAG, "Connected to the relay server as #" + Binary.unsigned(clientId));
}
@Override
public void send(byte[] packet, int len) throws IOException {
if (GnirehtetService.VERBOSE) {
Log.v(TAG, "Sending packet: " + Binary.buildPacketString(packet, len));
}
localSocket.getOutputStream().write(packet, 0, len);
}
@Override
public int receive(byte[] packet) throws IOException {
int r = localSocket.getInputStream().read(packet);
if (GnirehtetService.VERBOSE) {
Log.v(TAG, "Receiving packet: " + Binary.buildPacketString(packet, r));
}
return r;
}
@Override
public void close() {
try {
if (localSocket.getFileDescriptor() != null) {
// close the streams to interrupt pending read and writes
localSocket.shutdownInput();
localSocket.shutdownOutput();
}
localSocket.close();
} catch (IOException e) {
// what could we do?
throw new RuntimeException(e);
}
}
}
================================================
FILE: app/src/main/java/com/genymobile/gnirehtet/RelayTunnelListener.java
================================================
package com.genymobile.gnirehtet;
import android.os.Handler;
/**
* Convenient wrapper to dispatch events to the given {@link Handler}.
*/
public class RelayTunnelListener {
static final int MSG_RELAY_TUNNEL_CONNECTED = 0;
static final int MSG_RELAY_TUNNEL_DISCONNECTED = 1;
private final Handler handler;
public RelayTunnelListener(Handler handler) {
this.handler = handler;
}
public void notifyRelayTunnelConnected() {
handler.sendEmptyMessage(MSG_RELAY_TUNNEL_CONNECTED);
}
public void notifyRelayTunnelDisconnected() {
handler.sendEmptyMessage(MSG_RELAY_TUNNEL_DISCONNECTED);
}
}
================================================
FILE: app/src/main/java/com/genymobile/gnirehtet/RelayTunnelProvider.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet;
import android.net.VpnService;
import java.io.IOException;
/**
* Provide a valid {@link RelayTunnel}, creating a new one if necessary.
*/
public class RelayTunnelProvider {
private static final int DELAY_BETWEEN_ATTEMPTS_MS = 5000;
private final Object getCurrentTunnelLock = new Object(); // protects getCurrentTunnel()
private final VpnService vpnService;
private final RelayTunnelListener listener;
private RelayTunnel tunnel; // protected both by "this" and "getCurrentTunnelLock"
private boolean first = true; // protected by "getCurrentTunnelLock"
private long lastFailureTimestamp; // protected by "this"
public RelayTunnelProvider(VpnService vpnService, RelayTunnelListener listener) {
this.vpnService = vpnService;
this.listener = listener;
}
public RelayTunnel getCurrentTunnel() throws IOException, InterruptedException {
/*
* To make sure that both the sending and receiving threads use the same tunnel, we must
* guarantee that this method may not be called several times concurrently.
*
* However, since it executes potentially long-running blocking calls, we still want to be
* able to call invalidateTunnel() concurrently, which requires to protect some fields.
*
* Therefore, use one mutex ("getCurrentTunnelLock") to avoid concurrent calls to
* getCurrentTunnel(), and another one ("this") to protect fields shared with
* invalidateTunnel().
*/
synchronized (getCurrentTunnelLock) {
synchronized (this) {
if (tunnel != null) {
return tunnel;
}
waitUntilNextAttemptSlot();
// "tunnel" has not changed during waiting (only getCurrentTunnel() may write it)
tunnel = RelayTunnel.open(vpnService);
}
// the first connection must either notify "connected" or "disconnected"
boolean notifyDisconnectedOnError = first;
first = false;
connectTunnel(notifyDisconnectedOnError);
}
return tunnel;
}
private void connectTunnel(boolean notifyDisconnectedOnError) throws IOException {
try {
tunnel.connect();
notifyConnected();
} catch (IOException e) {
touchFailure();
if (notifyDisconnectedOnError) {
notifyDisconnected();
}
throw e;
}
}
public synchronized void invalidateTunnel() {
if (tunnel != null) {
touchFailure();
tunnel.close();
tunnel = null;
notifyDisconnected();
}
}
/**
* Call {@link #invalidateTunnel()} only if {@code tunnelToInvalidate} is the current tunnel (or
* is {@code null}).
*
* @param tunnelToInvalidate the tunnel to invalidate
*/
public synchronized void invalidateTunnel(Tunnel tunnelToInvalidate) {
if (tunnel == tunnelToInvalidate || tunnelToInvalidate == null) {
invalidateTunnel();
}
}
private synchronized void touchFailure() {
lastFailureTimestamp = System.currentTimeMillis();
}
private void waitUntilNextAttemptSlot() throws InterruptedException {
if (first) {
// do not wait on first attempt
return;
}
long delay = lastFailureTimestamp + DELAY_BETWEEN_ATTEMPTS_MS - System.currentTimeMillis();
while (delay > 0) {
wait(delay);
delay = lastFailureTimestamp + DELAY_BETWEEN_ATTEMPTS_MS - System.currentTimeMillis();
}
}
private void notifyConnected() {
if (listener != null) {
listener.notifyRelayTunnelConnected();
}
}
private void notifyDisconnected() {
if (listener != null) {
listener.notifyRelayTunnelDisconnected();
}
}
}
================================================
FILE: app/src/main/java/com/genymobile/gnirehtet/Tunnel.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet;
import java.io.IOException;
public interface Tunnel {
// blocking
void send(byte[] packet, int len) throws IOException;
// blocking
int receive(byte[] packet) throws IOException;
// blocking
void close();
}
================================================
FILE: app/src/main/java/com/genymobile/gnirehtet/VpnConfiguration.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet;
import android.os.Parcel;
import android.os.Parcelable;
import java.net.InetAddress;
import java.net.UnknownHostException;
public class VpnConfiguration implements Parcelable {
private final InetAddress[] dnsServers;
private final CIDR[] routes;
public VpnConfiguration() {
this.dnsServers = new InetAddress[0];
this.routes = new CIDR[0];
}
public VpnConfiguration(InetAddress[] dnsServers, CIDR[] routes) {
this.dnsServers = dnsServers;
this.routes = routes;
}
private VpnConfiguration(Parcel source) {
int dnsCount = source.readInt();
dnsServers = new InetAddress[dnsCount];
try {
for (int i = 0; i < dnsCount; ++i) {
dnsServers[i] = InetAddress.getByAddress(source.createByteArray());
}
} catch (UnknownHostException e) {
throw new AssertionError("Invalid address", e);
}
routes = source.createTypedArray(CIDR.CREATOR);
}
public InetAddress[] getDnsServers() {
return dnsServers;
}
public CIDR[] getRoutes() {
return routes;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeInt(dnsServers.length);
for (InetAddress addr : dnsServers) {
dest.writeByteArray(addr.getAddress());
}
dest.writeTypedArray(routes, 0);
}
@Override
public int describeContents() {
return 0;
}
public static final Creator CREATOR = new Creator() {
@Override
public VpnConfiguration createFromParcel(Parcel source) {
return new VpnConfiguration(source);
}
@Override
public VpnConfiguration[] newArray(int size) {
return new VpnConfiguration[size];
}
};
}
================================================
FILE: app/src/main/res/drawable/ic_close_24dp.xml
================================================
================================================
FILE: app/src/main/res/drawable/ic_report_problem_24dp.xml
================================================
================================================
FILE: app/src/main/res/drawable/ic_usb_24dp.xml
================================================
================================================
FILE: app/src/main/res/values/strings.xml
================================================
Gnirehtet
Reverse tethering enabled
Disconnected from the relay server
Stop Gnirehtet
================================================
FILE: app/src/main/res/values/styles.xml
================================================
================================================
FILE: app/src/main/res/values-fr/strings.xml
================================================
Reverse tethering activé
Déconnecté du serveur relais
Arrêter Gnirehtet
================================================
FILE: app/src/test/java/com/genymobile/gnirehtet/TestIPPacketOutputSteam.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet;
import org.junit.Assert;
import org.junit.Test;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.Arrays;
@SuppressWarnings("checkstyle:MagicNumber")
public class TestIPPacketOutputSteam {
private ByteBuffer createMockPacket() {
ByteBuffer buffer = ByteBuffer.allocate(32);
writeMockPacketTo(buffer);
buffer.flip();
return buffer;
}
private void writeMockPacketTo(ByteBuffer buffer) {
buffer.put((byte) ((4 << 4) | 5)); // versionAndIHL
buffer.put((byte) 0); // ToS
buffer.putShort((short) 32); // total length 20 + 8 + 4
buffer.putInt(0); // IdFlagsFragmentOffset
buffer.put((byte) 0); // TTL
buffer.put((byte) 17); // protocol (UDP)
buffer.putShort((short) 0); // checksum
buffer.putInt(0x12345678); // source address
buffer.putInt(0x42424242); // destination address
buffer.putShort((short) 1234); // source port
buffer.putShort((short) 5678); // destination port
buffer.putShort((short) 12); // length
buffer.putShort((short) 0); // checksum
buffer.putInt(0x11223344); // payload
}
@Test
public void testSimplePacket() throws IOException {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
IPPacketOutputStream pos = new IPPacketOutputStream(bos);
byte[] rawPacket = createMockPacket().array();
pos.write(rawPacket, 0, 14);
Assert.assertEquals("Partial packet should not be written", 0, bos.size());
pos.write(rawPacket, 14, 14);
Assert.assertEquals("Partial packet should not be written", 0, bos.size());
pos.write(rawPacket, 28, 4);
Assert.assertEquals("Complete packet should be written", 32, bos.size());
byte[] result = bos.toByteArray();
Assert.assertTrue("Resulting array must be identical", Arrays.equals(rawPacket, result));
}
@Test
public void testSeveralPacketsAtOnce() throws IOException {
class CapturingOutputStream extends ByteArrayOutputStream {
private int packetCount;
@Override
public void write(byte[] b, int off, int len) {
super.write(b, off, len);
++packetCount;
}
}
CapturingOutputStream cos = new CapturingOutputStream();
IPPacketOutputStream pos = new IPPacketOutputStream(cos);
ByteBuffer buffer = ByteBuffer.allocate(3 * 32);
for (int i = 0; i < 3; ++i) {
writeMockPacketTo(buffer);
}
byte[] rawPackets = buffer.array();
pos.write(rawPackets, 0, 70); // 2 packets + 6 bytes
Assert.assertEquals("Exactly 2 packets should have been written", 64, cos.size());
Assert.assertEquals("Packets should be written individually to the target", 2, cos.packetCount);
pos.write(rawPackets, 70, 26);
Assert.assertEquals("Exactly 3 packets should have been written", 96, cos.size());
Assert.assertEquals("Packets should be written individually to the target", 3, cos.packetCount);
}
}
================================================
FILE: build.gradle
================================================
// Top-level build file where you can add configuration options common to all sub-projects/modules.
ext {
compileSdkVersion = 28
buildToolsVersion = "28.0.3"
}
buildscript {
repositories {
jcenter()
google()
}
dependencies {
classpath 'com.android.tools.build:gradle:3.5.0'
// NOTE: Do not place your application dependencies here; they belong
// in the individual module build.gradle files
}
}
allprojects {
repositories {
jcenter()
google()
}
}
task clean(type: Delete) {
delete rootProject.buildDir
}
task debugJava(dependsOn: [':app:assembleDebug', ':relay-java:assembleDebug'])
task releaseJava(dependsOn: [':app:assembleRelease', ':relay-java:assembleRelease'])
task debugRust(dependsOn: [':app:assembleDebug', ':relay-rust:debug'])
task releaseRust(dependsOn: [':app:assembleRelease', ':relay-rust:release'])
task releaseRustWindows(dependsOn: [':app:assembleRelease', 'relay-rust:releaseCrossToWindows'])
task debugAll(dependsOn: ['debugJava', 'debugRust'])
task releaseAll(dependsOn: ['releaseJava', 'releaseRust'])
task checkJava(dependsOn: [':app:check', ':relay-java:check'])
task checkRust(dependsOn: ['app:check', ':relay-rust:check'])
task checkAll(dependsOn: ['checkJava', 'checkRust'])
================================================
FILE: config/android-checkstyle.gradle
================================================
apply plugin: 'checkstyle'
check.dependsOn 'checkstyle'
checkstyle {
toolVersion = '6.19'
}
task checkstyle(type: Checkstyle) {
description = "Check Java style with Checkstyle"
configFile = rootProject.file("config/checkstyle/checkstyle.xml")
source = javaSources()
classpath = files()
ignoreFailures = true
}
def javaSources() {
def files = []
android.sourceSets.each { sourceSet ->
sourceSet.java.each { javaSource ->
javaSource.getSrcDirs().each {
if (it.exists()) {
files.add(it)
}
}
}
}
return files
}
================================================
FILE: config/android-signing.gradle
================================================
if (project.hasProperty("RELEASE_STORE_FILE")) {
android.signingConfigs {
release {
// to be defined in gradle.properties
storeFile file(RELEASE_STORE_FILE)
storePassword RELEASE_STORE_PASSWORD
keyAlias RELEASE_KEY_ALIAS
keyPassword RELEASE_KEY_PASSWORD
}
}
android.buildTypes.release.signingConfig = android.signingConfigs.release
}
================================================
FILE: config/checkstyle/checkstyle.xml
================================================
================================================
FILE: config/java-checkstyle.gradle
================================================
apply plugin: 'checkstyle'
checkstyle {
toolVersion = '6.19'
configFile = rootProject.file("config/checkstyle/checkstyle.xml")
}
================================================
FILE: gradle/wrapper/gradle-wrapper.properties
================================================
#Sat Sep 07 21:43:49 CEST 2019
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-5.4.1-all.zip
================================================
FILE: gradle.properties
================================================
# Project-wide Gradle settings.
# IDE (e.g. Android Studio) users:
# Gradle settings configured through the IDE *will override*
# any settings specified in this file.
# For more details on how to configure your build environment visit
# http://www.gradle.org/docs/current/userguide/build_environment.html
# Specifies the JVM arguments used for the daemon process.
# The setting is particularly useful for tweaking memory settings.
org.gradle.jvmargs=-Xmx1536m
# When configured, Gradle will run in incubating parallel mode.
# This option should only be used with decoupled projects. More details, visit
# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
# org.gradle.parallel=true
================================================
FILE: gradlew
================================================
#!/usr/bin/env bash
##############################################################################
##
## Gradle start up script for UN*X
##
##############################################################################
# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
DEFAULT_JVM_OPTS=""
APP_NAME="Gradle"
APP_BASE_NAME=`basename "$0"`
# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD="maximum"
warn ( ) {
echo "$*"
}
die ( ) {
echo
echo "$*"
echo
exit 1
}
# OS specific support (must be 'true' or 'false').
cygwin=false
msys=false
darwin=false
case "`uname`" in
CYGWIN* )
cygwin=true
;;
Darwin* )
darwin=true
;;
MINGW* )
msys=true
;;
esac
# Attempt to set APP_HOME
# Resolve links: $0 may be a link
PRG="$0"
# Need this for relative symlinks.
while [ -h "$PRG" ] ; do
ls=`ls -ld "$PRG"`
link=`expr "$ls" : '.*-> \(.*\)$'`
if expr "$link" : '/.*' > /dev/null; then
PRG="$link"
else
PRG=`dirname "$PRG"`"/$link"
fi
done
SAVED="`pwd`"
cd "`dirname \"$PRG\"`/" >/dev/null
APP_HOME="`pwd -P`"
cd "$SAVED" >/dev/null
CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
# Determine the Java command to use to start the JVM.
if [ -n "$JAVA_HOME" ] ; then
if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
# IBM's JDK on AIX uses strange locations for the executables
JAVACMD="$JAVA_HOME/jre/sh/java"
else
JAVACMD="$JAVA_HOME/bin/java"
fi
if [ ! -x "$JAVACMD" ] ; then
die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
else
JAVACMD="java"
which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
# Increase the maximum file descriptors if we can.
if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
MAX_FD_LIMIT=`ulimit -H -n`
if [ $? -eq 0 ] ; then
if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
MAX_FD="$MAX_FD_LIMIT"
fi
ulimit -n $MAX_FD
if [ $? -ne 0 ] ; then
warn "Could not set maximum file descriptor limit: $MAX_FD"
fi
else
warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
fi
fi
# For Darwin, add options to specify how the application appears in the dock
if $darwin; then
GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
fi
# For Cygwin, switch paths to Windows format before running java
if $cygwin ; then
APP_HOME=`cygpath --path --mixed "$APP_HOME"`
CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
JAVACMD=`cygpath --unix "$JAVACMD"`
# We build the pattern for arguments to be converted via cygpath
ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
SEP=""
for dir in $ROOTDIRSRAW ; do
ROOTDIRS="$ROOTDIRS$SEP$dir"
SEP="|"
done
OURCYGPATTERN="(^($ROOTDIRS))"
# Add a user-defined pattern to the cygpath arguments
if [ "$GRADLE_CYGPATTERN" != "" ] ; then
OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
fi
# Now convert the arguments - kludge to limit ourselves to /bin/sh
i=0
for arg in "$@" ; do
CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
else
eval `echo args$i`="\"$arg\""
fi
i=$((i+1))
done
case $i in
(0) set -- ;;
(1) set -- "$args0" ;;
(2) set -- "$args0" "$args1" ;;
(3) set -- "$args0" "$args1" "$args2" ;;
(4) set -- "$args0" "$args1" "$args2" "$args3" ;;
(5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
(6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
(7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
(8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
(9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
esac
fi
# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
function splitJvmOpts() {
JVM_OPTS=("$@")
}
eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
================================================
FILE: gradlew.bat
================================================
@if "%DEBUG%" == "" @echo off
@rem ##########################################################################
@rem
@rem Gradle startup script for Windows
@rem
@rem ##########################################################################
@rem Set local scope for the variables with windows NT shell
if "%OS%"=="Windows_NT" setlocal
@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
set DEFAULT_JVM_OPTS=
set DIRNAME=%~dp0
if "%DIRNAME%" == "" set DIRNAME=.
set APP_BASE_NAME=%~n0
set APP_HOME=%DIRNAME%
@rem Find java.exe
if defined JAVA_HOME goto findJavaFromJavaHome
set JAVA_EXE=java.exe
%JAVA_EXE% -version >NUL 2>&1
if "%ERRORLEVEL%" == "0" goto init
echo.
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:findJavaFromJavaHome
set JAVA_HOME=%JAVA_HOME:"=%
set JAVA_EXE=%JAVA_HOME%/bin/java.exe
if exist "%JAVA_EXE%" goto init
echo.
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:init
@rem Get command-line arguments, handling Windowz variants
if not "%OS%" == "Windows_NT" goto win9xME_args
if "%@eval[2+2]" == "4" goto 4NT_args
:win9xME_args
@rem Slurp the command line arguments.
set CMD_LINE_ARGS=
set _SKIP=2
:win9xME_args_slurp
if "x%~1" == "x" goto execute
set CMD_LINE_ARGS=%*
goto execute
:4NT_args
@rem Get arguments from the 4NT Shell from JP Software
set CMD_LINE_ARGS=%$
:execute
@rem Setup the command line
set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
@rem Execute Gradle
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
:end
@rem End local scope for the variables with windows NT shell
if "%ERRORLEVEL%"=="0" goto mainEnd
:fail
rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
rem the _cmd.exe /c_ return code!
if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
exit /b 1
:mainEnd
if "%OS%"=="Windows_NT" endlocal
:omega
================================================
FILE: relay-java/build.gradle
================================================
apply plugin: 'application'
mainClassName = 'com.genymobile.gnirehtet.Main'
dependencies {
compile fileTree(dir: 'libs', include: ['*.jar'])
testCompile 'junit:junit:4.12'
}
jar {
manifest {
attributes(
'Main-Class': mainClassName
)
}
baseName 'gnirehtet'
}
task assembleDebug(dependsOn: 'jar')
task assembleRelease(dependsOn: ['build', 'jar'])
apply from: "$project.rootDir/config/java-checkstyle.gradle"
test {
// to log using System.out.println(…) in tests
testLogging.showStandardStreams = true
}
================================================
FILE: relay-java/scripts/gnirehtet
================================================
#!/bin/bash
java -jar gnirehtet.jar "$@"
================================================
FILE: relay-java/scripts/gnirehtet-run.cmd
================================================
@java -jar gnirehtet.jar run
@pause
================================================
FILE: relay-java/scripts/gnirehtet.cmd
================================================
@java -jar gnirehtet.jar %*
================================================
FILE: relay-java/src/main/java/com/genymobile/gnirehtet/AdbMonitor.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet;
import com.genymobile.gnirehtet.relay.Log;
import java.io.EOFException;
import java.io.IOException;
import java.net.Inet4Address;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ByteChannel;
import java.nio.channels.ReadableByteChannel;
import java.nio.channels.SocketChannel;
import java.nio.channels.WritableByteChannel;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
public class AdbMonitor {
public interface AdbDevicesCallback {
void onNewDeviceConnected(String serial);
}
private static final String TAG = AdbMonitor.class.getSimpleName();
private static final int ADBD_PORT = 5037;
private static final String TRACK_DEVICES_REQUEST = "0012host:track-devices";
private static final int BUFFER_SIZE = 1024;
private static final int LENGTH_FIELD_SIZE = 4;
private static final int OKAY_SIZE = 4;
private static final long RETRY_DELAY_ADB_DAEMON_OK = 1000;
private static final long RETRY_DELAY_ADB_DAEMON_KO = 5000;
private List connectedDevices = new ArrayList<>();
private AdbDevicesCallback callback;
private static final byte[] BUFFER = new byte[BUFFER_SIZE]; // used only locally to avoid allocations, so static is ok
private final ByteBuffer socketBuffer = ByteBuffer.allocate(BUFFER_SIZE);
public AdbMonitor(AdbDevicesCallback callback) {
this.callback = callback;
}
public void monitor() {
while (true) {
try {
trackDevices();
} catch (Exception e) {
Log.e(TAG, "Failed to monitor adb devices", e);
repairAdbDaemon();
}
}
}
private void trackDevices() throws IOException {
SocketChannel socketChannel = SocketChannel.open();
try {
socketChannel.connect(new InetSocketAddress(Inet4Address.getLoopbackAddress(), ADBD_PORT));
trackDevicesOnChannel(socketChannel);
} finally {
socketChannel.close();
}
}
private void trackDevicesOnChannel(ByteChannel channel) throws IOException {
socketBuffer.clear();
writeRequest(channel, TRACK_DEVICES_REQUEST);
// the daemon initially sends "OKAY" if it understands the request
if (!consumeOkay(channel)) {
return;
}
while (true) {
String packet = nextPacket(channel);
handlePacket(packet);
}
}
private static void writeRequest(WritableByteChannel channel, String request) throws IOException {
ByteBuffer requestBuffer = ByteBuffer.wrap(request.getBytes(StandardCharsets.US_ASCII));
channel.write(requestBuffer);
}
private boolean consumeOkay(ReadableByteChannel channel) throws IOException {
while (channel.read(socketBuffer) != -1) {
if (socketBuffer.position() < OKAY_SIZE) {
// not enough data
continue;
}
socketBuffer.flip();
socketBuffer.get(BUFFER, 0, OKAY_SIZE);
socketBuffer.compact();
socketBuffer.flip();
String text = new String(BUFFER, 0, OKAY_SIZE, StandardCharsets.US_ASCII);
return "OKAY".equals(text);
}
return false;
}
private String nextPacket(ReadableByteChannel channel) throws IOException {
String packet;
while ((packet = readPacket(socketBuffer)) == null) {
// need more data
fillBufferFrom(channel);
}
return packet;
}
private void fillBufferFrom(ReadableByteChannel channel) throws IOException {
socketBuffer.compact();
int r;
if (channel.read(socketBuffer) == -1) {
throw new EOFException("ADB daemon closed the track-devices connexion");
}
socketBuffer.flip();
}
static String readPacket(ByteBuffer input) {
if (input.remaining() < LENGTH_FIELD_SIZE) {
return null;
}
// each packet contains 4 bytes representing the String length in hexa, followed by a list of device states, one per line;
// each line contains: the device serial, `\t', the state, '\n'
// for example: "00360123456789abcdef\tdevice\nfedcba9876543210\tunauthorized\n":
// - 0036 indicates that the data is 0x36 (54) bytes length
// - the device with serial 0123456789abcdef is connected
// - the device with serial fedcba9876543210 is unauthorized
input.get(BUFFER, 0, LENGTH_FIELD_SIZE);
int length = parseLength(BUFFER);
if (length > BUFFER.length) {
throw new IllegalArgumentException("Packet size should not be that big: " + length);
}
if (input.remaining() < length) {
// not enough data
input.rewind();
return null;
}
input.get(BUFFER, 0, length);
return new String(BUFFER, 0, length, StandardCharsets.UTF_8);
}
void handlePacket(String packet) {
List currentConnectedDevices = parseConnectedDevices(packet);
for (String serial : currentConnectedDevices) {
if (!connectedDevices.contains(serial)) {
callback.onNewDeviceConnected(serial);
}
}
connectedDevices = currentConnectedDevices;
}
private static List parseConnectedDevices(String packet) {
List list = new ArrayList<>();
for (String line : packet.split("\\n")) {
String[] tokens = line.split("\\s+");
if (tokens.length == 2) {
String state = tokens[1];
if ("device".equals(state)) {
String serial = tokens[0];
list.add(serial);
}
}
}
return list;
}
@SuppressWarnings("checkstyle:MagicNumber")
private static int parseLength(byte[] data) {
if (data.length < LENGTH_FIELD_SIZE) {
throw new IllegalArgumentException("Length field must be at least 4 bytes length");
}
int result = 0;
for (int i = 0; i < LENGTH_FIELD_SIZE; ++i) {
char c = (char) data[i];
result = (result << 4) + Character.digit(c, 0x10);
}
return result;
}
private static void repairAdbDaemon() {
if (startAdbDaemon()) {
sleep(RETRY_DELAY_ADB_DAEMON_OK);
} else {
sleep(RETRY_DELAY_ADB_DAEMON_KO);
}
}
private static boolean startAdbDaemon() {
Log.i(TAG, "Restarting adb deamon");
try {
Process process = new ProcessBuilder("adb", "start-server")
.redirectOutput(ProcessBuilder.Redirect.INHERIT)
.redirectError(ProcessBuilder.Redirect.INHERIT).start();
int exitCode = process.waitFor();
if (exitCode != 0) {
Log.e(TAG, "Could not restart adb daemon (exited on error)");
return false;
}
return true;
} catch (InterruptedException | IOException e) {
Log.e(TAG, "Could not restart adb daemon", e);
return false;
}
}
private static void sleep(long delay) {
try {
Thread.sleep(delay);
} catch (InterruptedException e) {
// should never happen
}
}
}
================================================
FILE: relay-java/src/main/java/com/genymobile/gnirehtet/CommandLineArguments.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet;
/**
* Simple specific command-line arguments parser.
*/
@SuppressWarnings("checkstyle:MagicNumber")
public class CommandLineArguments {
public static final int PARAM_NONE = 0;
public static final int PARAM_SERIAL = 1;
public static final int PARAM_DNS_SERVER = 1 << 1;
public static final int PARAM_ROUTES = 1 << 2;
public static final int PARAM_PORT = 1 << 3;
public static final int DEFAULT_PORT = 31416;
private int port;
private String serial;
private String dnsServers;
private String routes;
public static CommandLineArguments parse(int acceptedParameters, String... args) {
CommandLineArguments arguments = new CommandLineArguments();
for (int i = 0; i < args.length; ++i) {
String arg = args[i];
if ((acceptedParameters & PARAM_DNS_SERVER) != 0 && "-d".equals(arg)) {
if (arguments.dnsServers != null) {
throw new IllegalArgumentException("DNS servers already set");
}
if (i == args.length - 1) {
throw new IllegalArgumentException("Missing -d parameter");
}
arguments.dnsServers = args[i + 1];
++i; // consume the -d parameter
} else if ((acceptedParameters & PARAM_ROUTES) != 0 && "-r".equals(arg)) {
if (arguments.routes != null) {
throw new IllegalArgumentException("Routes already set");
}
if (i == args.length - 1) {
throw new IllegalArgumentException("Missing -r parameter");
}
arguments.routes = args[i + 1];
++i; // consume the -r parameter
} else if ((acceptedParameters & PARAM_PORT) != 0 && "-p".equals(arg)) {
if (arguments.port != 0) {
throw new IllegalArgumentException("Port already set");
}
if (i == args.length - 1) {
throw new IllegalArgumentException("Missing -p parameter");
}
arguments.port = Integer.parseInt(args[i + 1]);
if (arguments.port <= 0 || arguments.port >= 65536) {
throw new IllegalArgumentException("Invalid port: " + arguments.port);
}
++i;
} else if ((acceptedParameters & PARAM_SERIAL) != 0 && arguments.serial == null) {
arguments.serial = arg;
} else {
throw new IllegalArgumentException("Unexpected argument: \"" + arg + "\"");
}
}
if (arguments.port == 0) {
arguments.port = DEFAULT_PORT;
}
return arguments;
}
public String getSerial() {
return serial;
}
public String getDnsServers() {
return dnsServers;
}
public String getRoutes() {
return routes;
}
public int getPort() {
return port;
}
}
================================================
FILE: relay-java/src/main/java/com/genymobile/gnirehtet/Main.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet;
import com.genymobile.gnirehtet.relay.CommandExecutionException;
import com.genymobile.gnirehtet.relay.Log;
import com.genymobile.gnirehtet.relay.Relay;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public final class Main {
private static final String TAG = "Gnirehtet";
private static final String NL = System.lineSeparator();
private static final String REQUIRED_APK_VERSION_CODE = "9";
private Main() {
// not instantiable
}
private static String getAdbPath() {
String adb = System.getenv("ADB");
return adb != null ? adb : "adb";
}
private static String getApkPath() {
String apk = System.getenv("GNIREHTET_APK");
return apk != null ? apk : "gnirehtet.apk";
}
enum Command {
INSTALL("install", CommandLineArguments.PARAM_SERIAL) {
@Override
String getDescription() {
return "Install the client on the Android device and exit.\n"
+ "If several devices are connected via adb, then serial must be\n"
+ "specified.";
}
@Override
void execute(CommandLineArguments args) throws Exception {
cmdInstall(args.getSerial());
}
},
UNINSTALL("uninstall", CommandLineArguments.PARAM_SERIAL) {
@Override
String getDescription() {
return "Uninstall the client from the Android device and exit.\n"
+ "If several devices are connected via adb, then serial must be\n"
+ "specified.";
}
@Override
void execute(CommandLineArguments args) throws Exception {
cmdUninstall(args.getSerial());
}
},
REINSTALL("reinstall", CommandLineArguments.PARAM_SERIAL) {
@Override
String getDescription() {
return "Uninstall then install.";
}
@Override
void execute(CommandLineArguments args) throws Exception {
cmdReinstall(args.getSerial());
}
},
RUN("run", CommandLineArguments.PARAM_SERIAL | CommandLineArguments.PARAM_DNS_SERVER | CommandLineArguments.PARAM_ROUTES
| CommandLineArguments.PARAM_PORT) {
@Override
String getDescription() {
return "Enable reverse tethering for exactly one device:\n"
+ " - install the client if necessary;\n"
+ " - start the client;\n"
+ " - start the relay server;\n"
+ " - on Ctrl+C, stop both the relay server and the client.";
}
@Override
void execute(CommandLineArguments args) throws Exception {
cmdRun(args.getSerial(), args.getDnsServers(), args.getRoutes(), args.getPort());
}
},
AUTORUN("autorun", CommandLineArguments.PARAM_DNS_SERVER | CommandLineArguments.PARAM_ROUTES | CommandLineArguments.PARAM_PORT) {
@Override
String getDescription() {
return "Enable reverse tethering for all devices:\n"
+ " - monitor devices and start clients (autostart);\n"
+ " - start the relay server.";
}
@Override
void execute(CommandLineArguments args) throws Exception {
cmdAutorun(args.getDnsServers(), args.getRoutes(), args.getPort());
}
},
START("start", CommandLineArguments.PARAM_SERIAL | CommandLineArguments.PARAM_DNS_SERVER | CommandLineArguments.PARAM_ROUTES
| CommandLineArguments.PARAM_PORT) {
@Override
String getDescription() {
return "Start a client on the Android device and exit.\n"
+ "If several devices are connected via adb, then serial must be\n"
+ "specified.\n"
+ "If -d is given, then make the Android device use the specified\n"
+ "DNS server(s). Otherwise, use 8.8.8.8 (Google public DNS).\n"
+ "If -r is given, then only reverse tether the specified routes.\n"
+ "If -p is given, then make the relay server listen on the specified\n"
+ "port. Otherwise, use port 31416.\n"
+ "Otherwise, use 0.0.0.0/0 (redirect the whole traffic).\n"
+ "If the client is already started, then do nothing, and ignore\n"
+ "the other parameters.\n"
+ "10.0.2.2 is mapped to the host 'localhost'.";
}
@Override
void execute(CommandLineArguments args) throws Exception {
cmdStart(args.getSerial(), args.getDnsServers(), args.getRoutes(), args.getPort());
}
},
AUTOSTART("autostart", CommandLineArguments.PARAM_DNS_SERVER | CommandLineArguments.PARAM_ROUTES | CommandLineArguments.PARAM_PORT) {
@Override
String getDescription() {
return "Listen for device connexions and start a client on every detected\n"
+ "device.\n"
+ "Accept the same parameters as the start command (excluding the\n"
+ "serial, which will be taken from the detected device).";
}
@Override
void execute(CommandLineArguments args) throws Exception {
cmdAutostart(args.getDnsServers(), args.getRoutes(), args.getPort());
}
},
STOP("stop", CommandLineArguments.PARAM_SERIAL) {
@Override
String getDescription() {
return "Stop the client on the Android device and exit.\n"
+ "If several devices are connected via adb, then serial must be\n"
+ "specified.";
}
@Override
void execute(CommandLineArguments args) throws Exception {
cmdStop(args.getSerial());
}
},
RESTART("restart", CommandLineArguments.PARAM_SERIAL | CommandLineArguments.PARAM_DNS_SERVER | CommandLineArguments.PARAM_ROUTES
| CommandLineArguments.PARAM_PORT) {
@Override
String getDescription() {
return "Stop then start.";
}
@Override
void execute(CommandLineArguments args) throws Exception {
cmdRestart(args.getSerial(), args.getDnsServers(), args.getRoutes(), args.getPort());
}
},
TUNNEL("tunnel", CommandLineArguments.PARAM_SERIAL | CommandLineArguments.PARAM_PORT) {
@Override
String getDescription() {
return "Set up the 'adb reverse' tunnel.\n"
+ "If a device is unplugged then plugged back while gnirehtet is\n"
+ "active, resetting the tunnel is sufficient to get the\n"
+ "connection back.";
}
@Override
void execute(CommandLineArguments args) throws Exception {
cmdTunnel(args.getSerial(), args.getPort());
}
},
RELAY("relay", CommandLineArguments.PARAM_PORT) {
@Override
String getDescription() {
return "Start the relay server in the current terminal.";
}
@Override
void execute(CommandLineArguments args) throws Exception {
cmdRelay(args.getPort());
}
};
private String command;
private int acceptedParameters;
Command(String command, int acceptedParameters) {
this.command = command;
this.acceptedParameters = acceptedParameters;
}
abstract String getDescription();
abstract void execute(CommandLineArguments args) throws Exception;
}
private static void cmdInstall(String serial) throws InterruptedException, IOException, CommandExecutionException {
Log.i(TAG, "Installing gnirehtet client...");
execAdb(serial, "install", "-r", getApkPath());
}
private static void cmdUninstall(String serial) throws InterruptedException, IOException, CommandExecutionException {
Log.i(TAG, "Uninstalling gnirehtet client...");
execAdb(serial, "uninstall", "com.genymobile.gnirehtet");
}
private static void cmdReinstall(String serial) throws InterruptedException, IOException, CommandExecutionException {
cmdUninstall(serial);
cmdInstall(serial);
}
private static void cmdRun(String serial, String dnsServers, String routes, int port) throws IOException {
// start in parallel so that the relay server is ready when the client connects
asyncStart(serial, dnsServers, routes, port);
Runtime.getRuntime().addShutdownHook(new Thread(() -> {
// executed on Ctrl+C
try {
cmdStop(serial);
} catch (Exception e) {
Log.e(TAG, "Cannot stop client", e);
}
}));
cmdRelay(port);
}
private static void cmdAutorun(final String dnsServers, final String routes, int port) throws IOException {
new Thread(() -> {
try {
cmdAutostart(dnsServers, routes, port);
} catch (Exception e) {
Log.e(TAG, "Cannot auto start clients", e);
}
}).start();
cmdRelay(port);
}
@SuppressWarnings("checkstyle:MagicNumber")
private static void cmdStart(String serial, String dnsServers, String routes, int port) throws InterruptedException, IOException,
CommandExecutionException {
if (mustInstallClient(serial)) {
cmdInstall(serial);
// wait a bit after the app is installed so that intent actions are correctly registered
Thread.sleep(500); // ms
}
Log.i(TAG, "Starting client...");
cmdTunnel(serial, port);
List cmd = new ArrayList<>();
Collections.addAll(cmd, "shell", "am", "start", "-a", "com.genymobile.gnirehtet.START", "-n",
"com.genymobile.gnirehtet/.GnirehtetActivity");
if (dnsServers != null) {
Collections.addAll(cmd, "--esa", "dnsServers", dnsServers);
}
if (routes != null) {
Collections.addAll(cmd, "--esa", "routes", routes);
}
execAdb(serial, cmd);
}
private static void cmdAutostart(final String dnsServers, final String routes, int port) {
AdbMonitor adbMonitor = new AdbMonitor((serial) -> {
asyncStart(serial, dnsServers, routes, port);
});
adbMonitor.monitor();
}
private static void cmdStop(String serial) throws InterruptedException, IOException, CommandExecutionException {
Log.i(TAG, "Stopping client...");
execAdb(serial, "shell", "am", "start", "-a", "com.genymobile.gnirehtet.STOP", "-n",
"com.genymobile.gnirehtet/.GnirehtetActivity");
}
private static void cmdRestart(String serial, String dnsServers, String routes, int port) throws InterruptedException, IOException,
CommandExecutionException {
cmdStop(serial);
cmdStart(serial, dnsServers, routes, port);
}
private static void cmdTunnel(String serial, int port) throws InterruptedException, IOException, CommandExecutionException {
execAdb(serial, "reverse", "localabstract:gnirehtet", "tcp:" + port);
}
private static void cmdRelay(int port) throws IOException {
Log.i(TAG, "Starting relay server on port " + port + "...");
new Relay(port).run();
}
private static void asyncStart(String serial, String dnsServers, String routes, int port) {
new Thread(() -> {
try {
cmdStart(serial, dnsServers, routes, port);
} catch (Exception e) {
Log.e(TAG, "Cannot start client", e);
}
}).start();
}
private static void execAdb(String serial, String... adbArgs) throws InterruptedException, IOException, CommandExecutionException {
execSync(createAdbCommand(serial, adbArgs));
}
private static List createAdbCommand(String serial, String... adbArgs) {
List command = new ArrayList<>();
command.add(getAdbPath());
if (serial != null) {
command.add("-s");
command.add(serial);
}
Collections.addAll(command, adbArgs);
return command;
}
private static void execAdb(String serial, List adbArgList) throws InterruptedException, IOException, CommandExecutionException {
String[] adbArgs = adbArgList.toArray(new String[adbArgList.size()]);
execAdb(serial, adbArgs);
}
private static void execSync(List command) throws InterruptedException, IOException, CommandExecutionException {
Log.d(TAG, "Execute: " + command);
ProcessBuilder processBuilder = new ProcessBuilder(command);
processBuilder.redirectOutput(ProcessBuilder.Redirect.INHERIT).redirectError(ProcessBuilder.Redirect.INHERIT);
Process process = processBuilder.start();
int exitCode = process.waitFor();
if (exitCode != 0) {
throw new CommandExecutionException(command, exitCode);
}
}
private static boolean mustInstallClient(String serial) throws InterruptedException, IOException, CommandExecutionException {
Log.i(TAG, "Checking gnirehtet client...");
List command = createAdbCommand(serial, "shell", "dumpsys", "package", "com.genymobile.gnirehtet");
Log.d(TAG, "Execute: " + command);
Process process = new ProcessBuilder(command).start();
try {
Scanner scanner = new Scanner(process.getInputStream());
// read the versionCode of the installed package
Pattern pattern = Pattern.compile("^ versionCode=(\\p{Digit}+).*");
while (scanner.hasNextLine()) {
Matcher matcher = pattern.matcher(scanner.nextLine());
if (matcher.matches()) {
String installedVersionCode = matcher.group(1);
return !REQUIRED_APK_VERSION_CODE.equals(installedVersionCode);
}
}
} finally {
int exitCode = process.waitFor();
if (exitCode != 0) {
// Overwrite any pending exception, the command just failed
throw new CommandExecutionException(command, exitCode);
}
}
return true;
}
private static void printUsage() {
StringBuilder builder = new StringBuilder("Syntax: gnirehtet (");
Command[] commands = Command.values();
for (int i = 0; i < commands.length; ++i) {
if (i != 0) {
builder.append('|');
}
builder.append(commands[i].command);
}
builder.append(") ...").append(NL);
for (Command command : commands) {
builder.append(NL);
appendCommandUsage(builder, command);
}
System.err.print(builder.toString());
}
private static void appendCommandUsage(StringBuilder builder, Command command) {
builder.append(" gnirehtet ").append(command.command);
if ((command.acceptedParameters & CommandLineArguments.PARAM_SERIAL) != 0) {
builder.append(" [serial]");
}
if ((command.acceptedParameters & CommandLineArguments.PARAM_DNS_SERVER) != 0) {
builder.append(" [-d DNS[,DNS2,...]]");
}
if ((command.acceptedParameters & CommandLineArguments.PARAM_PORT) != 0) {
builder.append(" [-p PORT]");
}
if ((command.acceptedParameters & CommandLineArguments.PARAM_ROUTES) != 0) {
builder.append(" [-r ROUTE[,ROUTE2,...]]");
}
builder.append(NL);
String[] descLines = command.getDescription().split("\n");
for (String descLine : descLines) {
builder.append(" ").append(descLine).append(NL);
}
}
private static void printCommandUsage(Command command) {
StringBuilder builder = new StringBuilder();
appendCommandUsage(builder, command);
System.err.print(builder.toString());
}
public static void main(String... args) throws Exception {
if (args.length == 0) {
printUsage();
return;
}
String cmd = args[0];
for (Command command : Command.values()) {
if (cmd.equals(command.command)) {
// forget args[0] containing the command name
String[] commandArgs = Arrays.copyOfRange(args, 1, args.length);
CommandLineArguments arguments;
try {
arguments = CommandLineArguments.parse(command.acceptedParameters, commandArgs);
} catch (IllegalArgumentException e) {
Log.e(TAG, e.getMessage());
printCommandUsage(command);
return;
}
command.execute(arguments);
return;
}
}
if ("rt".equals(cmd)) {
Log.e(TAG, "The 'rt' command has been renamed to 'run'. Try 'gnirehtet run' instead.");
printCommandUsage(Command.RUN);
} else {
Log.e(TAG, "Unknown command: " + cmd);
printUsage();
}
}
}
================================================
FILE: relay-java/src/main/java/com/genymobile/gnirehtet/relay/AbstractConnection.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
import java.net.InetAddress;
import java.net.InetSocketAddress;
public abstract class AbstractConnection implements Connection {
private static final int LOCALHOST_FORWARD = 0x0a000202; // 10.0.2.2 must be forwarded to localhost
private final ConnectionId id;
private final Client client;
protected AbstractConnection(ConnectionId id, Client client) {
this.id = id;
this.client = client;
}
@Override
public ConnectionId getId() {
return id;
}
protected void close() {
disconnect();
client.getRouter().remove(this);
}
protected void consume(PacketSource source) {
client.consume(source);
}
protected boolean sendToClient(IPv4Packet packet) {
return client.sendToClient(packet);
}
private static InetAddress getRewrittenAddress(int ip) {
return ip == LOCALHOST_FORWARD ? InetAddress.getLoopbackAddress() : Net.toInetAddress(ip);
}
/**
* Get destination, rewritten to {@code localhost} if it was {@code 10.0.2.2}.
*
* @return Destination to connect to.
*/
protected InetSocketAddress getRewrittenDestination() {
int destIp = id.getDestinationIp();
int port = id.getDestinationPort();
return new InetSocketAddress(getRewrittenAddress(destIp), port);
}
public void logv(String tag, String message, Throwable e) {
Log.v(tag, id + " " + message);
}
public void logv(String tag, String message) {
logv(tag, message, null);
}
public void logd(String tag, String message, Throwable e) {
Log.d(tag, id + " " + message);
}
public void logd(String tag, String message) {
logd(tag, message, null);
}
public void logi(String tag, String message, Throwable e) {
Log.i(tag, id + " " + message);
}
public void logi(String tag, String message) {
logi(tag, message, null);
}
public void logw(String tag, String message, Throwable e) {
Log.w(tag, id + " " + message);
}
public void logw(String tag, String message) {
logw(tag, message, null);
}
public void loge(String tag, String message, Throwable e) {
Log.e(tag, id + " " + message);
}
public void loge(String tag, String message) {
loge(tag, message, null);
}
}
================================================
FILE: relay-java/src/main/java/com/genymobile/gnirehtet/relay/Binary.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
import java.nio.ByteBuffer;
@SuppressWarnings("checkstyle:MagicNumber")
public final class Binary {
private static final int MAX_STRING_PACKET_SIZE = 20;
private Binary() {
// not instantiable
}
public static String buildPacketString(byte[] data, int offset, int len) {
int limit = Math.min(MAX_STRING_PACKET_SIZE, len);
StringBuilder builder = new StringBuilder();
builder.append('[').append(len).append(" bytes] ");
for (int i = 0; i < limit; ++i) {
if (i != 0) {
String sep = i % 4 == 0 ? " " : " ";
builder.append(sep);
}
builder.append(String.format("%02X", data[offset + i] & 0xff));
}
if (limit < len) {
builder.append(" ... +").append(len - limit).append(" bytes");
}
return builder.toString();
}
public static String buildPacketString(ByteBuffer buffer) {
return buildPacketString(buffer.array(), buffer.arrayOffset() + buffer.position(), buffer.remaining());
}
public static ByteBuffer copy(ByteBuffer buffer) {
buffer.rewind();
ByteBuffer result = ByteBuffer.allocate(buffer.remaining());
result.put(buffer);
buffer.rewind();
result.flip();
return result;
}
public static ByteBuffer slice(ByteBuffer buffer, int offset, int length) {
// save
int position = buffer.position();
int limit = buffer.limit();
// slice
buffer.limit(offset + length).position(offset);
ByteBuffer result = buffer.slice();
// restore
buffer.limit(limit).position(position);
return result;
}
}
================================================
FILE: relay-java/src/main/java/com/genymobile/gnirehtet/relay/Client.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Client {
private static final String TAG = Client.class.getSimpleName();
private static int nextId = 0;
private final int id;
private final SocketChannel clientChannel;
private final SelectionKey selectionKey;
private final CloseListener closeListener;
private int interests;
private final IPv4PacketBuffer clientToNetwork = new IPv4PacketBuffer();
private final StreamBuffer networkToClient = new StreamBuffer(16 * IPv4Packet.MAX_PACKET_LENGTH);
private final Router router;
private final List pendingPacketSources = new ArrayList<>();
// store the remaining bytes of "id" to send to the client before relaying any data
private ByteBuffer pendingIdBuffer;
public Client(Selector selector, SocketChannel clientChannel, CloseListener closeListener) throws ClosedChannelException {
id = nextId++;
this.clientChannel = clientChannel;
router = new Router(this, selector);
pendingIdBuffer = createIntBuffer(id);
SelectionHandler selectionHandler = (selectionKey) -> {
if (selectionKey.isValid() && selectionKey.isWritable()) {
processSend();
}
if (selectionKey.isValid() && selectionKey.isReadable()) {
processReceive();
}
if (selectionKey.isValid()) {
updateInterests();
}
};
// on start, we are interested only in writing (we must first send the client id)
interests = SelectionKey.OP_WRITE;
selectionKey = clientChannel.register(selector, interests, selectionHandler);
this.closeListener = closeListener;
}
private static ByteBuffer createIntBuffer(int value) {
final int intSize = 4;
ByteBuffer buffer = ByteBuffer.allocate(intSize);
buffer.putInt(value);
buffer.flip();
return buffer;
}
public int getId() {
return id;
}
public Router getRouter() {
return router;
}
private void processReceive() {
if (!read()) {
close();
return;
}
pushToNetwork();
}
private void processSend() {
if (mustSendId()) {
if (!sendId()) {
close();
}
return;
}
if (!write()) {
close();
return;
}
processPending();
}
private boolean read() {
try {
return clientToNetwork.readFrom(clientChannel) != -1;
} catch (IOException e) {
Log.e(TAG, "Cannot read", e);
return false;
}
}
private boolean write() {
try {
return networkToClient.writeTo(clientChannel) != -1;
} catch (IOException e) {
Log.e(TAG, "Cannot write", e);
return false;
}
}
private boolean mustSendId() {
return pendingIdBuffer != null && pendingIdBuffer.hasRemaining();
}
private boolean sendId() {
assert mustSendId();
try {
if (clientChannel.write(pendingIdBuffer) == -1) {
Log.w(TAG, "Cannot write client id #" + id + " (EOF)");
return false;
}
if (!pendingIdBuffer.hasRemaining()) {
// we don't need this buffer anymore, release it
Log.d(TAG, "Client id #" + id + " sent to client");
pendingIdBuffer = null;
}
return true;
} catch (IOException e) {
Log.e(TAG, "Cannot write client id #" + id, e);
return false;
}
}
private void pushToNetwork() {
IPv4Packet packet;
while ((packet = clientToNetwork.asIPv4Packet()) != null) {
router.sendToNetwork(packet);
clientToNetwork.next();
}
}
private void close() {
selectionKey.cancel();
try {
clientChannel.close();
} catch (IOException e) {
Log.e(TAG, "Cannot close client connection", e);
}
router.clear();
closeListener.onClosed(this);
}
private void updateInterests() {
int interestOps = SelectionKey.OP_READ; // we always want to read
if (!networkToClient.isEmpty()) {
interestOps |= SelectionKey.OP_WRITE;
}
if (interests != interestOps) {
// interests must be changed
interests = interestOps;
selectionKey.interestOps(interestOps);
}
}
public boolean sendToClient(IPv4Packet packet) {
if (networkToClient.remaining() < packet.getRawLength()) {
Log.w(TAG, "Client buffer full");
return false;
}
networkToClient.readFrom(packet.getRaw());
updateInterests();
return true;
}
public void consume(PacketSource source) {
IPv4Packet packet = source.get();
if (sendToClient(packet)) {
source.next();
return;
}
assert !pendingPacketSources.contains(source);
pendingPacketSources.add(source);
}
private void processPending() {
Iterator iterator = pendingPacketSources.iterator();
while (iterator.hasNext()) {
PacketSource packetSource = iterator.next();
IPv4Packet packet = packetSource.get();
if (sendToClient(packet)) {
packetSource.next();
Log.d(TAG, "Pending packet sent to client (" + packet.getRawLength() + ")");
iterator.remove();
} else {
Log.w(TAG, "Pending packet not sent to client (" + packet.getRawLength() + "), client buffer full again");
return;
}
}
}
public void cleanExpiredConnections() {
router.cleanExpiredConnections();
}
}
================================================
FILE: relay-java/src/main/java/com/genymobile/gnirehtet/relay/CloseListener.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
public interface CloseListener {
void onClosed(T object);
}
================================================
FILE: relay-java/src/main/java/com/genymobile/gnirehtet/relay/CommandExecutionException.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
import java.util.List;
public class CommandExecutionException extends Exception {
private List command;
private int exitCode;
public CommandExecutionException(List command, int exitCode) {
super(createMessage(command, exitCode));
this.command = command;
this.exitCode = exitCode;
}
private static String createMessage(List command, int exitCode) {
return "Command " + command + " returned with value " + exitCode;
}
public int getExitCode() {
return exitCode;
}
public List getCommand() {
return command;
}
}
================================================
FILE: relay-java/src/main/java/com/genymobile/gnirehtet/relay/Connection.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
public interface Connection {
ConnectionId getId();
void sendToNetwork(IPv4Packet packet);
void disconnect();
boolean isExpired();
}
================================================
FILE: relay-java/src/main/java/com/genymobile/gnirehtet/relay/ConnectionId.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
public class ConnectionId {
private final IPv4Header.Protocol protocol;
private final int sourceIp;
private final short sourcePort;
private final int destIp;
private final short destPort;
private final String idString;
public ConnectionId(IPv4Header.Protocol protocol, int sourceIp, short sourcePort, int destIp, short destPort) {
this.protocol = protocol;
this.sourceIp = sourceIp;
this.sourcePort = sourcePort;
this.destIp = destIp;
this.destPort = destPort;
// compute the String representation only once
idString = protocol + " " + Net.toString(sourceIp, sourcePort) + " -> " + Net.toString(destIp, destPort);
}
public IPv4Header.Protocol getProtocol() {
return protocol;
}
public int getSourceIp() {
return sourceIp;
}
public int getSourcePort() {
return Short.toUnsignedInt(sourcePort);
}
public int getDestinationIp() {
return destIp;
}
public int getDestinationPort() {
return Short.toUnsignedInt(destPort);
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
ConnectionId that = (ConnectionId) o;
return sourceIp == that.sourceIp
&& sourcePort == that.sourcePort
&& destIp == that.destIp
&& destPort == that.destPort
&& protocol == that.protocol;
}
@Override
public int hashCode() {
int result = protocol.hashCode();
result = 31 * result + sourceIp;
result = 31 * result + (int) sourcePort;
result = 31 * result + destIp;
result = 31 * result + (int) destPort;
return result;
}
@Override
public String toString() {
return idString;
}
public static ConnectionId from(IPv4Header ipv4Header, TransportHeader transportHeader) {
IPv4Header.Protocol protocol = ipv4Header.getProtocol();
int sourceAddress = ipv4Header.getSource();
short sourcePort = (short) transportHeader.getSourcePort();
int destinationAddress = ipv4Header.getDestination();
short destinationPort = (short) transportHeader.getDestinationPort();
return new ConnectionId(protocol, sourceAddress, sourcePort, destinationAddress, destinationPort);
}
}
================================================
FILE: relay-java/src/main/java/com/genymobile/gnirehtet/relay/DatagramBuffer.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.WritableByteChannel;
/**
* Circular buffer to store datagrams (preserving their boundaries).
*
*
* circularBufferLength
* |<------------------------->| extra space for storing the last datagram in one block
* +---------------------------+------+
* | | |
* |[D4] [ D1 ][ D2 ][ D3 ] |
* +---------------------------+------+
* ^ ^
* head tail
*
*/
@SuppressWarnings("checkstyle:MagicNumber")
public class DatagramBuffer {
private static final String TAG = DatagramBuffer.class.getSimpleName();
// every datagram is stored along with a header storing its length, on 16 bits
private static final int HEADER_LENGTH = 2;
private static final int MAX_DATAGRAM_LENGTH = 1 << 16;
private static final int MAX_BLOCK_LENGTH = HEADER_LENGTH + MAX_DATAGRAM_LENGTH;
private final byte[] data;
private final ByteBuffer wrapper;
private int head;
private int tail;
private final int circularBufferLength;
public DatagramBuffer(int capacity) {
data = new byte[capacity + MAX_BLOCK_LENGTH];
wrapper = ByteBuffer.wrap(data);
circularBufferLength = capacity + 1;
}
public boolean isEmpty() {
return head == tail;
}
public boolean hasEnoughSpaceFor(int datagramLength) {
if (head >= tail) {
// there is at least the extra space for storing 1 packet
return true;
}
int remaining = tail - head - 1; // 1 extra byte to distinguish empty vs full
return HEADER_LENGTH + datagramLength <= remaining;
}
public int capacity() {
return circularBufferLength - 1;
}
public boolean writeTo(WritableByteChannel channel) throws IOException {
int length = readLength();
wrapper.limit(tail + length).position(tail);
tail += length;
if (tail >= circularBufferLength) {
tail = 0;
}
int w = channel.write(wrapper);
if (w != length) {
Log.e(TAG, "Cannot write the whole datagram to the channel (only " + w + "/" + length + ")");
return false;
}
return true;
}
public boolean readFrom(ByteBuffer buffer) {
int length = buffer.remaining();
if (length > MAX_DATAGRAM_LENGTH) {
throw new IllegalArgumentException("Datagram length (" + buffer.remaining() + ") may not be greater than "
+ MAX_DATAGRAM_LENGTH + " bytes");
}
if (!hasEnoughSpaceFor(length)) {
return false;
}
writeLength(length);
buffer.get(data, head, length);
head += length;
if (head >= circularBufferLength) {
head = 0;
}
return true;
}
private void writeLength(int length) {
assert (length & ~0xffff) == 0 : "Length must be stored on 16 bits";
data[head++] = (byte) ((length >> 8) & 0xff);
data[head++] = (byte) (length & 0xff);
}
private int readLength() {
int length = ((data[tail] & 0xff) << 8) | (data[tail + 1] & 0xff);
tail += 2;
return length;
}
}
================================================
FILE: relay-java/src/main/java/com/genymobile/gnirehtet/relay/IPv4Header.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
import java.nio.ByteBuffer;
@SuppressWarnings("checkstyle:MagicNumber")
public class IPv4Header {
public enum Protocol {
TCP(6), UDP(17), OTHER(-1);
private final int number;
Protocol(int number) {
this.number = number;
}
int getNumber() {
return number;
}
static Protocol fromNumber(int number) {
if (number == TCP.number) {
return TCP;
}
if (number == UDP.number) {
return UDP;
}
return OTHER;
}
}
private static final int MIN_IPV4_HEADER_LENGTH = 20;
private ByteBuffer raw;
private byte version;
private int headerLength;
private int totalLength;
private Protocol protocol;
private int source;
private int destination;
public IPv4Header(ByteBuffer raw) {
assert raw.limit() >= MIN_IPV4_HEADER_LENGTH : "IPv4 headers length must be at least 20 bytes";
this.raw = raw;
byte versionAndIHL = raw.get(0);
version = (byte) (versionAndIHL >> 4);
byte ihl = (byte) (versionAndIHL & 0xf);
headerLength = ihl << 2;
raw.limit(headerLength);
totalLength = Short.toUnsignedInt(raw.getShort(2));
//raw.limit(); // by design
//assert totalLength == Binary.unsigned(raw.getShort(2)) : "Inconsistent packet length";
int protocolNumber = Short.toUnsignedInt(raw.get(9));
protocol = Protocol.fromNumber(protocolNumber);
source = raw.getInt(12);
destination = raw.getInt(16);
}
public boolean isSupported() {
return version == 4 && protocol != Protocol.OTHER;
}
public Protocol getProtocol() {
return protocol;
}
public int getHeaderLength() {
return headerLength;
}
public int getTotalLength() {
return totalLength;
}
public void setTotalLength(int totalLength) {
this.totalLength = totalLength;
// apply changes to raw
raw.putShort(2, (short) totalLength);
}
public int getSource() {
return source;
}
public int getDestination() {
return destination;
}
public void setSource(int source) {
this.source = source;
raw.putInt(12, source);
}
public void setDestination(int destination) {
this.destination = destination;
raw.putInt(16, destination);
}
public void swapSourceAndDestination() {
int tmp = source;
setSource(destination);
setDestination(tmp);
}
public ByteBuffer getRaw() {
raw.rewind();
return raw.slice();
}
public IPv4Header copyTo(ByteBuffer target) {
raw.rewind();
ByteBuffer slice = Binary.slice(target, target.position(), getHeaderLength());
target.put(raw);
return new IPv4Header(slice);
}
public IPv4Header copy() {
return new IPv4Header(Binary.copy(raw));
}
public void computeChecksum() {
// reset checksum field
setChecksum((short) 0);
// checksum computation is the most CPU-intensive task in gnirehtet
// prefer optimization over readability
byte[] rawArray = raw.array();
int rawArrayOffset = raw.arrayOffset();
int sum = 0;
for (int i = 0; i < headerLength / 2; ++i) {
// compute a 16-bit value from two 8-bit values manually
sum += (rawArray[rawArrayOffset + 2 * i] & 0xff) << 8 | (rawArray[rawArrayOffset + 2 * i + 1] & 0xff);
}
while ((sum & ~0xffff) != 0) {
sum = (sum & 0xffff) + (sum >> 16);
}
setChecksum((short) ~sum);
}
private void setChecksum(short checksum) {
raw.putShort(10, checksum);
}
public short getChecksum() {
return raw.getShort(10);
}
/**
* Read the packet IP version, assuming that an IP packets is stored at absolute position 0.
*
* @param buffer the buffer
* @return the IP version, or {@code -1} if not available
*/
public static int readVersion(ByteBuffer buffer) {
if (buffer.limit() == 0) {
// buffer is empty
return -1;
}
// version is stored in the 4 first bits
byte versionAndIHL = buffer.get(0);
return (versionAndIHL & 0xf0) >> 4;
}
/**
* Read the packet length, assuming thatan IP packet is stored at absolute position 0.
*
* @param buffer the buffer
* @return the packet length, or {@code -1} if not available
*/
public static int readLength(ByteBuffer buffer) {
if (buffer.limit() < 4) {
// buffer does not even contains the length field
return -1;
}
// packet length is 16 bits starting at offset 2
return Short.toUnsignedInt(buffer.getShort(2));
}
}
================================================
FILE: relay-java/src/main/java/com/genymobile/gnirehtet/relay/IPv4Packet.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
import java.nio.ByteBuffer;
public class IPv4Packet {
private static final String TAG = IPv4Packet.class.getSimpleName();
@SuppressWarnings("checkstyle:MagicNumber")
public static final int MAX_PACKET_LENGTH = 1 << 16; // packet length is stored on 16 bits
private final ByteBuffer raw;
private final IPv4Header ipv4Header;
private final TransportHeader transportHeader;
public IPv4Packet(ByteBuffer raw) {
this.raw = raw;
raw.rewind();
if (Log.isVerboseEnabled()) {
Log.v(TAG, "IPv4Packet: " + Binary.buildPacketString(raw));
}
ipv4Header = new IPv4Header(raw.duplicate());
if (!ipv4Header.isSupported()) {
Log.d(TAG, "Unsupported IPv4 headers");
transportHeader = null;
return;
}
transportHeader = createTransportHeader();
raw.limit(ipv4Header.getTotalLength());
}
public boolean isValid() {
return transportHeader != null;
}
private TransportHeader createTransportHeader() {
IPv4Header.Protocol protocol = ipv4Header.getProtocol();
switch (protocol) {
case UDP:
return new UDPHeader(getRawTransport());
case TCP:
return new TCPHeader(getRawTransport());
default:
throw new AssertionError("Should be unreachable if ipv4Header.isSupported()");
}
}
private ByteBuffer getRawTransport() {
raw.position(ipv4Header.getHeaderLength());
return raw.slice();
}
public IPv4Header getIpv4Header() {
return ipv4Header;
}
public TransportHeader getTransportHeader() {
return transportHeader;
}
public void swapSourceAndDestination() {
ipv4Header.swapSourceAndDestination();
transportHeader.swapSourceAndDestination();
}
public ByteBuffer getRaw() {
raw.rewind();
return raw.duplicate();
}
public int getRawLength() {
return raw.limit();
}
public ByteBuffer getPayload() {
int headersLength = ipv4Header.getHeaderLength() + transportHeader.getHeaderLength();
raw.position(headersLength);
return raw.slice();
}
public int getPayloadLength() {
return raw.limit() - ipv4Header.getHeaderLength() - transportHeader.getHeaderLength();
}
public void computeChecksums() {
ipv4Header.computeChecksum();
transportHeader.computeChecksum(ipv4Header, getPayload());
}
}
================================================
FILE: relay-java/src/main/java/com/genymobile/gnirehtet/relay/IPv4PacketBuffer.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.ReadableByteChannel;
public class IPv4PacketBuffer {
private final ByteBuffer buffer = ByteBuffer.allocate(IPv4Packet.MAX_PACKET_LENGTH);
public int readFrom(ReadableByteChannel channel) throws IOException {
return channel.read(buffer);
}
@SuppressWarnings("checkstyle:MagicNumber")
private int getAvailablePacketLength() {
int length = IPv4Header.readLength(buffer);
assert length == -1 || IPv4Header.readVersion(buffer) == 4 : "This function must not be called when the packet is not IPv4";
if (length == -1) {
// no packet
return 0;
}
if (length > buffer.remaining()) {
// no full packet available
return 0;
}
return length;
}
public IPv4Packet asIPv4Packet() {
buffer.flip();
int length = getAvailablePacketLength();
if (length == 0) {
buffer.compact();
return null;
}
int limit = buffer.limit();
buffer.limit(length).position(0);
ByteBuffer packetBuffer = buffer.slice();
buffer.limit(limit).position(length);
// In order to avoid copies, packetBuffer is shared with this IPv4Packet instance that is returned.
// Don't use it after another call to next()!
return new IPv4Packet(packetBuffer);
}
public void next() {
buffer.compact();
}
}
================================================
FILE: relay-java/src/main/java/com/genymobile/gnirehtet/relay/Log.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
import java.io.PrintStream;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
public final class Log {
enum Level {
VERBOSE("V"),
DEBUG("D"),
INFO("I"),
WARNING("W"),
ERROR("E");
private final String id;
Level(String id) {
this.id = id;
}
}
private static Level threshold = Level.INFO;
private static final DateFormat FORMAT = new SimpleDateFormat("YYYY-MM-dd HH:mm:ss.SSS");
private static final Date DATE = new Date();
private Log() {
// not instantiable
}
public static Level getThreshold() {
return threshold;
}
public static void setThreshold(Level threshold) {
Log.threshold = threshold;
}
public static boolean isEnabled(Level level) {
return level.ordinal() >= threshold.ordinal();
}
public static boolean isVerboseEnabled() {
return isEnabled(Level.VERBOSE);
}
public static boolean isDebugEnabled() {
return isEnabled(Level.DEBUG);
}
public static boolean isInfoEnabled() {
return isEnabled(Level.INFO);
}
public static boolean isWarningEnabled() {
return isEnabled(Level.WARNING);
}
public static boolean isErrorEnabled() {
return isEnabled(Level.ERROR);
}
private static String getDate() {
DATE.setTime(System.currentTimeMillis());
return FORMAT.format(DATE);
}
private static String format(Level level, String tag, String message) {
return getDate() + " " + level.id + " " + tag + ": " + message;
}
private static void l(Level level, PrintStream stream, String tag, String message, Throwable e) {
if (isEnabled(level)) {
stream.println(format(level, tag, message));
if (e != null) {
e.printStackTrace();
}
}
}
public static void v(String tag, String message, Throwable e) {
l(Level.VERBOSE, System.out, tag, message, e);
}
public static void v(String tag, String message) {
v(tag, message, null);
}
public static void d(String tag, String message, Throwable e) {
l(Level.DEBUG, System.out, tag, message, e);
}
public static void d(String tag, String message) {
d(tag, message, null);
}
public static void i(String tag, String message, Throwable e) {
l(Level.INFO, System.out, tag, message, e);
}
public static void i(String tag, String message) {
i(tag, message, null);
}
public static void w(String tag, String message, Throwable e) {
l(Level.WARNING, System.out, tag, message, e);
}
public static void w(String tag, String message) {
w(tag, message, null);
}
public static void e(String tag, String message, Throwable e) {
l(Level.ERROR, System.err, tag, message, e);
}
public static void e(String tag, String message) {
e(tag, message, null);
}
}
================================================
FILE: relay-java/src/main/java/com/genymobile/gnirehtet/relay/Net.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.UnknownHostException;
public final class Net {
private Net() {
// not instantiable
}
public static InetAddress[] toInetAddresses(String... addresses) {
InetAddress[] result = new InetAddress[addresses.length];
for (int i = 0; i < result.length; ++i) {
result[i] = toInetAddress(addresses[i]);
}
return result;
}
public static InetAddress toInetAddress(String address) {
try {
return InetAddress.getByName(address);
} catch (UnknownHostException e) {
throw new IllegalArgumentException(e);
}
}
public static InetAddress toInetAddress(byte[] raw) {
try {
return InetAddress.getByAddress(raw);
} catch (UnknownHostException e) {
throw new IllegalArgumentException(e);
}
}
@SuppressWarnings("checkstyle:MagicNumber")
public static InetAddress toInetAddress(int ipAddr) {
byte[] ip = {
(byte) (ipAddr >>> 24),
(byte) ((ipAddr >> 16) & 0xff),
(byte) ((ipAddr >> 8) & 0xff),
(byte) (ipAddr & 0xff)
};
return toInetAddress(ip);
}
public static String toString(InetSocketAddress address) {
return address.getAddress().getHostAddress() + ":" + address.getPort();
}
public static String toString(int ip, short port) {
return toString(new InetSocketAddress(Net.toInetAddress(ip), Short.toUnsignedInt(port)));
}
}
================================================
FILE: relay-java/src/main/java/com/genymobile/gnirehtet/relay/PacketSource.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
/**
* Source that may produce packets.
*
* When a {@link TCPConnection} sends a packet to the {@link Client} while its buffers are full,
* then it fails. To recover, once some space becomes available, the {@link Client} must pull the
* available packets.
*
* This interface provides the abstraction of a packet source from which it can pull packets.
*
* It is implemented by {@link TCPConnection}.
*/
public interface PacketSource {
IPv4Packet get();
void next();
}
================================================
FILE: relay-java/src/main/java/com/genymobile/gnirehtet/relay/Packetizer.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.ReadableByteChannel;
/**
* Convert from level 5 to level 3 by appending correct IP and transport headers.
*/
public class Packetizer {
private final ByteBuffer buffer = ByteBuffer.allocate(IPv4Packet.MAX_PACKET_LENGTH);
private final ByteBuffer payloadBuffer;
private final IPv4Header responseIPv4Header;
private final TransportHeader responseTransportHeader;
public Packetizer(IPv4Header ipv4Header, TransportHeader transportHeader) {
responseIPv4Header = ipv4Header.copyTo(buffer);
responseTransportHeader = transportHeader.copyTo(buffer);
payloadBuffer = buffer.slice();
}
public IPv4Header getResponseIPv4Header() {
return responseIPv4Header;
}
public TransportHeader getResponseTransportHeader() {
return responseTransportHeader;
}
public IPv4Packet packetizeEmptyPayload() {
payloadBuffer.limit(0).position(0);
return inflate();
}
public IPv4Packet packetize(ReadableByteChannel channel, int maxChunkSize) throws IOException {
payloadBuffer.limit(maxChunkSize).position(0);
int payloadLength = channel.read(payloadBuffer);
if (payloadLength == -1) {
return null;
}
payloadBuffer.flip();
return inflate();
}
public IPv4Packet packetize(ReadableByteChannel channel) throws IOException {
return packetize(channel, payloadBuffer.capacity());
}
private IPv4Packet inflate() {
int payloadLength = payloadBuffer.remaining();
buffer.limit(payloadBuffer.arrayOffset() + payloadBuffer.limit()).position(0);
int ipv4HeaderLength = responseIPv4Header.getHeaderLength();
int transportHeaderLength = responseTransportHeader.getHeaderLength();
int totalLength = ipv4HeaderLength + transportHeaderLength + payloadLength;
responseIPv4Header.setTotalLength(totalLength);
responseTransportHeader.setPayloadLength(payloadLength);
// In order to avoid copies, buffer is shared with this IPv4Packet instance that is returned.
// Don't use it after another call to packetize()!
IPv4Packet packet = new IPv4Packet(buffer);
packet.computeChecksums();
return packet;
}
}
================================================
FILE: relay-java/src/main/java/com/genymobile/gnirehtet/relay/Relay.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
import java.io.IOException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.util.Set;
public class Relay {
private static final String TAG = Relay.class.getSimpleName();
private static final int CLEANING_INTERVAL = 60 * 1000;
private final int port;
public Relay(int port) {
this.port = port;
}
public void run() throws IOException {
Selector selector = Selector.open();
// will register the socket on the selector
TunnelServer tunnelServer = new TunnelServer(port, selector);
Log.i(TAG, "Relay server started");
long nextCleaningDeadline = System.currentTimeMillis() + UDPConnection.IDLE_TIMEOUT;
while (true) {
long timeout = Math.max(0, nextCleaningDeadline - System.currentTimeMillis());
selector.select(timeout);
Set selectedKeys = selector.selectedKeys();
long now = System.currentTimeMillis();
if (now >= nextCleaningDeadline || selectedKeys.isEmpty()) {
tunnelServer.cleanUp();
nextCleaningDeadline = now + CLEANING_INTERVAL;
}
for (SelectionKey selectedKey : selectedKeys) {
SelectionHandler selectionHandler = (SelectionHandler) selectedKey.attachment();
selectionHandler.onReady(selectedKey);
}
// by design, we handled everything
selectedKeys.clear();
}
}
}
================================================
FILE: relay-java/src/main/java/com/genymobile/gnirehtet/relay/Router.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
import java.io.IOException;
import java.nio.channels.Selector;
import java.util.ArrayList;
import java.util.List;
public class Router {
private static final String TAG = Router.class.getSimpleName();
private final Client client;
private final Selector selector;
// there are typically only few connections per client, HashMap would be less efficient
private final List connections = new ArrayList<>();
public Router(Client client, Selector selector) {
this.client = client;
this.selector = selector;
}
public void sendToNetwork(IPv4Packet packet) {
if (!packet.isValid()) {
Log.w(TAG, "Dropping invalid packet");
if (Log.isVerboseEnabled()) {
Log.v(TAG, Binary.buildPacketString(packet.getRaw()));
}
return;
}
try {
Connection connection = getConnection(packet.getIpv4Header(), packet.getTransportHeader());
connection.sendToNetwork(packet);
} catch (IOException e) {
Log.e(TAG, "Cannot create connection, dropping packet", e);
}
}
private Connection getConnection(IPv4Header ipv4Header, TransportHeader transportHeader) throws IOException {
ConnectionId id = ConnectionId.from(ipv4Header, transportHeader);
Connection connection = find(id);
if (connection == null) {
connection = createConnection(id, ipv4Header, transportHeader);
connections.add(connection);
}
return connection;
}
private Connection createConnection(ConnectionId id, IPv4Header ipv4Header, TransportHeader transportHeader) throws IOException {
IPv4Header.Protocol protocol = id.getProtocol();
if (protocol == IPv4Header.Protocol.UDP) {
return new UDPConnection(id, client, selector, ipv4Header, (UDPHeader) transportHeader);
}
if (protocol == IPv4Header.Protocol.TCP) {
return new TCPConnection(id, client, selector, ipv4Header, (TCPHeader) transportHeader);
}
throw new UnsupportedOperationException("Unsupported protocol: " + protocol);
}
private Connection find(ConnectionId id) {
for (Connection connection : connections) {
if (id.equals(connection.getId())) {
return connection;
}
}
return null;
}
public void clear() {
for (Connection connection : connections) {
connection.disconnect();
}
connections.clear();
}
public void remove(Connection connection) {
if (!connections.remove(connection)) {
throw new AssertionError("Removed a connection unknown from the router");
}
}
public void cleanExpiredConnections() {
for (int i = connections.size() - 1; i >= 0; --i) {
Connection connection = connections.get(i);
if (connection.isExpired()) {
Log.d(TAG, "Remove expired connection: " + connection.getId());
connection.disconnect();
connections.remove(i);
}
}
}
}
================================================
FILE: relay-java/src/main/java/com/genymobile/gnirehtet/relay/SelectionHandler.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
import java.nio.channels.SelectionKey;
public interface SelectionHandler {
void onReady(SelectionKey selectionKey);
}
================================================
FILE: relay-java/src/main/java/com/genymobile/gnirehtet/relay/StreamBuffer.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.WritableByteChannel;
/**
* Circular buffer to store a stream. Read/write boundaries are not preserved.
*/
public class StreamBuffer {
private final byte[] data;
private final ByteBuffer wrapper;
private int head;
private int tail;
public StreamBuffer(int capacity) {
data = new byte[capacity + 1];
wrapper = ByteBuffer.wrap(data);
}
public boolean isEmpty() {
return head == tail;
}
public boolean isFull() {
return (head + 1) % data.length == tail;
}
public int size() {
if (head < tail) {
return head + data.length - tail;
}
return head - tail;
}
public int capacity() {
return data.length - 1;
}
public int remaining() {
return capacity() - size();
}
public int writeTo(WritableByteChannel channel) throws IOException {
if (head > tail) {
wrapper.limit(head).position(tail);
int w = channel.write(wrapper);
tail = wrapper.position();
optimize();
return w;
}
if (head < tail) {
wrapper.limit(data.length).position(tail);
int w = channel.write(wrapper);
tail = wrapper.position() % data.length;
optimize();
return w;
}
// else head == tail, which means empty buffer, nothing to do
return 0;
}
public void readFrom(ByteBuffer buffer) {
int requested = Math.min(buffer.remaining(), remaining());
if (requested <= data.length - head) {
buffer.get(data, head, requested);
} else {
buffer.get(data, head, data.length - head);
buffer.get(data, 0, head + requested - data.length);
}
head = (head + requested) % data.length;
}
/**
* To avoid unnecessary copies, StreamBuffer writes at most until the "end" of the circular
* buffer, which is suboptimal (it could have written more data if they have been contiguous).
*
* In order to minimize the occurrence of this event, reset the head and tail to 0 when the
* buffer is empty (no copy is involved).
*
* This is especially useful when the StreamBuffer is used to read/write one packet at a time,
* so the "end" of the buffer is guaranteed to never be reached.
*/
private void optimize() {
if (isEmpty()) {
head = 0;
tail = 0;
}
}
}
================================================
FILE: relay-java/src/main/java/com/genymobile/gnirehtet/relay/TCPConnection.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
import java.io.IOException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Random;
public class TCPConnection extends AbstractConnection implements PacketSource {
private static final String TAG = TCPConnection.class.getSimpleName();
// same value as GnirehtetService.MTU in the client
private static final int MTU = 0x4000;
// 20 bytes for IP headers, 20 bytes for TCP headers
private static final int MAX_PAYLOAD_SIZE = MTU - 20 - 20;
private static final Random RANDOM = new Random();
/**
* See RFC793.
*/
public enum State {
SYN_SENT,
SYN_RECEIVED,
ESTABLISHED,
CLOSE_WAIT,
LAST_ACK,
CLOSING,
FIN_WAIT_1,
FIN_WAIT_2;
public boolean isConnected() {
return this != SYN_SENT && this != SYN_RECEIVED;
}
public boolean isClosed() {
return this == FIN_WAIT_1 || this == FIN_WAIT_2 || this == CLOSING || this == LAST_ACK;
}
}
private final StreamBuffer clientToNetwork = new StreamBuffer(4 * IPv4Packet.MAX_PACKET_LENGTH);
private final Packetizer networkToClient;
private IPv4Packet packetForClient;
private final SocketChannel channel;
private final SelectionKey selectionKey;
private int interests;
private State state;
private int synSequenceNumber;
private int sequenceNumber;
private int acknowledgementNumber;
private int theirAcknowledgementNumber;
private Integer finSequenceNumber; // null means "no FIN sent yet"
private boolean finReceived;
private int clientWindow;
public TCPConnection(ConnectionId id, Client client, Selector selector, IPv4Header ipv4Header, TCPHeader tcpHeader) throws IOException {
super(id, client);
TCPHeader shrinkedTcpHeader = tcpHeader.copy();
shrinkedTcpHeader.shrinkOptions(); // no TCP options
networkToClient = new Packetizer(ipv4Header, shrinkedTcpHeader);
networkToClient.getResponseIPv4Header().swapSourceAndDestination();
networkToClient.getResponseTransportHeader().swapSourceAndDestination();
SelectionHandler selectionHandler = (selectionKey) -> {
if (selectionKey.isValid() && selectionKey.isConnectable()) {
processConnect();
}
if (selectionKey.isValid() && selectionKey.isReadable()) {
processReceive();
}
if (selectionKey.isValid() && selectionKey.isWritable()) {
processSend();
}
updateInterests();
};
channel = createChannel();
// interests will be set on the first packet received
// set the initial value now so that they won't need to be updated
interests = SelectionKey.OP_CONNECT;
selectionKey = channel.register(selector, interests, selectionHandler);
}
@Override
public void disconnect() {
logi(TAG, "Close");
selectionKey.cancel();
try {
channel.close();
} catch (IOException e) {
loge(TAG, "Cannot close connection channel", e);
}
}
private void processReceive() {
try {
assert packetForClient == null : "The IPv4Packet shares the networkToClient buffer, it must not be corrupted";
int remainingClientWindow = getRemainingClientWindow();
assert remainingClientWindow > 0 : "If remainingClientWindow is 0, then processReceive() should not have been called";
int maxPayloadSize = Math.min(remainingClientWindow, MAX_PAYLOAD_SIZE);
updateHeaders(TCPHeader.FLAG_ACK | TCPHeader.FLAG_PSH);
packetForClient = networkToClient.packetize(channel, maxPayloadSize);
if (packetForClient == null) {
eof();
return;
}
consume(this);
} catch (IOException e) {
loge(TAG, "Cannot read", e);
resetConnection();
}
}
private void processSend() {
try {
int w = clientToNetwork.writeTo(channel);
if (w > 0) {
acknowledgementNumber += w;
logd(TAG, w + " bytes written to the network socket");
if (finReceived && clientToNetwork.isEmpty()) {
logd(TAG, "No more pending data, process the pending FIN");
doHandleFin();
} else {
logd(TAG, "Sending ACK " + numbers() + " to client");
sendEmptyPacketToClient(TCPHeader.FLAG_ACK);
}
} else {
close();
}
} catch (IOException e) {
loge(TAG, "Cannot write", e);
resetConnection();
}
}
private void eof() {
sendEmptyPacketToClient(TCPHeader.FLAG_FIN | TCPHeader.FLAG_ACK);
finSequenceNumber = sequenceNumber;
++sequenceNumber; // FIN counts for 1 byte
if (state == State.CLOSE_WAIT) {
state = State.LAST_ACK;
} else {
state = State.FIN_WAIT_1;
}
logd(TAG, "State = " + state);
}
private int getRemainingClientWindow() {
// in Java, (signed) integer overflow is well-defined: it wraps around
int remaining = theirAcknowledgementNumber + clientWindow - sequenceNumber;
if (remaining < 0 || remaining > clientWindow) {
// our sequence number is outside their window
return 0;
}
return remaining;
}
@Override
public boolean isExpired() {
// no external timeout expiration
return false;
}
private void updateHeaders(int flags) {
TCPHeader tcpHeader = (TCPHeader) networkToClient.getResponseTransportHeader();
tcpHeader.setFlags(flags);
tcpHeader.setSequenceNumber(sequenceNumber);
tcpHeader.setAcknowledgementNumber(acknowledgementNumber);
}
private SocketChannel createChannel() throws IOException {
logi(TAG, "Open");
SocketChannel socketChannel = SocketChannel.open();
socketChannel.configureBlocking(false);
socketChannel.connect(getRewrittenDestination());
return socketChannel;
}
@Override
public void sendToNetwork(IPv4Packet packet) {
handlePacket(packet);
logd(TAG, "current ack=" + acknowledgementNumber);
updateInterests();
}
private void handlePacket(IPv4Packet packet) {
TCPHeader tcpHeader = (TCPHeader) packet.getTransportHeader();
if (state == null) {
handleFirstPacket(packet);
return;
}
if (tcpHeader.isSyn()) {
// the client always initiates the connection
// at this point, any SYN packet received is duplicate
handleDuplicateSyn(packet);
return;
}
int packetSequenceNumber = tcpHeader.getSequenceNumber();
int expectedPacket = acknowledgementNumber + clientToNetwork.size();
if (packetSequenceNumber != expectedPacket) {
// ignore packet already received or out-of-order, retransmission is already managed by both sides
logw(TAG, "Ignoring packet " + packetSequenceNumber + " (acking " + tcpHeader.getAcknowledgementNumber() + "); expecting "
+ expectedPacket + "; flags=" + tcpHeader.getFlags());
return;
}
clientWindow = tcpHeader.getWindow();
theirAcknowledgementNumber = tcpHeader.getAcknowledgementNumber();
logd(TAG, "Receiving expected paquet " + packetSequenceNumber + " (flags = " + tcpHeader.getFlags() + ")");
if (tcpHeader.isRst()) {
logd(TAG, "Reset requested, closing");
close();
return;
}
if (tcpHeader.isAck()) {
logd(TAG, "Client acked " + tcpHeader.getAcknowledgementNumber());
handleAck(packet);
}
if (tcpHeader.isFin()) {
handleFin();
}
if (finSequenceNumber != null && tcpHeader.getAcknowledgementNumber() == finSequenceNumber + 1) {
logd(TAG, "Received ACK of FIN");
handleFinAck();
}
}
private void handleFirstPacket(IPv4Packet packet) {
logd(TAG, "handleFirstPacket()");
TCPHeader tcpHeader = (TCPHeader) packet.getTransportHeader();
if (!tcpHeader.isSyn()) {
logw(TAG, "Unexpected first packet " + tcpHeader.getSequenceNumber() + "; acking " + tcpHeader.getAcknowledgementNumber()
+ "; flags=" + tcpHeader.getFlags());
sequenceNumber = tcpHeader.getAcknowledgementNumber(); // make a RST in the window client
resetConnection();
return;
}
int theirSequenceNumber = tcpHeader.getSequenceNumber();
acknowledgementNumber = theirSequenceNumber + 1;
synSequenceNumber = theirSequenceNumber;
sequenceNumber = RANDOM.nextInt();
logd(TAG, "initialized seqNum=" + sequenceNumber + "; ackNum=" + acknowledgementNumber);
clientWindow = tcpHeader.getWindow();
state = State.SYN_SENT;
logd(TAG, "State = " + state);
}
private void handleDuplicateSyn(IPv4Packet packet) {
TCPHeader tcpHeader = (TCPHeader) packet.getTransportHeader();
int theirSequenceNumber = tcpHeader.getSequenceNumber();
if (state == State.SYN_SENT) {
// we didn't call finishConnect() yet, we can accept this packet as if it were the first SYN
synSequenceNumber = theirSequenceNumber;
acknowledgementNumber = theirSequenceNumber + 1;
} else if (theirSequenceNumber != synSequenceNumber) {
// duplicate SYN with different sequence number
resetConnection();
}
}
private void handleFin() {
logd(TAG, "Received a FIN from the client " + numbers());
finReceived = true;
if (clientToNetwork.isEmpty()) {
logd(TAG, "No pending data, process the FIN immediately");
doHandleFin();
}
// otherwise, the FIN will be processed once clientToNetwork is empty
}
private void doHandleFin() {
++acknowledgementNumber; // received FIN counts for 1 byte
switch (state) {
case ESTABLISHED:
sendEmptyPacketToClient(TCPHeader.FLAG_FIN | TCPHeader.FLAG_ACK);
finSequenceNumber = sequenceNumber;
++sequenceNumber; // FIN counts for 1 byte
// do not wait for the real network connection, switch immediately to LAST_ACK (bypass CLOSE_WAIT)
state = State.LAST_ACK;
logd(TAG, "State = " + state);
break;
case FIN_WAIT_1:
sendEmptyPacketToClient(TCPHeader.FLAG_ACK);
state = State.CLOSING;
logd(TAG, "State = " + state);
break;
case FIN_WAIT_2:
sendEmptyPacketToClient(TCPHeader.FLAG_ACK);
close();
break;
default:
logw(TAG, "Received FIN while state was " + state);
}
}
private void handleFinAck() {
switch (state) {
case LAST_ACK:
case CLOSING:
close();
break;
case FIN_WAIT_1:
state = State.FIN_WAIT_2;
logd(TAG, "State = " + state);
break;
case FIN_WAIT_2:
// do nothing
break;
default:
logw(TAG, "Received FIN ACK while state was " + state);
}
}
private void handleAck(IPv4Packet packet) {
logd(TAG, "handleAck()");
if (state == State.SYN_RECEIVED) {
state = State.ESTABLISHED;
logd(TAG, "State = " + state);
return;
}
if (Log.isVerboseEnabled()) {
logv(TAG, Binary.buildPacketString(packet.getRaw()));
}
int payloadLength = packet.getPayloadLength();
if (payloadLength == 0) {
// no data to transmit
return;
}
if (clientToNetwork.remaining() < payloadLength) {
logw(TAG, "Not enough space, dropping packet");
return;
}
clientToNetwork.readFrom(packet.getPayload());
// data will be ACKed once written to the network socket
}
private void processConnect() {
logd(TAG, "processConnect()");
if (!finishConnect()) {
close();
return;
}
logd(TAG, "SYN_RECEIVED, acking " + numbers());
state = State.SYN_RECEIVED;
logd(TAG, "State = " + state);
sendEmptyPacketToClient(TCPHeader.FLAG_SYN | TCPHeader.FLAG_ACK);
++sequenceNumber; // SYN counts for 1 byte
}
private boolean finishConnect() {
try {
return channel.finishConnect();
} catch (IOException e) {
loge(TAG, "Cannot finish connect", e);
return false;
}
}
private void resetConnection() {
logd(TAG, "Resetting connection");
state = null;
sendEmptyPacketToClient(TCPHeader.FLAG_RST);
close();
}
private IPv4Packet createEmptyResponsePacket(int flags) {
updateHeaders(flags);
IPv4Packet packet = networkToClient.packetizeEmptyPayload();
logd(TAG, "Forging empty response (flags=" + flags + ") " + numbers());
if (Log.isVerboseEnabled()) {
logd(TAG, Binary.buildPacketString(packet.getRaw()));
}
if ((flags & TCPHeader.FLAG_ACK) != 0) {
logd(TAG, "Acking " + numbers());
}
return packet;
}
private void sendEmptyPacketToClient(int flags) {
sendToClient(createEmptyResponsePacket(flags));
}
protected void updateInterests() {
if (!selectionKey.isValid()) {
return;
}
int interestOps = 0;
if (mayRead()) {
interestOps |= SelectionKey.OP_READ;
}
if (mayWrite()) {
interestOps |= SelectionKey.OP_WRITE;
}
if (mayConnect()) {
interestOps |= SelectionKey.OP_CONNECT;
}
if (interests != interestOps) {
// interests must be changed
interests = interestOps;
selectionKey.interestOps(interestOps);
}
}
private boolean mayRead() {
if (!state.isConnected() || state.isClosed()) {
return false;
}
if (packetForClient != null) {
// a packet is already pending
return false;
}
return getRemainingClientWindow() > 0;
}
private boolean mayWrite() {
return !clientToNetwork.isEmpty();
}
private boolean mayConnect() {
return state == State.SYN_SENT;
}
private String numbers() {
return "(seq=" + sequenceNumber + ", ack=" + acknowledgementNumber + ")";
}
@Override
public IPv4Packet get() {
// TODO update only when necessary
updateAcknowledgementNumber(packetForClient);
return packetForClient;
}
private void updateAcknowledgementNumber(IPv4Packet packet) {
TCPHeader tcpHeader = (TCPHeader) packet.getTransportHeader();
tcpHeader.setAcknowledgementNumber(acknowledgementNumber);
packet.computeChecksums();
}
@Override
public void next() {
logd(TAG, "Packet (" + packetForClient.getPayloadLength() + " bytes) sent to client " + numbers());
if (Log.isVerboseEnabled()) {
logv(TAG, Binary.buildPacketString(packetForClient.getRaw()));
}
sequenceNumber += packetForClient.getPayloadLength();
packetForClient = null;
updateInterests();
}
}
================================================
FILE: relay-java/src/main/java/com/genymobile/gnirehtet/relay/TCPHeader.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
import java.nio.ByteBuffer;
@SuppressWarnings("checkstyle:MagicNumber")
public class TCPHeader implements TransportHeader {
public static final int FLAG_FIN = 1 << 0;
public static final int FLAG_SYN = 1 << 1;
public static final int FLAG_RST = 1 << 2;
public static final int FLAG_PSH = 1 << 3;
public static final int FLAG_ACK = 1 << 4;
public static final int FLAG_URG = 1 << 5;
private final ByteBuffer raw;
private int sourcePort;
private int destinationPort;
private int headerLength;
private int sequenceNumber;
private int acknowledgementNumber;
private int flags;
private int window;
public TCPHeader(ByteBuffer raw) {
this.raw = raw;
sourcePort = Short.toUnsignedInt(raw.getShort(0));
destinationPort = Short.toUnsignedInt(raw.getShort(2));
sequenceNumber = raw.getInt(4);
acknowledgementNumber = raw.getInt(8);
short dataOffsetAndFlags = raw.getShort(12);
headerLength = (dataOffsetAndFlags & 0xf000) >> 10;
flags = dataOffsetAndFlags & 0x1ff;
window = Short.toUnsignedInt(raw.getShort(14));
raw.limit(headerLength);
}
public int getWindow() {
return window;
}
@Override
public int getSourcePort() {
return sourcePort;
}
@Override
public int getDestinationPort() {
return destinationPort;
}
@Override
public void setSourcePort(int sourcePort) {
this.sourcePort = sourcePort;
raw.putShort(0, (short) sourcePort);
}
@Override
public void setDestinationPort(int destinationPort) {
this.destinationPort = destinationPort;
raw.putShort(2, (short) destinationPort);
}
public int getSequenceNumber() {
return sequenceNumber;
}
public void setSequenceNumber(int sequenceNumber) {
this.sequenceNumber = sequenceNumber;
raw.putInt(4, sequenceNumber);
}
public int getAcknowledgementNumber() {
return acknowledgementNumber;
}
public void setAcknowledgementNumber(int acknowledgementNumber) {
this.acknowledgementNumber = acknowledgementNumber;
raw.putInt(8, acknowledgementNumber);
}
@Override
public int getHeaderLength() {
return headerLength;
}
@Override
public void setPayloadLength(int payloadLength) {
// do nothing
}
public int getFlags() {
return flags;
}
public void setFlags(int flags) {
this.flags = flags;
short dataOffsetAndFlags = raw.getShort(12);
dataOffsetAndFlags = (short) (dataOffsetAndFlags & 0xfe00 | flags & 0x1ff);
raw.putShort(12, dataOffsetAndFlags);
}
public void shrinkOptions() {
setDataOffset(5);
raw.limit(20);
}
private void setDataOffset(int dataOffset) {
short dataOffsetAndFlags = raw.getShort(12);
dataOffsetAndFlags = (short) (dataOffsetAndFlags & 0x0fff | (dataOffset << 12));
raw.putShort(12, dataOffsetAndFlags);
headerLength = dataOffset << 2;
}
public boolean isFin() {
return (flags & FLAG_FIN) != 0;
}
public boolean isSyn() {
return (flags & FLAG_SYN) != 0;
}
public boolean isRst() {
return (flags & FLAG_RST) != 0;
}
public boolean isPsh() {
return (flags & FLAG_PSH) != 0;
}
public boolean isAck() {
return (flags & FLAG_ACK) != 0;
}
public boolean isUrg() {
return (flags & FLAG_URG) != 0;
}
@Override
public ByteBuffer getRaw() {
raw.rewind();
return raw.slice();
}
@Override
public TCPHeader copyTo(ByteBuffer target) {
raw.rewind();
ByteBuffer slice = Binary.slice(target, target.position(), getHeaderLength());
target.put(raw);
return new TCPHeader(slice);
}
public TCPHeader copy() {
return new TCPHeader(Binary.copy(raw));
}
@Override
public void computeChecksum(IPv4Header ipv4Header, ByteBuffer payload) {
// checksum computation is the most CPU-intensive task in gnirehtet
// prefer optimization over readability
byte[] rawArray = raw.array();
int rawOffset = raw.arrayOffset();
byte[] payloadArray = payload.array();
int payloadOffset = payload.arrayOffset();
// pseudo-header checksum (cf rfc793 section 3.1)
int source = ipv4Header.getSource();
int destination = ipv4Header.getDestination();
int length = ipv4Header.getTotalLength() - ipv4Header.getHeaderLength();
assert (length & ~0xffff) == 0 : "Length cannot take more than 16 bits"; // by design
int sum = source >>> 16;
sum += source & 0xffff;
sum += destination >>> 16;
sum += destination & 0xffff;
sum += IPv4Header.Protocol.TCP.getNumber();
sum += length;
// reset checksum field
setChecksum((short) 0);
for (int i = 0; i < headerLength / 2; ++i) {
// compute a 16-bit value from two 8-bit values manually
sum += ((rawArray[rawOffset + 2 * i] & 0xff) << 8) | (rawArray[rawOffset + 2 * i + 1] & 0xff);
}
int payloadLength = length - headerLength;
assert payloadLength == payload.limit() : "Payload length does not match";
for (int i = 0; i < payloadLength / 2; ++i) {
// compute a 16-bit value from two 8-bit values manually
sum += ((payloadArray[payloadOffset + 2 * i] & 0xff) << 8) | (payloadArray[payloadOffset + 2 * i + 1] & 0xff);
}
if (payloadLength % 2 != 0) {
sum += (payloadArray[payloadOffset + payloadLength - 1] & 0xff) << 8;
}
while ((sum & ~0xffff) != 0) {
sum = (sum & 0xffff) + (sum >> 16);
}
setChecksum((short) ~sum);
}
private void setChecksum(short checksum) {
raw.putShort(16, checksum);
}
public short getChecksum() {
return raw.getShort(16);
}
}
================================================
FILE: relay-java/src/main/java/com/genymobile/gnirehtet/relay/TransportHeader.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
import java.nio.ByteBuffer;
public interface TransportHeader {
int getSourcePort();
int getDestinationPort();
void setSourcePort(int port);
void setDestinationPort(int port);
int getHeaderLength();
void setPayloadLength(int payloadLength);
ByteBuffer getRaw();
TransportHeader copyTo(ByteBuffer buffer);
void computeChecksum(IPv4Header ipv4Header, ByteBuffer payload);
default void swapSourceAndDestination() {
int tmp = getSourcePort();
setSourcePort(getDestinationPort());
setDestinationPort(tmp);
}
}
================================================
FILE: relay-java/src/main/java/com/genymobile/gnirehtet/relay/TunnelServer.java
================================================
package com.genymobile.gnirehtet.relay;
import java.io.IOException;
import java.net.Inet4Address;
import java.net.InetSocketAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.ArrayList;
import java.util.List;
/**
* Handle the connections from the clients.
*/
public class TunnelServer {
private static final String TAG = TunnelServer.class.getSimpleName();
private final List clients = new ArrayList<>();
public TunnelServer(int port, Selector selector) throws IOException {
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.configureBlocking(false);
// ServerSocketChannel.bind() requires API 24
serverSocketChannel.socket().bind(new InetSocketAddress(Inet4Address.getLoopbackAddress(), port));
SelectionHandler socketChannelHandler = (selectionKey) -> {
try {
ServerSocketChannel channel = (ServerSocketChannel) selectionKey.channel();
acceptClient(selector, channel);
} catch (IOException e) {
Log.e(TAG, "Cannot accept client", e);
}
};
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT, socketChannelHandler);
}
private void acceptClient(Selector selector, ServerSocketChannel serverSocketChannel) throws IOException {
SocketChannel socketChannel = serverSocketChannel.accept();
socketChannel.configureBlocking(false);
// will register the socket on the selector
Client client = new Client(selector, socketChannel, this::removeClient);
clients.add(client);
Log.i(TAG, "Client #" + client.getId() + " connected");
}
private void removeClient(Client client) {
clients.remove(client);
Log.i(TAG, "Client #" + client.getId() + " disconnected");
}
public void cleanUp() {
for (Client client : clients) {
client.cleanExpiredConnections();
}
}
}
================================================
FILE: relay-java/src/main/java/com/genymobile/gnirehtet/relay/UDPConnection.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
import java.io.IOException;
import java.nio.channels.DatagramChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
public class UDPConnection extends AbstractConnection {
public static final long IDLE_TIMEOUT = 2 * 60 * 1000;
private static final String TAG = UDPConnection.class.getSimpleName();
private final DatagramBuffer clientToNetwork = new DatagramBuffer(4 * IPv4Packet.MAX_PACKET_LENGTH);
private final Packetizer networkToClient;
private final DatagramChannel channel;
private final SelectionKey selectionKey;
private int interests;
private long idleSince;
public UDPConnection(ConnectionId id, Client client, Selector selector, IPv4Header ipv4Header, UDPHeader udpHeader) throws IOException {
super(id, client);
networkToClient = new Packetizer(ipv4Header, udpHeader);
networkToClient.getResponseIPv4Header().swapSourceAndDestination();
networkToClient.getResponseTransportHeader().swapSourceAndDestination();
touch();
SelectionHandler selectionHandler = (selectionKey) -> {
touch();
if (selectionKey.isValid() && selectionKey.isReadable()) {
processReceive();
}
if (selectionKey.isValid() && selectionKey.isWritable()) {
processSend();
}
updateInterests();
};
channel = createChannel();
interests = SelectionKey.OP_READ;
selectionKey = channel.register(selector, interests, selectionHandler);
}
@Override
public void sendToNetwork(IPv4Packet packet) {
if (!clientToNetwork.readFrom(packet.getPayload())) {
logw(TAG, "Cannot send to network, dropping packet");
return;
}
updateInterests();
}
@Override
public void disconnect() {
logi(TAG, "Close");
selectionKey.cancel();
try {
channel.close();
} catch (IOException e) {
loge(TAG, "Cannot close connection channel", e);
}
}
@Override
public boolean isExpired() {
return System.currentTimeMillis() >= idleSince + IDLE_TIMEOUT;
}
private DatagramChannel createChannel() throws IOException {
logi(TAG, "Open");
DatagramChannel datagramChannel = DatagramChannel.open();
datagramChannel.configureBlocking(false);
datagramChannel.connect(getRewrittenDestination());
return datagramChannel;
}
private void touch() {
idleSince = System.currentTimeMillis();
}
private void processReceive() {
IPv4Packet packet = read();
if (packet == null) {
close();
return;
}
pushToClient(packet);
}
private void processSend() {
if (!write()) {
close();
}
}
private IPv4Packet read() {
try {
return networkToClient.packetize(channel);
} catch (IOException e) {
loge(TAG, "Cannot read", e);
return null;
}
}
private boolean write() {
try {
return clientToNetwork.writeTo(channel);
} catch (IOException e) {
loge(TAG, "Cannot write", e);
return false;
}
}
private void pushToClient(IPv4Packet packet) {
if (!sendToClient(packet)) {
logw(TAG, "Cannot send to client, dropping packet");
return;
}
logd(TAG, "Packet (" + packet.getPayloadLength() + " bytes) sent to client");
if (Log.isVerboseEnabled()) {
logv(TAG, Binary.buildPacketString(packet.getRaw()));
}
}
protected void updateInterests() {
if (!selectionKey.isValid()) {
return;
}
int interestOps = SelectionKey.OP_READ;
if (mayWrite()) {
interestOps |= SelectionKey.OP_WRITE;
}
if (interests != interestOps) {
// interests must be changed
interests = interestOps;
selectionKey.interestOps(interestOps);
}
}
private boolean mayWrite() {
return !clientToNetwork.isEmpty();
}
}
================================================
FILE: relay-java/src/main/java/com/genymobile/gnirehtet/relay/UDPHeader.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
import java.nio.ByteBuffer;
@SuppressWarnings("checkstyle:MagicNumber")
public class UDPHeader implements TransportHeader {
private static final int UDP_HEADER_LENGTH = 8;
private final ByteBuffer raw;
private int sourcePort;
private int destinationPort;
public UDPHeader(ByteBuffer raw) {
this.raw = raw;
raw.limit(UDP_HEADER_LENGTH);
sourcePort = Short.toUnsignedInt(raw.getShort(0));
destinationPort = Short.toUnsignedInt(raw.getShort(2));
}
@Override
public int getSourcePort() {
return sourcePort;
}
@Override
public int getDestinationPort() {
return destinationPort;
}
@Override
public void setSourcePort(int sourcePort) {
this.sourcePort = sourcePort;
raw.putShort(0, (short) sourcePort);
}
@Override
public void setDestinationPort(int destinationPort) {
this.destinationPort = destinationPort;
raw.putShort(2, (short) destinationPort);
}
@Override
public int getHeaderLength() {
return UDP_HEADER_LENGTH;
}
@Override
public void setPayloadLength(int payloadLength) {
int length = getHeaderLength() + payloadLength;
raw.putShort(4, (short) length);
}
@Override
public ByteBuffer getRaw() {
raw.rewind();
return raw.slice();
}
@Override
public UDPHeader copyTo(ByteBuffer target) {
raw.rewind();
ByteBuffer slice = Binary.slice(target, target.position(), getHeaderLength());
target.put(raw);
return new UDPHeader(slice);
}
@Override
public void computeChecksum(IPv4Header ipv4Header, ByteBuffer payload) {
// disable checksum validation
raw.putShort(6, (short) 0);
}
}
================================================
FILE: relay-java/src/test/java/com/genymobile/gnirehtet/AdbMonitorTest.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet;
import org.junit.Assert;
import org.junit.Test;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
public class AdbMonitorTest {
private static ByteBuffer toByteBuffer(String s) {
return ByteBuffer.wrap(s.getBytes(StandardCharsets.US_ASCII));
}
@Test
public void testReadValidPacket() {
String data = "00180123456789ABCDEF\tdevice\n";
String result = AdbMonitor.readPacket(toByteBuffer(data));
Assert.assertEquals("0123456789ABCDEF\tdevice\n", result);
}
@Test
public void testReadValidPackets() {
String data = "00300123456789ABCDEF\tdevice\nFEDCBA9876543210\tdevice\n";
String result = AdbMonitor.readPacket(toByteBuffer(data));
Assert.assertEquals("0123456789ABCDEF\tdevice\nFEDCBA9876543210\tdevice\n", result);
}
@Test
public void testReadValidPacketWithGarbage() {
String data = "00180123456789ABCDEF\tdevice\ngarbage";
String result = AdbMonitor.readPacket(toByteBuffer(data));
Assert.assertEquals("0123456789ABCDEF\tdevice\n", result);
}
@Test
public void testReadShortPacket() {
String data = "00180123456789ABCDEF\tdevi";
String result = AdbMonitor.readPacket(toByteBuffer(data));
Assert.assertNull(result);
}
@Test
public void testHandlePacketDevice() {
final String[] pSerial = new String[1];
AdbMonitor monitor = new AdbMonitor((serial) -> pSerial[0] = serial);
String packet = "0123456789ABCDEF\tdevice\n";
monitor.handlePacket(packet);
Assert.assertEquals("0123456789ABCDEF", pSerial[0]);
}
@Test
public void testHandlePacketOffline() {
final String[] pSerial = new String[1];
AdbMonitor monitor = new AdbMonitor((serial) -> pSerial[0] = serial);
String packet = "0123456789ABCDEF\toffline\n";
monitor.handlePacket(packet);
Assert.assertNull(pSerial[0]);
}
@Test
public void testMultipleConnectedDevices() {
final String[] pSerials = new String[2];
AdbMonitor monitor = new AdbMonitor(new AdbMonitor.AdbDevicesCallback() {
private int i;
@Override
public void onNewDeviceConnected(String serial) {
pSerials[i++] = serial;
}
});
String packet = "0123456789ABCDEF\tdevice\nFEDCBA9876543210\tdevice\n";
monitor.handlePacket(packet);
Assert.assertEquals("0123456789ABCDEF", pSerials[0]);
Assert.assertEquals("FEDCBA9876543210", pSerials[1]);
}
@Test
@SuppressWarnings("checkstyle:MagicNumber")
public void testMultipleConnectedDevicesWithDisconnection() {
final String[] pSerials = new String[3];
AdbMonitor monitor = new AdbMonitor(new AdbMonitor.AdbDevicesCallback() {
private int i;
@Override
public void onNewDeviceConnected(String serial) {
pSerials[i++] = serial;
}
});
String packet = "0123456789ABCDEF\tdevice\nFEDCBA9876543210\tdevice\n";
monitor.handlePacket(packet);
packet = "0123456789ABCDEF\tdevice\n";
monitor.handlePacket(packet);
packet = "0123456789ABCDEF\tdevice\nFEDCBA9876543210\tdevice\n";
monitor.handlePacket(packet);
Assert.assertEquals("0123456789ABCDEF", pSerials[0]);
Assert.assertEquals("FEDCBA9876543210", pSerials[1]);
Assert.assertEquals("FEDCBA9876543210", pSerials[2]);
}
}
================================================
FILE: relay-java/src/test/java/com/genymobile/gnirehtet/CommandLineArgumentsTest.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet;
import org.junit.Assert;
import org.junit.Test;
public class CommandLineArgumentsTest {
private static final int ACCEPT_ALL = CommandLineArguments.PARAM_SERIAL | CommandLineArguments.PARAM_DNS_SERVER
| CommandLineArguments.PARAM_ROUTES;
@Test
public void testNoArgs() {
CommandLineArguments args = CommandLineArguments.parse(ACCEPT_ALL);
Assert.assertNull(args.getSerial());
Assert.assertNull(args.getDnsServers());
}
@Test
public void testSerialOnly() {
CommandLineArguments args = CommandLineArguments.parse(ACCEPT_ALL, "myserial");
Assert.assertEquals("myserial", args.getSerial());
Assert.assertNull(args.getDnsServers());
}
@Test(expected = IllegalArgumentException.class)
public void testInvalidParameter() {
CommandLineArguments.parse(ACCEPT_ALL, "myserial", "other");
}
@Test
public void testDnsServersOnly() {
CommandLineArguments args = CommandLineArguments.parse(ACCEPT_ALL, "-d", "8.8.8.8");
Assert.assertNull(args.getSerial());
Assert.assertEquals("8.8.8.8", args.getDnsServers());
}
@Test
public void testSerialAndDnsServers() {
CommandLineArguments args = CommandLineArguments.parse(ACCEPT_ALL, "myserial", "-d", "8.8.8.8");
Assert.assertEquals("myserial", args.getSerial());
Assert.assertEquals("8.8.8.8", args.getDnsServers());
}
@Test
public void testDnsServersAndSerial() {
CommandLineArguments args = CommandLineArguments.parse(ACCEPT_ALL, "-d", "8.8.8.8", "myserial");
Assert.assertEquals("myserial", args.getSerial());
Assert.assertEquals("8.8.8.8", args.getDnsServers());
}
@Test(expected = IllegalArgumentException.class)
public void testSerialWithNoDnsServersParameter() {
CommandLineArguments.parse(ACCEPT_ALL, "myserial", "-d");
}
@Test(expected = IllegalArgumentException.class)
public void testNoDnsServersParameter() {
CommandLineArguments.parse(ACCEPT_ALL, "-d");
}
@Test
public void testRoutesParameter() {
CommandLineArguments args = CommandLineArguments.parse(ACCEPT_ALL, "-r", "1.2.3.0/24");
Assert.assertEquals("1.2.3.0/24", args.getRoutes());
}
@Test(expected = IllegalArgumentException.class)
public void testNoRoutesParameter() {
CommandLineArguments.parse(ACCEPT_ALL, "-r");
}
}
================================================
FILE: relay-java/src/test/java/com/genymobile/gnirehtet/relay/DatagramBufferTest.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
import org.junit.Assert;
import org.junit.Test;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.Channels;
import java.nio.channels.WritableByteChannel;
@SuppressWarnings("checkstyle:MagicNumber")
public class DatagramBufferTest {
private static ByteBuffer createDatagram(int size) {
byte[] data = new byte[size];
for (int i = 0; i < size; ++i) {
data[i] = (byte) i;
}
return ByteBuffer.wrap(data);
}
@Test
public void testSimple() throws IOException {
ByteBuffer datagram = createDatagram(5);
DatagramBuffer datagramBuffer = new DatagramBuffer(9);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
WritableByteChannel channel = Channels.newChannel(bos);
datagramBuffer.readFrom(datagram);
datagramBuffer.writeTo(channel);
byte[] result = bos.toByteArray();
Assert.assertArrayEquals(datagram.array(), result);
}
@Test
public void testDatagramBoundaries() throws IOException {
DatagramBuffer datagramBuffer = new DatagramBuffer(32);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
WritableByteChannel channel = Channels.newChannel(bos);
ByteBuffer datagram5 = createDatagram(5);
ByteBuffer datagram0 = createDatagram(0);
ByteBuffer datagram3 = createDatagram(3);
ByteBuffer datagram4 = createDatagram(4);
datagramBuffer.readFrom(datagram5);
datagramBuffer.readFrom(datagram0);
datagramBuffer.readFrom(datagram3);
datagramBuffer.readFrom(datagram4);
datagramBuffer.writeTo(channel);
byte[] result = bos.toByteArray();
Assert.assertArrayEquals(datagram5.array(), result);
bos.reset();
datagramBuffer.writeTo(channel);
result = bos.toByteArray();
Assert.assertArrayEquals(datagram0.array(), result);
bos.reset();
datagramBuffer.writeTo(channel);
result = bos.toByteArray();
Assert.assertArrayEquals(datagram3.array(), result);
bos.reset();
datagramBuffer.writeTo(channel);
result = bos.toByteArray();
Assert.assertArrayEquals(datagram4.array(), result);
}
@Test
public void testCircular() throws IOException {
ByteBuffer datagram5 = createDatagram(5);
ByteBuffer datagram3 = createDatagram(3);
DatagramBuffer datagramBuffer = new DatagramBuffer(14);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
WritableByteChannel channel = Channels.newChannel(bos);
// write and consume 10 bytes
datagramBuffer.readFrom(createDatagram(10));
datagramBuffer.writeTo(Channels.newChannel(new ByteArrayOutputStream())); // forget
// DatagramBuffer is expected to store the whole datagram (even if it exceeds its "capacity")
datagramBuffer.readFrom(datagram5);
datagramBuffer.readFrom(datagram3);
datagramBuffer.writeTo(channel);
byte[] result = bos.toByteArray();
Assert.assertArrayEquals(datagram5.array(), result);
bos.reset();
datagramBuffer.writeTo(channel);
result = bos.toByteArray();
Assert.assertArrayEquals(datagram3.array(), result);
}
}
================================================
FILE: relay-java/src/test/java/com/genymobile/gnirehtet/relay/IPv4HeaderTest.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
import org.junit.Assert;
import org.junit.Ignore;
import org.junit.Test;
import java.nio.ByteBuffer;
@SuppressWarnings("checkstyle:MagicNumber")
public class IPv4HeaderTest {
@Test
public void testReadIPVersionUnavailable() {
ByteBuffer buffer = ByteBuffer.allocate(20);
buffer.flip();
int firstPacketVersion = IPv4Header.readVersion(buffer);
Assert.assertEquals("IPv4 packet version must be unknown", -1, firstPacketVersion);
}
@Test
public void testReadIPVersionAvailable() {
ByteBuffer buffer = ByteBuffer.allocate(20);
byte versionAndIHL = (4 << 4) | 5;
buffer.put(versionAndIHL);
buffer.flip();
int firstPacketVersion = IPv4Header.readVersion(buffer);
Assert.assertEquals("Wrong IP version field value", 4, firstPacketVersion);
}
@Test
public void testReadLengthUnavailable() {
ByteBuffer buffer = ByteBuffer.allocate(20);
buffer.flip();
int firstPacketLength = IPv4Header.readLength(buffer);
Assert.assertEquals("IPv4 packet length must be unknown", -1, firstPacketLength);
}
@Test
public void testReadLengthAvailable() {
ByteBuffer buffer = ByteBuffer.allocate(20);
buffer.put(2, (byte) 0x01);
buffer.put(3, (byte) 0x23);
buffer.position(20); // consider we wrote the whole header
buffer.flip();
int firstPacketLength = IPv4Header.readLength(buffer);
Assert.assertEquals("Wrong IP length field value", 0x123, firstPacketLength);
}
private static ByteBuffer createMockHeaders() {
ByteBuffer buffer = ByteBuffer.allocate(28);
buffer.put((byte) ((4 << 4) | 5)); // versionAndIHL
buffer.put((byte) 0); // ToS
buffer.putShort((short) 28); // total length
buffer.putInt(0); // IdFlagsFragmentOffset
buffer.put((byte) 0); // TTL
buffer.put((byte) 17); // protocol (UDP)
buffer.putShort((short) 0); // checksum
buffer.putInt(0x12345678); // source address
buffer.putInt(0x42424242); // destination address
buffer.limit(28);
buffer.flip();
return buffer;
}
@Test
public void testParsePacketHeaders() {
IPv4Header header = new IPv4Header(createMockHeaders());
Assert.assertNotNull("Valid IPv4 header not parsed", header);
Assert.assertTrue(header.isSupported());
Assert.assertEquals(IPv4Header.Protocol.UDP, header.getProtocol());
Assert.assertEquals(20, header.getHeaderLength());
Assert.assertEquals(28, header.getTotalLength());
}
@Test
public void testEditHeaders() {
ByteBuffer buffer = createMockHeaders();
IPv4Header header = new IPv4Header(buffer);
header.setSource(0x87654321);
header.setDestination(0x24242424);
header.setTotalLength(42);
Assert.assertEquals(0x87654321, header.getSource());
Assert.assertEquals(0x24242424, header.getDestination());
Assert.assertEquals(42, header.getTotalLength());
// assert the buffer has been modified
int source = buffer.getInt(12);
int destination = buffer.getInt(16);
int totalLength = Short.toUnsignedInt(buffer.getShort(2));
Assert.assertEquals(0x87654321, source);
Assert.assertEquals(0x24242424, destination);
Assert.assertEquals(42, totalLength);
header.swapSourceAndDestination();
Assert.assertEquals(0x24242424, header.getSource());
Assert.assertEquals(0x87654321, header.getDestination());
source = buffer.getInt(12);
destination = buffer.getInt(16);
Assert.assertEquals(0x24242424, source);
Assert.assertEquals(0x87654321, destination);
}
@Test
public void testComputeChecksum() {
ByteBuffer buffer = createMockHeaders();
IPv4Header header = new IPv4Header(buffer);
// set a fake checksum value to assert that it is correctly computed
buffer.putShort(10, (short) 0x79);
header.computeChecksum();
int sum = 0x4500 + 0x001c + 0x0000 + 0x0000 + 0x0011 + 0x0000 + 0x1234 + 0x5678 + 0x4242 + 0x4242;
while ((sum & ~0xffff) != 0) {
sum = (sum & 0xffff) + (sum >> 16);
}
short checksum = (short) ~sum;
Assert.assertEquals(checksum, header.getChecksum());
}
@Ignore // manual benchmark
@Test
public void benchComputeChecksum() {
ByteBuffer buffer = createMockHeaders();
IPv4Header header = new IPv4Header(buffer);
long start = System.currentTimeMillis();
for (int i = 0; i < 5000000; ++i) {
header.computeChecksum();
}
long duration = System.currentTimeMillis() - start;
System.out.println("5000000 IP checksums: " + duration + "ms");
}
}
================================================
FILE: relay-java/src/test/java/com/genymobile/gnirehtet/relay/IPv4PacketBufferTest.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
import org.junit.Assert;
import org.junit.Test;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.Channels;
import java.nio.channels.ReadableByteChannel;
@SuppressWarnings("checkstyle:MagicNumber")
public class IPv4PacketBufferTest {
private static ByteBuffer createMockPacket() {
ByteBuffer buffer = ByteBuffer.allocate(32);
writeMockPacketTo(buffer);
buffer.flip();
return buffer;
}
private static void writeMockPacketTo(ByteBuffer buffer) {
buffer.put((byte) ((4 << 4) | 5)); // versionAndIHL
buffer.put((byte) 0); // ToS
buffer.putShort((short) 32); // total length 20 + 8 + 4
buffer.putInt(0); // IdFlagsFragmentOffset
buffer.put((byte) 0); // TTL
buffer.put((byte) 17); // protocol (UDP)
buffer.putShort((short) 0); // checksum
buffer.putInt(0x12345678); // source address
buffer.putInt(0x42424242); // destination address
buffer.putShort((short) 1234); // source port
buffer.putShort((short) 5678); // destination port
buffer.putShort((short) 12); // length
buffer.putShort((short) 0); // checksum
buffer.putInt(0x11223344); // payload
}
private static ReadableByteChannel contentToChannel(ByteBuffer buffer) {
ByteArrayInputStream bis = new ByteArrayInputStream(buffer.array(), buffer.arrayOffset() + buffer.position(), buffer.limit());
return Channels.newChannel(bis);
}
@Test
public void testParseIPv4PacketBuffer() throws IOException {
ByteBuffer buffer = createMockPacket();
IPv4PacketBuffer packetBuffer = new IPv4PacketBuffer();
packetBuffer.readFrom(contentToChannel(buffer));
IPv4Packet packet = packetBuffer.asIPv4Packet();
Assert.assertNotNull(packet);
checkPacketHeaders(packet);
}
@Test
public void testParseFragmentedIPv4PacketBuffer() throws IOException {
ByteBuffer buffer = createMockPacket();
IPv4PacketBuffer packetBuffer = new IPv4PacketBuffer();
// onReadable the first 14 bytes
buffer.limit(14);
packetBuffer.readFrom(contentToChannel(buffer));
Assert.assertNull(packetBuffer.asIPv4Packet());
// onReadable the remaining
buffer.limit(32).position(14);
packetBuffer.readFrom(contentToChannel(buffer));
IPv4Packet packet = packetBuffer.asIPv4Packet();
Assert.assertNotNull(packet);
checkPacketHeaders(packet);
}
private static ByteBuffer createMockPackets() {
ByteBuffer buffer = ByteBuffer.allocate(32 * 3);
for (int i = 0; i < 3; ++i) {
writeMockPacketTo(buffer);
}
buffer.flip();
return buffer;
}
@Test
public void testMultiPackets() throws IOException {
ByteBuffer buffer = createMockPackets();
IPv4PacketBuffer packetBuffer = new IPv4PacketBuffer();
packetBuffer.readFrom(contentToChannel(buffer));
for (int i = 0; i < 3; ++i) {
IPv4Packet packet = packetBuffer.asIPv4Packet();
Assert.assertNotNull(packet);
checkPacketHeaders(packet);
packetBuffer.next();
}
// after the 3 packets have been consumed, there is nothing left
Assert.assertNull(packetBuffer.asIPv4Packet());
}
private static void checkPacketHeaders(IPv4Packet packet) {
IPv4Header ipv4Header = packet.getIpv4Header();
Assert.assertEquals(20, ipv4Header.getHeaderLength());
Assert.assertEquals(32, ipv4Header.getTotalLength());
Assert.assertEquals(IPv4Header.Protocol.UDP, ipv4Header.getProtocol());
Assert.assertEquals(0x12345678, ipv4Header.getSource());
Assert.assertEquals(0x42424242, ipv4Header.getDestination());
UDPHeader udpHeader = (UDPHeader) packet.getTransportHeader();
Assert.assertEquals(8, udpHeader.getHeaderLength());
Assert.assertEquals(1234, udpHeader.getSourcePort());
Assert.assertEquals(5678, udpHeader.getDestinationPort());
}
}
================================================
FILE: relay-java/src/test/java/com/genymobile/gnirehtet/relay/IPv4PacketTest.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
import org.junit.Assert;
import org.junit.Test;
import java.nio.ByteBuffer;
@SuppressWarnings("checkstyle:MagicNumber")
public class IPv4PacketTest {
private static ByteBuffer createMockPacket() {
ByteBuffer buffer = ByteBuffer.allocate(32);
buffer.put((byte) ((4 << 4) | 5)); // versionAndIHL
buffer.put((byte) 0); // ToS
buffer.putShort((short) 32); // total length 20 + 8 + 4
buffer.putInt(0); // IdFlagsFragmentOffset
buffer.put((byte) 0); // TTL
buffer.put((byte) 17); // protocol (UDP)
buffer.putShort((short) 0); // checksum
buffer.putInt(0x12345678); // source address
buffer.putInt(0x42424242); // destination address
buffer.putShort((short) 1234); // source port
buffer.putShort((short) 5678); // destination port
buffer.putShort((short) 4); // length
buffer.putShort((short) 0); // checksum
buffer.putInt(0x11223344); // payload
return buffer;
}
@Test
public void testParseHeaders() {
ByteBuffer buffer = createMockPacket();
IPv4Packet packet = new IPv4Packet(buffer);
IPv4Header ipv4Header = packet.getIpv4Header();
Assert.assertTrue(ipv4Header.isSupported());
Assert.assertEquals(20, ipv4Header.getHeaderLength());
Assert.assertEquals(32, ipv4Header.getTotalLength());
Assert.assertEquals(IPv4Header.Protocol.UDP, ipv4Header.getProtocol());
Assert.assertEquals(0x12345678, ipv4Header.getSource());
Assert.assertEquals(0x42424242, ipv4Header.getDestination());
UDPHeader udpHeader = (UDPHeader) packet.getTransportHeader();
Assert.assertEquals(1234, udpHeader.getSourcePort());
Assert.assertEquals(5678, udpHeader.getDestinationPort());
Assert.assertEquals(8, udpHeader.getHeaderLength());
packet.swapSourceAndDestination();
Assert.assertEquals(0x42424242, ipv4Header.getSource());
Assert.assertEquals(0x12345678, ipv4Header.getDestination());
Assert.assertEquals(5678, udpHeader.getSourcePort());
Assert.assertEquals(1234, udpHeader.getDestinationPort());
int source = buffer.getInt(12);
int destination = buffer.getInt(16);
int sourcePort = Short.toUnsignedInt(buffer.getShort(20));
int destinationPort = Short.toUnsignedInt(buffer.getShort(22));
Assert.assertEquals(0x42424242, source);
Assert.assertEquals(0x12345678, destination);
Assert.assertEquals(5678, sourcePort);
Assert.assertEquals(1234, destinationPort);
}
@Test
public void testPayload() {
ByteBuffer buffer = createMockPacket();
IPv4Packet packet = new IPv4Packet(buffer);
ByteBuffer payload = packet.getPayload();
Assert.assertEquals(0x11223344, payload.getInt(0));
}
}
================================================
FILE: relay-java/src/test/java/com/genymobile/gnirehtet/relay/InetAddressTest.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
import org.junit.Assert;
import org.junit.Test;
import java.net.InetAddress;
@SuppressWarnings("checkstyle:MagicNumber")
public class InetAddressTest {
@Test
public void testIntToInetAddress() {
int ip = 0x01020304;
InetAddress addr = Net.toInetAddress(ip);
Assert.assertEquals("1.2.3.4", addr.getHostAddress());
}
@Test
public void testUnsignedIntToInetAddress() {
int ip = 0xff020304;
InetAddress addr = Net.toInetAddress(ip);
Assert.assertEquals("255.2.3.4", addr.getHostAddress());
}
}
================================================
FILE: relay-java/src/test/java/com/genymobile/gnirehtet/relay/PacketizerTest.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
import org.junit.Assert;
import org.junit.Test;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.Channels;
import java.nio.channels.ReadableByteChannel;
@SuppressWarnings("checkstyle:MagicNumber")
public class PacketizerTest {
private static ByteBuffer createMockPacket() {
ByteBuffer buffer = ByteBuffer.allocate(32);
buffer.put((byte) ((4 << 4) | 5)); // versionAndIHL
buffer.put((byte) 0); // ToS
buffer.putShort((short) 32); // total length 20 + 8 + 4
buffer.putInt(0); // IdFlagsFragmentOffset
buffer.put((byte) 0); // TTL
buffer.put((byte) 17); // protocol (UDP)
buffer.putShort((short) 0); // checksum
buffer.putInt(0x12345678); // source address
buffer.putInt(0x42424242); // destination address
buffer.putShort((short) 1234); // source port
buffer.putShort((short) 5678); // destination port
buffer.putShort((short) 4); // length
buffer.putShort((short) 0); // checksum
buffer.putInt(0x11223344); // payload
return buffer;
}
@Test
public void testMergeHeadersAndPayload() throws IOException {
IPv4Packet referencePacket = new IPv4Packet(createMockPacket());
IPv4Header ipv4Header = referencePacket.getIpv4Header();
TransportHeader transportHeader = referencePacket.getTransportHeader();
byte[] data = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, (byte) 0x88};
ReadableByteChannel channel = Channels.newChannel(new ByteArrayInputStream(data));
Packetizer packetizer = new Packetizer(ipv4Header, transportHeader);
IPv4Packet packet = packetizer.packetize(channel);
Assert.assertEquals(36, packet.getIpv4Header().getTotalLength());
ByteBuffer packetPayload = packet.getPayload();
Assert.assertEquals(8, packetPayload.remaining());
Assert.assertEquals(0x1122334455667788L, packetPayload.getLong());
}
@Test
public void testPacketizeChunks() throws IOException {
IPv4Packet originalPacket = new IPv4Packet(createMockPacket());
IPv4Header ipv4Header = originalPacket.getIpv4Header();
TransportHeader transportHeader = originalPacket.getTransportHeader();
byte[] data = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, (byte) 0x88};
ReadableByteChannel channel = Channels.newChannel(new ByteArrayInputStream(data));
Packetizer packetizer = new Packetizer(ipv4Header, transportHeader);
IPv4Packet packet = packetizer.packetize(channel, 2);
ByteBuffer packetPayload = packet.getPayload();
Assert.assertEquals(30, packet.getIpv4Header().getTotalLength());
Assert.assertEquals(2, packetPayload.remaining());
Assert.assertEquals(0x1122, Short.toUnsignedInt(packetPayload.getShort()));
packet = packetizer.packetize(channel, 3);
packetPayload = packet.getPayload();
Assert.assertEquals(31, packet.getIpv4Header().getTotalLength());
Assert.assertEquals(3, packetPayload.remaining());
Assert.assertEquals(0x33, packetPayload.get());
Assert.assertEquals(0x44, packetPayload.get());
Assert.assertEquals(0x55, packetPayload.get());
packet = packetizer.packetize(channel, 1024);
packetPayload = packet.getPayload();
Assert.assertEquals(31, packet.getIpv4Header().getTotalLength());
Assert.assertEquals(3, packetPayload.remaining());
Assert.assertEquals(0x66, packetPayload.get());
Assert.assertEquals(0x77, packetPayload.get());
Assert.assertEquals((byte) 0x88, packetPayload.get());
}
}
================================================
FILE: relay-java/src/test/java/com/genymobile/gnirehtet/relay/StreamBufferTest.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
import org.junit.Assert;
import org.junit.Test;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.ByteChannel;
import java.nio.channels.Channels;
import java.nio.channels.WritableByteChannel;
@SuppressWarnings("checkstyle:MagicNumber")
public class StreamBufferTest {
private static ByteBuffer createChunk() {
byte[] data = {0, 1, 2, 3, 4, 5};
return ByteBuffer.wrap(data);
}
@Test
public void testSimple() throws IOException {
ByteBuffer buffer = createChunk();
StreamBuffer streamBuffer = new StreamBuffer(9);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
WritableByteChannel channel = Channels.newChannel(bos);
streamBuffer.readFrom(buffer);
streamBuffer.writeTo(channel);
byte[] result = bos.toByteArray();
Assert.assertArrayEquals(buffer.array(), result);
}
static class DevNullChannel implements ByteChannel {
private int writeChunkSize;
DevNullChannel(int writeChunkSize) {
this.writeChunkSize = writeChunkSize;
}
@Override
public int read(ByteBuffer byteBuffer) {
return 0;
}
@Override
public int write(ByteBuffer byteBuffer) {
int consume = Math.min(writeChunkSize, byteBuffer.remaining());
byteBuffer.position(byteBuffer.position() + consume);
return consume;
}
@Override
public boolean isOpen() {
return false;
}
@Override
public void close() {
// do nothing
}
}
@Test
public void testCircular() throws IOException {
ByteBuffer buffer = createChunk();
StreamBuffer streamBuffer = new StreamBuffer(9);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
WritableByteChannel channel = Channels.newChannel(bos);
// put 6 bytes
streamBuffer.readFrom(buffer);
// consume 3 bytes
streamBuffer.writeTo(new DevNullChannel(3));
// put test data
buffer.rewind();
streamBuffer.readFrom(buffer);
// consume 3 bytes (so that the first 6 bytes are totally consumed, and the "tail" position is 6)
streamBuffer.writeTo(new DevNullChannel(3));
// consume test data
streamBuffer.writeTo(channel);
// StreamBuffer is expected to break writes at circular buffer boundaries (capacity + 1)
// This is not a requirement, but this verifies that the implementation works as expected
byte[] result = bos.toByteArray();
byte[] expected = {0, 1, 2, 3};
Assert.assertArrayEquals(expected, result);
// write the remaining
streamBuffer.writeTo(channel);
result = bos.toByteArray();
Assert.assertArrayEquals(buffer.array(), result);
}
@Test
public void testNotEnoughSpace() throws IOException {
ByteBuffer buffer = createChunk();
StreamBuffer streamBuffer = new StreamBuffer(9);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
WritableByteChannel channel = Channels.newChannel(bos);
streamBuffer.readFrom(buffer);
buffer.rewind();
streamBuffer.readFrom(buffer);
Assert.assertEquals(3, buffer.remaining());
streamBuffer.writeTo(channel);
byte[] result = bos.toByteArray();
byte[] expected = {0, 1, 2, 3, 4, 5, 0, 1, 2};
Assert.assertArrayEquals(expected, result);
}
}
================================================
FILE: relay-java/src/test/java/com/genymobile/gnirehtet/relay/TCPHeaderTest.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
import org.junit.Assert;
import org.junit.Ignore;
import org.junit.Test;
import java.nio.ByteBuffer;
@SuppressWarnings("checkstyle:MagicNumber")
public class TCPHeaderTest {
private static ByteBuffer createMockPacket() {
ByteBuffer buffer = ByteBuffer.allocate(64);
buffer.put((byte) ((4 << 4) | 5)); // versionAndIHL
buffer.put((byte) 0); // ToS
buffer.putShort((short) 44); // total length 20 + 20 + 4
buffer.putInt(0); // IdFlagsFragmentOffset
buffer.put((byte) 0); // TTL
buffer.put((byte) 6); // protocol (TCP)
buffer.putShort((short) 0); // checksum
buffer.putInt(0x12345678); // source address
buffer.putInt(0xa2a24242); // destination address
buffer.putShort((short) 0x1234); // source port
buffer.putShort((short) 0x5678); // destination port
buffer.putInt(0x111); // sequence number
buffer.putInt(0x222); // acknowledgment number
buffer.putShort((short) (5 << 12)); // data offset + flags(0)
buffer.putShort((short) 0); // window (don't care for these tests)
buffer.putShort((short) 0); // checksum
buffer.putShort((short) 0); // urgent pointer
buffer.putInt(0x1122eeff); // payload
return buffer;
}
private static ByteBuffer createMockOddPacket() {
ByteBuffer buffer = ByteBuffer.allocate(64);
buffer.put((byte) ((4 << 4) | 5)); // versionAndIHL
buffer.put((byte) 0); // ToS
buffer.putShort((short) 45); // total length 20 + 20 + 5
buffer.putInt(0); // IdFlagsFragmentOffset
buffer.put((byte) 0); // TTL
buffer.put((byte) 6); // protocol (TCP)
buffer.putShort((short) 0); // checksum
buffer.putInt(0x12345678); // source address
buffer.putInt(0xa2a24242); // destination address
buffer.putShort((short) 0x1234); // source port
buffer.putShort((short) 0x5678); // destination port
buffer.putInt(0x111); // sequence number
buffer.putInt(0x222); // acknowledgment number
buffer.putShort((short) (5 << 12)); // data offset + flags(0)
buffer.putShort((short) 0); // window (don't care for these tests)
buffer.putShort((short) 0); // checksum
buffer.putShort((short) 0); // urgent pointer
// payload
buffer.putInt(0x1122eeff);
buffer.put((byte) 0x88);
return buffer;
}
private static ByteBuffer createMockTCPHeader() {
ByteBuffer buffer = ByteBuffer.allocate(20);
buffer.putShort((short) 0x1234); // source port
buffer.putShort((short) 0x5678); // destination port
buffer.putInt(0x111); // sequence number
buffer.putInt(0x222); // acknowledgment number
buffer.putShort((short) (5 << 12)); // data offset + flags(0)
buffer.putShort((short) 0); // window (don't care for these tests)
buffer.putShort((short) 0); // checksum
buffer.putShort((short) 0); // urgent pointer
buffer.flip();
return buffer;
}
@Test
public void testEditHeaders() {
ByteBuffer buffer = createMockTCPHeader();
TCPHeader header = new TCPHeader(buffer);
header.setSourcePort(1111);
header.setDestinationPort(2222);
header.setSequenceNumber(300);
header.setAcknowledgementNumber(101);
header.setFlags(TCPHeader.FLAG_FIN | TCPHeader.FLAG_ACK);
Assert.assertEquals(1111, header.getSourcePort());
Assert.assertEquals(2222, header.getDestinationPort());
Assert.assertEquals(300, header.getSequenceNumber());
Assert.assertEquals(101, header.getAcknowledgementNumber());
Assert.assertEquals(TCPHeader.FLAG_FIN | TCPHeader.FLAG_ACK, header.getFlags());
// assert the buffer has been modified
int sourcePort = Short.toUnsignedInt(buffer.getShort(0));
int destinationPort = Short.toUnsignedInt(buffer.getShort(2));
int sequenceNumber = buffer.getInt(4);
int acknowledgementNumber = buffer.getInt(8);
short dataOffsetAndFlags = buffer.getShort(12);
Assert.assertEquals(1111, sourcePort);
Assert.assertEquals(2222, destinationPort);
Assert.assertEquals(300, sequenceNumber);
Assert.assertEquals(101, acknowledgementNumber);
Assert.assertEquals(0x5011, dataOffsetAndFlags);
header.swapSourceAndDestination();
Assert.assertEquals(2222, header.getSourcePort());
Assert.assertEquals(1111, header.getDestinationPort());
sourcePort = Short.toUnsignedInt(buffer.getShort(0));
destinationPort = Short.toUnsignedInt(buffer.getShort(2));
Assert.assertEquals(2222, sourcePort);
Assert.assertEquals(1111, destinationPort);
}
@Test
public void testComputeChecksum() {
ByteBuffer buffer = createMockPacket();
buffer.flip();
IPv4Packet packet = new IPv4Packet(buffer);
TCPHeader tcpHeader = (TCPHeader) packet.getTransportHeader();
// set a fake checksum value to assert that it is correctly computed
buffer.putShort(36, (short) 0x79);
tcpHeader.computeChecksum(packet.getIpv4Header(), packet.getPayload());
// pseudo-header
int sum = 0x1234 + 0x5678 + 0xa2a2 + 0x4242 + 0x0006 + 0x0018;
// header
sum += 0x1234 + 0x5678 + 0x0000 + 0x0111 + 0x0000 + 0x0222 + 0x5000 + 0x0000 + 0x0000 + 0x0000;
// payload
sum += 0x1122 + 0xeeff;
while ((sum & ~0xffff) != 0) {
sum = (sum & 0xffff) + (sum >> 16);
}
short checksum = (short) ~sum;
Assert.assertEquals(checksum, tcpHeader.getChecksum());
}
@Test
public void testComputeChecksumOddLength() {
ByteBuffer buffer = createMockOddPacket();
buffer.flip();
IPv4Packet packet = new IPv4Packet(buffer);
TCPHeader tcpHeader = (TCPHeader) packet.getTransportHeader();
// set a fake checksum value to assert that it is correctly computed
buffer.putShort(36, (short) 0x79);
tcpHeader.computeChecksum(packet.getIpv4Header(), packet.getPayload());
// pseudo-header
int sum = 0x1234 + 0x5678 + 0xa2a2 + 0x4242 + 0x0006 + 0x0019;
// header
sum += 0x1234 + 0x5678 + 0x0000 + 0x0111 + 0x0000 + 0x0222 + 0x5000 + 0x0000 + 0x0000 + 0x0000;
// payload
sum += 0x1122 + 0xeeff + 0x8800;
while ((sum & ~0xffff) != 0) {
sum = (sum & 0xffff) + (sum >> 16);
}
short checksum = (short) ~sum;
Assert.assertEquals(checksum, tcpHeader.getChecksum());
}
@Test
public void testCopyTo() {
ByteBuffer buffer = createMockTCPHeader();
TCPHeader header = new TCPHeader(buffer);
ByteBuffer target = ByteBuffer.allocate(40);
target.position(12);
TCPHeader copy = header.copyTo(target);
copy.setSourcePort(9999);
Assert.assertEquals(32, target.position());
Assert.assertEquals("Header must modify target", 9999, target.getShort(12));
Assert.assertEquals("Header must not modify buffer", 0x1234, buffer.getShort(0));
}
private static ByteBuffer createLongPacket() {
ByteBuffer buffer = ByteBuffer.allocate(2048);
buffer.put((byte) ((4 << 4) | 5)); // versionAndIHL
buffer.put((byte) 0); // ToS
buffer.putShort((short) 1240); // total length 20 + 20 + 1200
buffer.putInt(0); // IdFlagsFragmentOffset
buffer.put((byte) 0); // TTL
buffer.put((byte) 6); // protocol (TCP)
buffer.putShort((short) 0); // checksum
buffer.putInt(0x12345678); // source address
buffer.putInt(0xa2a24242); // destination address
buffer.putShort((short) 0x1234); // source port
buffer.putShort((short) 0x5678); // destination port
buffer.putInt(0x111); // sequence number
buffer.putInt(0x222); // acknowledgment number
buffer.putShort((short) (5 << 12)); // data offset + flags(0)
buffer.putShort((short) 0); // window (don't care for these tests)
buffer.putShort((short) 0); // checksum
buffer.putShort((short) 0); // urgent pointer
// payload
for (int i = 0; i < 1200; ++i) {
buffer.put((byte) i);
}
return buffer;
}
@Ignore // manual benchmark
@Test
public void benchComputeChecksum() {
ByteBuffer buffer = createLongPacket();
buffer.flip();
IPv4Packet packet = new IPv4Packet(buffer);
TCPHeader tcpHeader = (TCPHeader) packet.getTransportHeader();
long start = System.currentTimeMillis();
for (int i = 0; i < 5000000; ++i) {
tcpHeader.computeChecksum(packet.getIpv4Header(), packet.getPayload());
}
long duration = System.currentTimeMillis() - start;
System.out.println("5000000 TCP checksums: " + duration + "ms");
}
}
================================================
FILE: relay-java/src/test/java/com/genymobile/gnirehtet/relay/UDPHeaderTest.java
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.genymobile.gnirehtet.relay;
import org.junit.Assert;
import org.junit.Test;
import java.nio.ByteBuffer;
@SuppressWarnings("checkstyle:MagicNumber")
public class UDPHeaderTest {
private static ByteBuffer createMockHeaders() {
ByteBuffer buffer = ByteBuffer.allocate(8);
buffer.putShort((short) 1234); // source port
buffer.putShort((short) 5678); // destination port
buffer.putShort((short) 42); // length
buffer.putShort((short) 0); // checksum
return buffer;
}
@Test
public void testParsePacketHeaders() {
UDPHeader header = new UDPHeader(createMockHeaders());
Assert.assertNotNull("Valid UDP header not parsed", header);
Assert.assertEquals(1234, header.getSourcePort());
Assert.assertEquals(5678, header.getDestinationPort());
}
@Test
public void testEditHeaders() {
ByteBuffer buffer = createMockHeaders();
UDPHeader header = new UDPHeader(buffer);
header.setSourcePort(1111);
header.setDestinationPort(2222);
header.setPayloadLength(34);
Assert.assertEquals(1111, header.getSourcePort());
Assert.assertEquals(2222, header.getDestinationPort());
// assert the buffer has been modified
int sourcePort = Short.toUnsignedInt(buffer.getShort(0));
int destinationPort = Short.toUnsignedInt(buffer.getShort(2));
int length = Short.toUnsignedInt(buffer.getShort(4));
Assert.assertEquals(1111, sourcePort);
Assert.assertEquals(2222, destinationPort);
Assert.assertEquals(42, length);
header.swapSourceAndDestination();
Assert.assertEquals(2222, header.getSourcePort());
Assert.assertEquals(1111, header.getDestinationPort());
sourcePort = Short.toUnsignedInt(buffer.getShort(0));
destinationPort = Short.toUnsignedInt(buffer.getShort(2));
Assert.assertEquals(2222, sourcePort);
Assert.assertEquals(1111, destinationPort);
}
@Test
public void testCopyTo() {
ByteBuffer buffer = createMockHeaders();
UDPHeader header = new UDPHeader(buffer);
ByteBuffer target = ByteBuffer.allocate(32);
target.position(12);
UDPHeader copy = header.copyTo(target);
copy.setSourcePort(9999);
Assert.assertEquals(20, target.position());
Assert.assertEquals("Header must modify target", 9999, target.getShort(12));
Assert.assertEquals("Header must not modify buffer", 1234, buffer.getShort(0));
}
}
================================================
FILE: relay-rust/.gitignore
================================================
target/
**/*.rs.bk
================================================
FILE: relay-rust/Cargo.toml
================================================
[package]
name = "gnirehtet"
version = "2.5.1"
authors = ["Romain Vimont "]
edition = "2018"
[lib]
name = "relaylib"
path = "src/lib.rs"
[dependencies]
mio = "0.6" # for async I/O
slab = "0.4" # helper for mio Tokens
log = "0.4" # for logs
chrono = "0.4" # for formatting timestamp in logs
byteorder = "1.3" # for reading/writing binary
rand = "0.7" # for random TCP sequence number
ctrlc = { version = "3.0", features = ["termination"] } # for handling Ctrl+C
[profile.release]
lto = true # link-time optimization
================================================
FILE: relay-rust/build.gradle
================================================
task debug(type: Exec) {
commandLine 'cargo', 'build'
}
task release(type: Exec) {
commandLine 'cargo', 'build', '--release'
}
task test(type: Exec) {
commandLine 'cargo', 'test'
}
task install(type: Exec) {
commandLine 'cargo', 'install'
}
task clean(type: Exec) {
commandLine 'cargo', 'clean'
}
task checkstyle(type: Exec) {
commandLine 'cargo', 'fmt', '--', '--check'
}
task check(dependsOn: ['checkstyle', 'test'])
task build(dependsOn: ['check', 'debug', 'release'])
// Requirements:
//
// Install the cross-compile toolchain (on Debian):
// sudo apt install gcc-mingw-w64-x86-64
// rustup target add x86_64-pc-windows-gnu
//
// Add the following lines to ~/.cargo/config:
// [target.x86_64-pc-windows-gnu]
// linker = "x86_64-w64-mingw32-gcc"
// ar = "x86_64-w64-mingw32-gcc-ar"
task releaseCrossToWindows(type: Exec) {
commandLine 'cargo', 'build', '--release', '--target=x86_64-pc-windows-gnu'
}
================================================
FILE: relay-rust/scripts/gnirehtet-run.cmd
================================================
@gnirehtet.exe run
@pause
================================================
FILE: relay-rust/src/adb_monitor.rs
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use log::*;
use relaylib::byte_buffer::ByteBuffer;
use std::io::{self, Write};
use std::net::{SocketAddr, TcpStream};
use std::process;
use std::str;
use std::thread;
use std::time::Duration;
const TAG: &str = "AdbMonitor";
pub trait AdbMonitorCallback {
fn on_new_device_connected(&self, serial: &str);
}
impl AdbMonitorCallback for F
where
F: Fn(&str),
{
fn on_new_device_connected(&self, serial: &str) {
self(serial);
}
}
pub struct AdbMonitor {
callback: Box,
buf: ByteBuffer,
connected_devices: Vec,
}
impl AdbMonitor {
const TRACK_DEVICES_REQUEST: &'static [u8] = b"0012host:track-devices";
const BUFFER_SIZE: usize = 1024;
const RETRY_DELAY_ADB_DAEMON_OK: u64 = 1000;
const RETRY_DELAY_ADB_DAEMON_KO: u64 = 5000;
pub fn new(callback: Box) -> Self {
Self {
callback,
buf: ByteBuffer::new(Self::BUFFER_SIZE),
connected_devices: Vec::new(),
}
}
pub fn monitor(&mut self) {
loop {
if let Err(err) = self.track_devices() {
error!(target: TAG, "Failed to monitor adb devices: {}", err);
Self::repair_adb_daemon();
}
}
}
fn track_devices(&mut self) -> io::Result<()> {
let adbd_addr = SocketAddr::from(([127, 0, 0, 1], 5037));
let mut stream = TcpStream::connect(adbd_addr)?;
self.track_devices_on_stream(&mut stream)
}
fn track_devices_on_stream(&mut self, stream: &mut TcpStream) -> io::Result<()> {
stream.write_all(Self::TRACK_DEVICES_REQUEST)?;
if self.consume_okay(stream)? {
loop {
let packet = self.next_packet(stream)?;
self.handle_packet(packet.as_str());
}
}
Ok(())
}
fn consume_okay(&mut self, stream: &mut TcpStream) -> io::Result {
while self.buf.peek().len() < 4 {
self.buf.read_from(stream)?;
}
let ok = b"OKAY" == &self.buf.peek()[0..4];
self.buf.consume(4);
Ok(ok)
}
fn read_packet(buf: &mut ByteBuffer) -> io::Result> {
let packet_length = Self::available_packet_length(buf.peek())?;
if let Some(len) = packet_length {
// retrieve the content and consume the packet
let data = Self::binary_to_string(&buf.peek()[4..len])?;
buf.consume(len);
Ok(Some(data))
} else {
Ok(None)
}
}
fn next_packet(&mut self, stream: &mut TcpStream) -> io::Result {
loop {
let packet = Self::read_packet(&mut self.buf)?;
if let Some(packet) = packet {
return Ok(packet);
} else {
self.fill_buffer_from(stream)?;
}
}
}
fn fill_buffer_from(&mut self, stream: &mut TcpStream) -> io::Result<()> {
match self.buf.read_from(stream) {
Ok(false) => Err(io::Error::new(
io::ErrorKind::UnexpectedEof,
"ADB daemon closed the track-devices connexion",
)),
Ok(_) => Ok(()),
Err(err) => Err(err),
}
}
fn available_packet_length(input: &[u8]) -> io::Result> {
if input.len() < 4 {
Ok(None)
} else {
// each packet contains 4 bytes representing the String length in hexa, followed by a
// list of device information;
// each line contains: the device serial, `\t', the state, '\n'
// for example:
// "00360123456789abcdef\tdevice\nfedcba9876543210\tunauthorized\n":
// - 0036 indicates that the data is 0x36 (54) bytes length
// - the device with serial 0123456789abcdef is connected
// - the device with serial fedcba9876543210 is unauthorized
let len = Self::parse_length(&input[0..4])?;
if len > Self::BUFFER_SIZE as u32 {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
format!("Packet size should not be that big: {}", len),
));
}
if input.len() - 4usize >= len as usize {
Ok(Some(4usize + len as usize))
} else {
// not enough data
Ok(None)
}
}
}
fn handle_packet(&mut self, packet: &str) {
let current_connected_devices = self.parse_connected_devices(packet);
for serial in ¤t_connected_devices {
if !self.connected_devices.contains(serial) {
self.callback.on_new_device_connected(serial.as_str());
}
}
self.connected_devices = current_connected_devices;
}
fn parse_connected_devices(&self, packet: &str) -> Vec {
packet
.lines()
.filter_map(|line| {
let mut split = line.split_whitespace();
if let Some(serial) = split.next() {
if let Some(state) = split.next() {
if state == "device" {
return Some(serial.to_string());
}
}
}
None
})
.collect()
}
fn parse_length(data: &[u8]) -> io::Result {
assert!(data.len() == 4, "Invalid length field value");
let hexa = str::from_utf8(data).map_err(|err| {
io::Error::new(
io::ErrorKind::InvalidInput,
format!("Cannot read hexa length as UTF-8 ({})", err),
)
})?;
u32::from_str_radix(hexa, 0x10).map_err(|err| {
io::Error::new(
io::ErrorKind::InvalidInput,
format!("Cannot parse hexa length ({})", err),
)
})
}
fn repair_adb_daemon() {
if Self::start_adb_daemon() {
thread::sleep(Duration::from_millis(Self::RETRY_DELAY_ADB_DAEMON_OK));
} else {
thread::sleep(Duration::from_millis(Self::RETRY_DELAY_ADB_DAEMON_KO));
}
}
fn start_adb_daemon() -> bool {
info!(target: TAG, "Restarting adb daemon");
match process::Command::new("adb")
.args(&["start-server"])
.status()
{
Ok(exit_status) => {
if exit_status.success() {
true
} else {
error!(
target: TAG,
"Could not restart adb daemon (exited on error)"
);
false
}
}
Err(err) => {
error!(target: TAG, "Could not restart adb daemon: {}", err);
false
}
}
}
fn binary_to_string(data: &[u8]) -> io::Result {
let raw_content = data.to_vec();
let content = String::from_utf8(raw_content);
if let Ok(content) = content {
Ok(content)
} else {
Err(io::Error::new(
io::ErrorKind::InvalidInput,
"Track-devices string is not valid UTF-8",
))
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::cell::RefCell;
use std::rc::Rc;
#[test]
fn test_read_valid_packet() {
let mut buf = ByteBuffer::new(64);
let raw = "00180123456789ABCDEF\tdevice\n".as_bytes();
let mut cursor = io::Cursor::new(raw);
buf.read_from(&mut cursor).unwrap();
let packet = AdbMonitor::read_packet(&mut buf).unwrap().unwrap();
assert_eq!("0123456789ABCDEF\tdevice\n", packet);
}
#[test]
fn test_read_valid_packets() {
let mut buf = ByteBuffer::new(64);
let raw = "00300123456789ABCDEF\tdevice\nFEDCBA9876543210\tdevice\n".as_bytes();
let mut cursor = io::Cursor::new(raw);
buf.read_from(&mut cursor).unwrap();
let packet = AdbMonitor::read_packet(&mut buf).unwrap().unwrap();
assert_eq!(
"0123456789ABCDEF\tdevice\nFEDCBA9876543210\tdevice\n",
packet
);
}
#[test]
fn test_read_valid_packet_with_garbage() {
let mut buf = ByteBuffer::new(64);
let raw = "00180123456789ABCDEF\tdevice\ngarbage".as_bytes();
let mut cursor = io::Cursor::new(raw);
buf.read_from(&mut cursor).unwrap();
let packet = AdbMonitor::read_packet(&mut buf).unwrap().unwrap();
assert_eq!("0123456789ABCDEF\tdevice\n", packet);
}
#[test]
fn test_read_short_packet() {
let mut buf = ByteBuffer::new(64);
let raw = "00180123456789ABCDEF\tdevi".as_bytes();
let mut cursor = io::Cursor::new(raw);
buf.read_from(&mut cursor).unwrap();
let packet = AdbMonitor::read_packet(&mut buf).unwrap();
assert!(packet.is_none());
}
#[test]
fn test_handle_packet_device() {
let serial = Rc::new(RefCell::new(None));
let serial_clone = serial.clone();
let mut monitor = AdbMonitor::new(Box::new(move |serial: &str| {
serial_clone.replace(Some(serial.to_string()));
}));
monitor.handle_packet("0123456789ABCDEF\tdevice\n");
assert_eq!("0123456789ABCDEF", serial.borrow().as_ref().unwrap());
}
#[test]
fn test_handle_packet_offline() {
let serial = Rc::new(RefCell::new(None));
let serial_clone = serial.clone();
let mut monitor = AdbMonitor::new(Box::new(move |serial: &str| {
serial_clone.replace(Some(serial.to_string()));
}));
monitor.handle_packet("0123456789ABCDEF\toffline\n");
assert!(serial.borrow().is_none());
}
#[test]
fn test_multiple_connected_devices() {
let serials = Rc::new(RefCell::new(Vec::new()));
let serials_clone = serials.clone();
let mut monitor = AdbMonitor::new(Box::new(move |serial: &str| {
serials_clone.borrow_mut().push(serial.to_string());
}));
monitor.handle_packet("0123456789ABCDEF\tdevice\nFEDCBA9876543210\tdevice\n");
let vec = serials.borrow();
assert_eq!(2, vec.len());
assert_eq!("0123456789ABCDEF", vec[0]);
assert_eq!("FEDCBA9876543210", vec[1]);
}
#[test]
fn test_multiple_connected_devices_with_disconnection() {
let serials = Rc::new(RefCell::new(Vec::new()));
let serials_clone = serials.clone();
let mut monitor = AdbMonitor::new(Box::new(move |serial: &str| {
serials_clone.borrow_mut().push(serial.to_string());
}));
monitor.handle_packet("0123456789ABCDEF\tdevice\nFEDCBA9876543210\tdevice\n");
monitor.handle_packet("0123456789ABCDEF\tdevice\n");
monitor.handle_packet("0123456789ABCDEF\tdevice\nFEDCBA9876543210\tdevice\n");
let vec = serials.borrow();
assert_eq!(3, vec.len());
assert_eq!("0123456789ABCDEF", vec[0]);
assert_eq!("FEDCBA9876543210", vec[1]);
assert_eq!("FEDCBA9876543210", vec[2]);
}
}
================================================
FILE: relay-rust/src/cli_args.rs
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
pub const PARAM_NONE: u8 = 0;
pub const PARAM_SERIAL: u8 = 1;
pub const PARAM_DNS_SERVERS: u8 = 1 << 1;
pub const PARAM_ROUTES: u8 = 1 << 2;
pub const PARAM_PORT: u8 = 1 << 3;
pub const DEFAULT_PORT: u16 = 31416;
pub struct CommandLineArguments {
serial: Option,
dns_servers: Option,
routes: Option,
port: u16,
}
impl CommandLineArguments {
// simple String as errors is sufficient, we never need to inspect them
pub fn parse>(accepted_parameters: u8, args: Vec) -> Result {
let mut serial = None;
let mut dns_servers = None;
let mut routes = None;
let mut port = 0;
let mut iter = args.into_iter();
while let Some(arg) = iter.next() {
let arg = arg.into();
if (accepted_parameters & PARAM_DNS_SERVERS) != 0 && "-d" == arg {
if dns_servers.is_some() {
return Err(String::from("DNS servers already set"));
}
if let Some(value) = iter.next() {
dns_servers = Some(value.into());
} else {
return Err(String::from("Missing -d parameter"));
}
} else if (accepted_parameters & PARAM_ROUTES) != 0 && "-r" == arg {
if routes.is_some() {
return Err(String::from("Routes already set"));
}
if let Some(value) = iter.next() {
routes = Some(value.into());
} else {
return Err(String::from("Missing -r parameter"));
}
} else if (accepted_parameters & PARAM_PORT) != 0 && "-p" == arg {
if port != 0 {
return Err(String::from("Port already set"));
}
if let Some(value) = iter.next() {
port = value.into().parse().unwrap();
if port == 0 {
return Err(String::from("Invalid port: 0"));
}
} else {
return Err(String::from("Missing -p parameter"));
}
} else if (accepted_parameters & PARAM_SERIAL) != 0 && serial.is_none() {
serial = Some(arg);
} else {
return Err(format!("Unexpected argument: \"{}\"", arg));
}
}
if port == 0 {
port = DEFAULT_PORT;
}
Ok(Self {
serial,
dns_servers,
routes,
port,
})
}
pub fn serial(&self) -> Option<&str> {
self.serial.as_deref()
}
pub fn dns_servers(&self) -> Option<&str> {
self.dns_servers.as_deref()
}
pub fn routes(&self) -> Option<&str> {
self.routes.as_deref()
}
pub fn port(&self) -> u16 {
self.port
}
}
#[cfg(test)]
mod tests {
use super::*;
const ACCEPT_ALL: u8 = PARAM_SERIAL | PARAM_DNS_SERVERS | PARAM_ROUTES;
#[test]
fn test_no_args() {
let args = CommandLineArguments::parse(ACCEPT_ALL, Vec::<&str>::new()).unwrap();
assert!(args.serial.is_none());
assert!(args.dns_servers.is_none());
}
#[test]
fn test_serial_only() {
let raw_args = vec!["myserial"];
let args = CommandLineArguments::parse(ACCEPT_ALL, raw_args).unwrap();
assert_eq!("myserial", args.serial.unwrap());
}
#[test]
fn test_invalid_paramater() {
let raw_args = vec!["myserial", "other"];
assert!(CommandLineArguments::parse(ACCEPT_ALL, raw_args).is_err());
}
#[test]
fn test_dns_servers_only() {
let raw_args = vec!["-d", "8.8.8.8"];
let args = CommandLineArguments::parse(ACCEPT_ALL, raw_args).unwrap();
assert!(args.serial.is_none());
assert_eq!("8.8.8.8", args.dns_servers.unwrap());
}
#[test]
fn test_serial_and_dns_servers() {
let raw_args = vec!["myserial", "-d", "8.8.8.8"];
let args = CommandLineArguments::parse(ACCEPT_ALL, raw_args).unwrap();
assert_eq!("myserial", args.serial.unwrap());
assert_eq!("8.8.8.8", args.dns_servers.unwrap());
}
#[test]
fn test_dns_servers_and_serial() {
let raw_args = vec!["-d", "8.8.8.8", "myserial"];
let args = CommandLineArguments::parse(ACCEPT_ALL, raw_args).unwrap();
assert_eq!("myserial", args.serial.unwrap());
assert_eq!("8.8.8.8", args.dns_servers.unwrap());
}
#[test]
fn test_serial_with_no_dns_servers_parameter() {
let raw_args = vec!["myserial", "-d"];
assert!(CommandLineArguments::parse(ACCEPT_ALL, raw_args).is_err());
}
#[test]
fn test_no_dns_servers_parameter() {
let raw_args = vec!["-d"];
assert!(CommandLineArguments::parse(ACCEPT_ALL, raw_args).is_err());
}
#[test]
fn test_routes_parameter() {
let raw_args = vec!["-r", "1.2.3.0/24"];
let args = CommandLineArguments::parse(ACCEPT_ALL, raw_args).unwrap();
assert_eq!("1.2.3.0/24", args.routes.unwrap());
}
#[test]
fn test_no_routes_parameter() {
let raw_args = vec!["-r"];
assert!(CommandLineArguments::parse(ACCEPT_ALL, raw_args).is_err());
}
}
================================================
FILE: relay-rust/src/execution_error.rs
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use std::error;
use std::fmt;
use std::io;
#[cfg(unix)]
use std::os::unix::process::ExitStatusExt;
use std::process::ExitStatus;
#[derive(Debug)]
pub enum CommandExecutionError {
ProcessIo(ProcessIoError),
ProcessStatus(ProcessStatusError),
Io(io::Error),
}
#[derive(Debug)]
pub struct ProcessStatusError {
cmd: Cmd,
termination: Termination,
}
#[derive(Debug)]
pub struct ProcessIoError {
cmd: Cmd,
error: io::Error,
}
#[derive(Debug)]
pub struct Cmd {
command: String,
args: Vec,
}
#[derive(Debug)]
pub enum Termination {
Value(i32),
#[cfg(unix)]
Signal(i32),
}
impl Termination {
fn from(status: ExitStatus) -> Self {
match status.code() {
Some(code) => Termination::Value(code),
#[cfg(unix)]
None => Termination::Signal(status.signal().unwrap()),
#[cfg(not(unix))]
None => panic!("Unexpected signal termination on non-unix system"),
}
}
}
impl fmt::Display for Cmd {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{} {:?}", self.command, self.args)
}
}
impl Cmd {
pub fn new(command: S1, args: Vec) -> Cmd
where
S1: Into,
S2: Into,
{
Self {
command: command.into(),
args: args.into_iter().map(Into::into).collect::>(),
}
}
}
impl ProcessStatusError {
pub fn new(cmd: Cmd, status: ExitStatus) -> Self {
Self {
cmd,
termination: Termination::from(status),
}
}
}
impl fmt::Display for ProcessStatusError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self.termination {
Termination::Value(code) => {
write!(f, "Command {} returned with value {}", self.cmd, code)
}
#[cfg(unix)]
Termination::Signal(sig) => {
write!(f, "Command {} terminated by signal {}", self.cmd, sig)
}
}
}
}
impl error::Error for ProcessStatusError {}
impl ProcessIoError {
pub fn new(cmd: Cmd, error: io::Error) -> Self {
Self { cmd, error }
}
}
impl fmt::Display for ProcessIoError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Command {} failed: {}", self.cmd, self.error)
}
}
impl error::Error for ProcessIoError {
fn source(&self) -> Option<&(dyn error::Error + 'static)> {
Some(&self.error)
}
}
impl fmt::Display for CommandExecutionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CommandExecutionError::ProcessIo(ref err) => write!(f, "{}", err),
CommandExecutionError::ProcessStatus(ref err) => write!(f, "{}", err),
CommandExecutionError::Io(ref err) => write!(f, "IO error: {}", err),
}
}
}
impl error::Error for CommandExecutionError {
fn source(&self) -> Option<&(dyn error::Error + 'static)> {
match *self {
CommandExecutionError::ProcessIo(ref err) => Some(err),
CommandExecutionError::ProcessStatus(ref err) => Some(err),
CommandExecutionError::Io(ref err) => Some(err),
}
}
}
impl From for CommandExecutionError {
fn from(error: ProcessIoError) -> Self {
CommandExecutionError::ProcessIo(error)
}
}
impl From for CommandExecutionError {
fn from(error: ProcessStatusError) -> Self {
CommandExecutionError::ProcessStatus(error)
}
}
impl From for CommandExecutionError {
fn from(error: io::Error) -> Self {
CommandExecutionError::Io(error)
}
}
================================================
FILE: relay-rust/src/lib.rs
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
mod relay;
pub use crate::relay::byte_buffer;
use crate::relay::Relay;
use std::io;
pub fn relay(port: u16) -> io::Result<()> {
Relay::new(port).run()
}
================================================
FILE: relay-rust/src/logger.rs
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use chrono::prelude::Local;
use log::*;
use std::io::{self, Write};
static LOGGER: SimpleLogger = SimpleLogger;
const THRESHOLD: LevelFilter = LevelFilter::Info;
pub struct SimpleLogger;
impl Log for SimpleLogger {
fn enabled(&self, metadata: &Metadata) -> bool {
metadata.level() <= THRESHOLD
}
fn log(&self, record: &Record) {
if self.enabled(record.metadata()) {
let date = Local::now();
let formatted_date = date.format("%Y-%m-%d %H:%M:%S%.3f");
let msg = format!(
"{} {} {}: {}",
formatted_date,
record.level(),
record.target(),
record.args()
);
if record.level() == Level::Error {
eprintln!("{}", msg);
} else {
println!("{}", msg);
}
}
}
fn flush(&self) {
io::stdout().flush().unwrap();
io::stderr().flush().unwrap();
}
}
pub fn init() -> Result<(), SetLoggerError> {
set_max_level(THRESHOLD);
set_logger(&LOGGER)
}
================================================
FILE: relay-rust/src/main.rs
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
extern crate chrono;
extern crate ctrlc;
#[macro_use]
extern crate log;
extern crate relaylib;
mod adb_monitor;
mod cli_args;
mod execution_error;
mod logger;
use crate::adb_monitor::AdbMonitor;
use crate::cli_args::CommandLineArguments;
use crate::execution_error::{Cmd, CommandExecutionError, ProcessIoError, ProcessStatusError};
use std::env;
use std::process::{self, exit};
use std::thread;
use std::time::Duration;
const TAG: &str = "Main";
const REQUIRED_APK_VERSION_CODE: &str = "9";
#[inline]
fn get_adb_path() -> String {
if let Some(env_adb) = std::env::var_os("ADB") {
env_adb.into_string().expect("invalid ADB value")
} else {
"adb".to_string()
}
}
#[inline]
fn get_apk_path() -> String {
if let Some(env_adb) = std::env::var_os("GNIREHTET_APK") {
env_adb.into_string().expect("invalid GNIREHTET_APK value")
} else {
"gnirehtet.apk".to_string()
}
}
const COMMANDS: &[&dyn Command] = &[
&InstallCommand,
&UninstallCommand,
&ReinstallCommand,
&RunCommand,
&AutorunCommand,
&StartCommand,
&AutostartCommand,
&StopCommand,
&RestartCommand,
&TunnelCommand,
&RelayCommand,
];
trait Command {
fn command(&self) -> &'static str;
fn accepted_parameters(&self) -> u8;
fn description(&self) -> &'static str;
fn execute(&self, args: &CommandLineArguments) -> Result<(), CommandExecutionError>;
}
struct InstallCommand;
struct UninstallCommand;
struct ReinstallCommand;
struct RunCommand;
struct AutorunCommand;
struct StartCommand;
struct AutostartCommand;
struct StopCommand;
struct RestartCommand;
struct TunnelCommand;
struct RelayCommand;
impl Command for InstallCommand {
fn command(&self) -> &'static str {
"install"
}
fn accepted_parameters(&self) -> u8 {
cli_args::PARAM_SERIAL
}
fn description(&self) -> &'static str {
"Install the client on the Android device and exit.\n\
If several devices are connected via adb, then serial must be\n\
specified."
}
fn execute(&self, args: &CommandLineArguments) -> Result<(), CommandExecutionError> {
cmd_install(args.serial())
}
}
impl Command for UninstallCommand {
fn command(&self) -> &'static str {
"uninstall"
}
fn accepted_parameters(&self) -> u8 {
cli_args::PARAM_SERIAL
}
fn description(&self) -> &'static str {
"Uninstall the client from the Android device and exit.\n\
If several devices are connected via adb, then serial must be\n\
specified."
}
fn execute(&self, args: &CommandLineArguments) -> Result<(), CommandExecutionError> {
cmd_uninstall(args.serial())
}
}
impl Command for ReinstallCommand {
fn command(&self) -> &'static str {
"reinstall"
}
fn accepted_parameters(&self) -> u8 {
cli_args::PARAM_SERIAL
}
fn description(&self) -> &'static str {
"Uninstall then install."
}
fn execute(&self, args: &CommandLineArguments) -> Result<(), CommandExecutionError> {
cmd_reinstall(args.serial())
}
}
impl Command for RunCommand {
fn command(&self) -> &'static str {
"run"
}
fn accepted_parameters(&self) -> u8 {
cli_args::PARAM_SERIAL
| cli_args::PARAM_DNS_SERVERS
| cli_args::PARAM_ROUTES
| cli_args::PARAM_PORT
}
fn description(&self) -> &'static str {
"Enable reverse tethering for exactly one device:\n \
- install the client if necessary;\n \
- start the client;\n \
- start the relay server;\n \
- on Ctrl+C, stop both the relay server and the client."
}
fn execute(&self, args: &CommandLineArguments) -> Result<(), CommandExecutionError> {
cmd_run(
args.serial(),
args.dns_servers(),
args.routes(),
args.port(),
)
}
}
impl Command for AutorunCommand {
fn command(&self) -> &'static str {
"autorun"
}
fn accepted_parameters(&self) -> u8 {
cli_args::PARAM_DNS_SERVERS | cli_args::PARAM_ROUTES | cli_args::PARAM_PORT
}
fn description(&self) -> &'static str {
"Enable reverse tethering for all devices:\n \
- monitor devices and start clients (autostart);\n \
- start the relay server."
}
fn execute(&self, args: &CommandLineArguments) -> Result<(), CommandExecutionError> {
cmd_autorun(args.dns_servers(), args.routes(), args.port())
}
}
impl Command for StartCommand {
fn command(&self) -> &'static str {
"start"
}
fn accepted_parameters(&self) -> u8 {
cli_args::PARAM_SERIAL
| cli_args::PARAM_DNS_SERVERS
| cli_args::PARAM_ROUTES
| cli_args::PARAM_PORT
}
fn description(&self) -> &'static str {
"Start a client on the Android device and exit.\n\
If several devices are connected via adb, then serial must be\n\
specified.\n\
If -d is given, then make the Android device use the specified\n\
DNS server(s). Otherwise, use 8.8.8.8 (Google public DNS).\n\
If -r is given, then only reverse tether the specified routes.\n\
Otherwise, use 0.0.0.0/0 (redirect the whole traffic).\n\
If -p is given, then make the relay server listen on the specified\n\
port. Otherwise, use port 31416.\n\
If the client is already started, then do nothing, and ignore\n\
the other parameters.\n\
10.0.2.2 is mapped to the host 'localhost'."
}
fn execute(&self, args: &CommandLineArguments) -> Result<(), CommandExecutionError> {
cmd_start(
args.serial(),
args.dns_servers(),
args.routes(),
args.port(),
)
}
}
impl Command for AutostartCommand {
fn command(&self) -> &'static str {
"autostart"
}
fn accepted_parameters(&self) -> u8 {
cli_args::PARAM_DNS_SERVERS | cli_args::PARAM_ROUTES | cli_args::PARAM_PORT
}
fn description(&self) -> &'static str {
"Listen for device connexions and start a client on every detected\n\
device.\n\
Accept the same parameters as the start command (excluding the\n\
serial, which will be taken from the detected device)."
}
fn execute(&self, args: &CommandLineArguments) -> Result<(), CommandExecutionError> {
cmd_autostart(args.dns_servers(), args.routes(), args.port())
}
}
impl Command for StopCommand {
fn command(&self) -> &'static str {
"stop"
}
fn accepted_parameters(&self) -> u8 {
cli_args::PARAM_SERIAL
}
fn description(&self) -> &'static str {
"Stop the client on the Android device and exit.\n\
If several devices are connected via adb, then serial must be\n\
specified."
}
fn execute(&self, args: &CommandLineArguments) -> Result<(), CommandExecutionError> {
cmd_stop(args.serial())
}
}
impl Command for RestartCommand {
fn command(&self) -> &'static str {
"restart"
}
fn accepted_parameters(&self) -> u8 {
cli_args::PARAM_SERIAL
| cli_args::PARAM_DNS_SERVERS
| cli_args::PARAM_ROUTES
| cli_args::PARAM_PORT
}
fn description(&self) -> &'static str {
"Stop then start."
}
fn execute(&self, args: &CommandLineArguments) -> Result<(), CommandExecutionError> {
cmd_stop(args.serial())?;
cmd_start(
args.serial(),
args.dns_servers(),
args.routes(),
args.port(),
)?;
Ok(())
}
}
impl Command for TunnelCommand {
fn command(&self) -> &'static str {
"tunnel"
}
fn accepted_parameters(&self) -> u8 {
cli_args::PARAM_SERIAL | cli_args::PARAM_PORT
}
fn description(&self) -> &'static str {
"Set up the 'adb reverse' tunnel.\n\
If a device is unplugged then plugged back while gnirehtet is\n\
active, resetting the tunnel is sufficient to get the\n\
connection back."
}
fn execute(&self, args: &CommandLineArguments) -> Result<(), CommandExecutionError> {
cmd_tunnel(args.serial(), args.port())
}
}
impl Command for RelayCommand {
fn command(&self) -> &'static str {
"relay"
}
fn accepted_parameters(&self) -> u8 {
cli_args::PARAM_NONE | cli_args::PARAM_PORT
}
fn description(&self) -> &'static str {
"Start the relay server in the current terminal."
}
fn execute(&self, args: &CommandLineArguments) -> Result<(), CommandExecutionError> {
cmd_relay(args.port())?;
Ok(())
}
}
fn cmd_install(serial: Option<&str>) -> Result<(), CommandExecutionError> {
info!(target: TAG, "Installing gnirehtet client...");
exec_adb(serial, vec!["install".into(), "-r".into(), get_apk_path()])
}
fn cmd_uninstall(serial: Option<&str>) -> Result<(), CommandExecutionError> {
info!(target: TAG, "Uninstalling gnirehtet client...");
exec_adb(serial, vec!["uninstall", "com.genymobile.gnirehtet"])
}
fn cmd_reinstall(serial: Option<&str>) -> Result<(), CommandExecutionError> {
cmd_uninstall(serial)?;
cmd_install(serial)?;
Ok(())
}
fn cmd_run(
serial: Option<&str>,
dns_servers: Option<&str>,
routes: Option<&str>,
port: u16,
) -> Result<(), CommandExecutionError> {
// start in parallel so that the relay server is ready when the client connects
async_start(serial, dns_servers, routes, port);
let ctrlc_serial = serial.map(String::from);
ctrlc::set_handler(move || {
info!(target: TAG, "Interrupted");
let serial = ctrlc_serial.as_ref().map(String::as_ref);
if let Err(err) = cmd_stop(serial) {
error!(target: TAG, "Cannot stop client: {}", err);
}
exit(0);
})
.expect("Error setting Ctrl-C handler");
cmd_relay(port)
}
fn cmd_autorun(
dns_servers: Option<&str>,
routes: Option<&str>,
port: u16,
) -> Result<(), CommandExecutionError> {
{
let autostart_dns_servers = dns_servers.map(String::from);
let autostart_routes = routes.map(String::from);
thread::spawn(move || {
let dns_servers = autostart_dns_servers.as_ref().map(String::as_ref);
let routes = autostart_routes.as_ref().map(String::as_ref);
if let Err(err) = cmd_autostart(dns_servers, routes, port) {
error!(target: TAG, "Cannot auto start clients: {}", err);
}
});
}
cmd_relay(port)
}
fn cmd_start(
serial: Option<&str>,
dns_servers: Option<&str>,
routes: Option<&str>,
port: u16,
) -> Result<(), CommandExecutionError> {
if must_install_client(serial)? {
cmd_install(serial)?;
// wait a bit after the app is installed so that intent actions are correctly
// registered
thread::sleep(Duration::from_millis(500));
}
info!(target: TAG, "Starting client...");
cmd_tunnel(serial, port)?;
let mut adb_args = vec![
"shell",
"am",
"start",
"-a",
"com.genymobile.gnirehtet.START",
"-n",
"com.genymobile.gnirehtet/.GnirehtetActivity",
];
if let Some(dns_servers) = dns_servers {
adb_args.append(&mut vec!["--esa", "dnsServers", dns_servers]);
}
if let Some(routes) = routes {
adb_args.append(&mut vec!["--esa", "routes", routes]);
}
exec_adb(serial, adb_args)
}
fn cmd_autostart(
dns_servers: Option<&str>,
routes: Option<&str>,
port: u16,
) -> Result<(), CommandExecutionError> {
let start_dns_servers = dns_servers.map(String::from);
let start_routes = routes.map(String::from);
let mut adb_monitor = AdbMonitor::new(Box::new(move |serial: &str| {
let dns_servers = start_dns_servers.as_ref().map(String::as_ref);
let routes = start_routes.as_ref().map(String::as_ref);
async_start(Some(serial), dns_servers, routes, port)
}));
adb_monitor.monitor();
Ok(())
}
fn cmd_stop(serial: Option<&str>) -> Result<(), CommandExecutionError> {
info!(target: TAG, "Stopping client...");
exec_adb(
serial,
vec![
"shell",
"am",
"start",
"-a",
"com.genymobile.gnirehtet.STOP",
"-n",
"com.genymobile.gnirehtet/.GnirehtetActivity",
],
)
}
fn cmd_tunnel(serial: Option<&str>, port: u16) -> Result<(), CommandExecutionError> {
exec_adb(
serial,
vec![
"reverse",
"localabstract:gnirehtet",
format!("tcp:{}", port).as_str(),
],
)
}
fn cmd_relay(port: u16) -> Result<(), CommandExecutionError> {
info!(target: TAG, "Starting relay server on port {}...", port);
relaylib::relay(port)?;
Ok(())
}
fn async_start(serial: Option<&str>, dns_servers: Option<&str>, routes: Option<&str>, port: u16) {
let start_serial = serial.map(String::from);
let start_dns_servers = dns_servers.map(String::from);
let start_routes = routes.map(String::from);
thread::spawn(move || {
let serial = start_serial.as_ref().map(String::as_ref);
let dns_servers = start_dns_servers.as_ref().map(String::as_ref);
let routes = start_routes.as_ref().map(String::as_ref);
if let Err(err) = cmd_start(serial, dns_servers, routes, port) {
error!(target: TAG, "Cannot start client: {}", err);
}
});
}
fn create_adb_args>(serial: Option<&str>, args: Vec) -> Vec {
let mut command = Vec::::new();
if let Some(serial) = serial {
command.push("-s".into());
command.push(serial.to_string());
}
for arg in args {
command.push(arg.into());
}
command
}
fn exec_adb>(
serial: Option<&str>,
args: Vec,
) -> Result<(), CommandExecutionError> {
let adb_args = create_adb_args(serial, args);
let adb = get_adb_path();
debug!(target: TAG, "Execute: {:?} {:?}", adb, adb_args);
match process::Command::new(&adb).args(&adb_args[..]).status() {
Ok(exit_status) => {
if exit_status.success() {
Ok(())
} else {
let cmd = Cmd::new(adb, adb_args);
Err(ProcessStatusError::new(cmd, exit_status).into())
}
}
Err(err) => {
let cmd = Cmd::new(adb, adb_args);
Err(ProcessIoError::new(cmd, err).into())
}
}
}
fn must_install_client(serial: Option<&str>) -> Result {
info!(target: TAG, "Checking gnirehtet client...");
let args = create_adb_args(
serial,
vec!["shell", "dumpsys", "package", "com.genymobile.gnirehtet"],
);
let adb = get_adb_path();
debug!(target: TAG, "Execute: {:?} {:?}", adb, args);
match process::Command::new(&adb).args(&args[..]).output() {
Ok(output) => {
if output.status.success() {
// the "regex" crate makes the binary far bigger, so just parse the versionCode
// manually
let dumpsys = String::from_utf8_lossy(&output.stdout[..]);
// read the versionCode of the installed package
if let Some(index) = dumpsys.find(" versionCode=") {
let start = index + 16; // size of " versionCode=\""
if let Some(end) = (&dumpsys[start..]).find(' ') {
let installed_version_code = &dumpsys[start..start + end];
Ok(installed_version_code != REQUIRED_APK_VERSION_CODE)
} else {
// end of versionCode value not found
Ok(true)
}
} else {
// versionCode not found
Ok(true)
}
} else {
let cmd = Cmd::new(adb, args);
Err(ProcessStatusError::new(cmd, output.status).into())
}
}
Err(err) => {
let cmd = Cmd::new(adb, args);
Err(ProcessIoError::new(cmd, err).into())
}
}
}
fn print_usage() {
let mut msg = "Syntax: gnirehtet (".to_string();
msg.push_str(COMMANDS[0].command());
for command in &COMMANDS[1..] {
msg.push('|');
msg.push_str(command.command());
}
msg.push_str(") ...\n");
for &command in COMMANDS {
msg.push('\n');
append_command_usage(&mut msg, command);
}
eprint!("{}", msg);
}
fn append_command_usage(msg: &mut String, command: &dyn Command) {
msg.push_str(" gnirehtet ");
msg.push_str(command.command());
let accepted_parameters = command.accepted_parameters();
if (accepted_parameters & cli_args::PARAM_SERIAL) != 0 {
msg.push_str(" [serial]");
}
if (accepted_parameters & cli_args::PARAM_DNS_SERVERS) != 0 {
msg.push_str(" [-d DNS[,DNS2,...]]");
}
if (accepted_parameters & cli_args::PARAM_PORT) != 0 {
msg.push_str(" [-p PORT]");
}
if (accepted_parameters & cli_args::PARAM_ROUTES) != 0 {
msg.push_str(" [-r ROUTE[,ROUTE2,...]]");
}
msg.push('\n');
for desc_line in command.description().split('\n') {
msg.push_str(" ");
msg.push_str(desc_line);
msg.push('\n');
}
}
fn print_command_usage(command: &dyn Command) {
let mut msg = String::new();
append_command_usage(&mut msg, command);
eprint!("{}", msg);
}
fn main() {
logger::init().unwrap();
let mut args = env::args();
// args.nth(1) will consume the two first arguments (the binary name and the command name)
if let Some(command_name) = args.nth(1) {
let command = COMMANDS
.iter()
.find(|&&command| command.command() == command_name);
match command {
Some(&command) => {
// args now contains only the command parameters
let arguments =
CommandLineArguments::parse(command.accepted_parameters(), args.collect());
match arguments {
Ok(arguments) => {
if let Err(err) = command.execute(&arguments) {
error!(target: TAG, "Execution error: {}", err);
exit(3);
}
}
Err(err) => {
error!(target: TAG, "{}", err);
print_command_usage(command);
exit(2);
}
}
}
None => {
if command_name == "rt" {
error!(
target: TAG,
"The 'rt' command has been renamed to 'run'. Try 'gnirehtet run' instead."
);
print_command_usage(&RunCommand);
} else {
error!(target: TAG, "Unknown command: {}", command_name);
print_usage();
}
exit(1);
}
}
} else {
print_usage();
}
}
================================================
FILE: relay-rust/src/relay/binary.rs
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use byteorder::{BigEndian, ByteOrder};
use std::cmp::min;
use std::fmt::Write;
const MAX_STRING_PACKET_SIZE: usize = 20;
pub fn to_byte_array(value: u32) -> [u8; 4] {
let mut raw = [0u8; 4];
BigEndian::write_u32(&mut raw, value);
raw
}
pub fn build_packet_string(data: &[u8]) -> String {
let mut s = String::new();
let limit = min(MAX_STRING_PACKET_SIZE, data.len());
for (i, &byte) in data.iter().take(limit).enumerate() {
if i != 0 {
let sep = if (i % 4) == 0 { " " } else { " " };
write!(&mut s, "{}", sep).unwrap();
}
write!(&mut s, "{:02X}", byte).unwrap();
}
if limit < data.len() {
write!(&mut s, " ... +{} bytes", data.len() - limit).unwrap();
}
s
}
// only compare the data part for fat pointers (ignore the vtable part)
// for some (buggy) reason, the vtable part may be different even if the data reference the same
// object
// See
pub fn ptr_data_eq(lhs: *const T, rhs: *const T) -> bool {
// cast to thin pointers to ignore the vtable part
lhs as *const () == rhs as *const ()
}
================================================
FILE: relay-rust/src/relay/byte_buffer.rs
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use std::io;
use std::ptr;
pub struct ByteBuffer {
buf: Box<[u8]>,
head: usize,
}
impl ByteBuffer {
pub fn new(length: usize) -> Self {
Self {
buf: vec![0; length].into_boxed_slice(),
head: 0,
}
}
pub fn read_from(&mut self, source: &mut R) -> io::Result {
let target_slice = &mut self.buf[self.head..];
let r = source.read(target_slice)?;
self.head += r;
Ok(r > 0)
}
pub fn peek(&self) -> &[u8] {
&self.buf[..self.head]
}
pub fn peek_mut(&mut self) -> &mut [u8] {
&mut self.buf[..self.head]
}
pub fn consume(&mut self, length: usize) {
assert!(self.head >= length);
self.head -= length;
if self.head > 0 {
// some data remaining, move them to the front of the buffer
unsafe {
let buf_ptr = self.buf.as_mut_ptr();
// Before:
//
// consumed old_head
// | |....................|
// <------>
// length
//
// After:
//
// new_head (= old_head - length)
// |....................|
// <------>
// length
//
// move from [length..old_head] to [0..new_head]
//
// semantically equivalent to memmove()
ptr::copy(buf_ptr.add(length), buf_ptr, self.head);
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::io;
#[test]
fn produce_consume_byte_buffer() {
let raw = "hello, world!".as_bytes();
let mut byte_buffer = ByteBuffer::new(64);
let mut cursor = io::Cursor::new(raw);
byte_buffer.read_from(&mut cursor).unwrap();
assert_eq!("hello, world!".as_bytes(), byte_buffer.peek());
byte_buffer.consume(7);
assert_eq!("world!".as_bytes(), byte_buffer.peek());
let mut cursor = io::Cursor::new(&raw[..5]);
byte_buffer.read_from(&mut cursor).unwrap();
assert_eq!("world!hello".as_bytes(), byte_buffer.peek());
}
}
================================================
FILE: relay-rust/src/relay/client.rs
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use log::*;
use mio::net::TcpStream;
use mio::{Event, PollOpt, Ready, Token};
use std::cell::RefCell;
use std::io::{self, Write};
use std::mem;
use std::net::Shutdown;
use std::rc::Rc;
use super::binary;
use super::close_listener::CloseListener;
use super::ipv4_packet::{Ipv4Packet, MAX_PACKET_LENGTH};
use super::ipv4_packet_buffer::Ipv4PacketBuffer;
use super::packet_source::PacketSource;
use super::router::Router;
use super::selector::Selector;
use super::stream_buffer::StreamBuffer;
const TAG: &str = "Client";
pub struct Client {
id: u32,
stream: TcpStream,
interests: Ready,
token: Token,
client_to_network: Ipv4PacketBuffer,
network_to_client: StreamBuffer,
router: Router,
close_listener: Box>,
closed: bool,
pending_packet_sources: Vec>>,
// number of remaining bytes of "id" to send to the client before relaying any data
pending_id_bytes: usize,
}
/// Channel for connections to send back data immediately to the client
pub struct ClientChannel<'a> {
network_to_client: &'a mut StreamBuffer,
stream: &'a TcpStream,
token: Token,
interests: &'a mut Ready,
}
impl<'a> ClientChannel<'a> {
fn new(
network_to_client: &'a mut StreamBuffer,
stream: &'a TcpStream,
token: Token,
interests: &'a mut Ready,
) -> Self {
Self {
network_to_client,
stream,
token,
interests,
}
}
// Functionally equivalent to Client::send_to_client(), except that it does not require to
// mutably borrow the whole client.
pub fn send_to_client(
&mut self,
selector: &mut Selector,
ipv4_packet: &Ipv4Packet,
) -> io::Result<()> {
if ipv4_packet.length() as usize <= self.network_to_client.remaining() {
self.network_to_client.read_from(ipv4_packet.raw());
self.update_interests(selector);
Ok(())
} else {
warn!(target: TAG, "Client buffer full");
Err(io::Error::new(
io::ErrorKind::WouldBlock,
"Client buffer full",
))
}
}
fn update_interests(&mut self, selector: &mut Selector) {
let ready = if self.network_to_client.is_empty() {
Ready::readable()
} else {
Ready::readable() | Ready::writable()
};
if *self.interests != ready {
// interests must be changed
*self.interests = ready;
selector
.reregister(self.stream, self.token, ready, PollOpt::level())
.expect("Cannot register on poll");
}
}
}
impl Client {
pub fn create(
id: u32,
selector: &mut Selector,
stream: TcpStream,
close_listener: Box>,
) -> io::Result>> {
// on start, we are interested only in writing (we must first send the client id)
let interests = Ready::writable();
let rc = Rc::new(RefCell::new(Self {
id,
stream,
interests,
token: Token(0), // default value, will be set afterwards
client_to_network: Ipv4PacketBuffer::new(),
network_to_client: StreamBuffer::new(16 * MAX_PACKET_LENGTH),
router: Router::new(),
closed: false,
close_listener,
pending_packet_sources: Vec::new(),
pending_id_bytes: 4,
}));
{
let mut self_ref = rc.borrow_mut();
// set client as router owner
self_ref.router.set_client(Rc::downgrade(&rc));
let rc2 = rc.clone();
// must anotate selector type: https://stackoverflow.com/a/44004103/1987178
let handler =
move |selector: &mut Selector, event| rc2.borrow_mut().on_ready(selector, event);
let token =
selector.register(&self_ref.stream, handler, interests, PollOpt::level())?;
self_ref.token = token;
}
Ok(rc)
}
pub fn id(&self) -> u32 {
self.id
}
pub fn router(&mut self) -> &mut Router {
&mut self.router
}
pub fn channel(&mut self) -> ClientChannel {
ClientChannel::new(
&mut self.network_to_client,
&self.stream,
self.token,
&mut self.interests,
)
}
fn close(&mut self, selector: &mut Selector) {
self.closed = true;
selector.deregister(&self.stream, self.token).unwrap();
// shutdown only (there is no close), the socket will be closed on drop
if self.stream.shutdown(Shutdown::Both).is_err() {
warn!(target: TAG, "Cannot shutdown client socket");
}
self.router.clear(selector);
self.close_listener.on_closed(self);
}
fn on_ready(&mut self, selector: &mut Selector, event: Event) {
#[allow(clippy::match_wild_err_arm)]
match self.process(selector, event) {
Ok(_) => (),
Err(ref err) if err.kind() == io::ErrorKind::WouldBlock => {
debug!(target: TAG, "Spurious event, ignoring")
}
Err(_) => panic!("Unexpected unhandled error"),
}
}
// return Err(err) with err.kind() == io::ErrorKind::WouldBlock on spurious event
fn process(&mut self, selector: &mut Selector, event: Event) -> io::Result<()> {
if !self.closed {
let ready = event.readiness();
if ready.is_writable() {
self.process_send(selector)?;
}
if !self.closed && ready.is_readable() {
self.process_receive(selector)?;
}
if !self.closed {
self.update_interests(selector);
}
}
Ok(())
}
// return Err(err) with err.kind() == io::ErrorKind::WouldBlock on spurious event
fn process_send(&mut self, selector: &mut Selector) -> io::Result<()> {
if self.must_send_id() {
match self.send_id() {
Ok(_) => {
if self.pending_id_bytes == 0 {
debug!(target: TAG, "Client id #{} sent to client", self.id);
}
}
Err(err) => {
if err.kind() == io::ErrorKind::WouldBlock {
// rethrow
return Err(err);
}
error!(target: TAG, "Cannot write client id #{}", self.id);
self.close(selector);
}
}
} else {
match self.write() {
Ok(_) => self.process_pending(selector),
Err(err) => {
error!(target: TAG, "Cannot write: [{:?}] {}", err.kind(), err);
self.close(selector);
}
}
}
Ok(())
}
// return Err(err) with err.kind() == io::ErrorKind::WouldBlock on spurious event
fn process_receive(&mut self, selector: &mut Selector) -> io::Result<()> {
match self.read() {
Ok(true) => self.push_to_network(selector),
Ok(false) => {
debug!(target: TAG, "EOF reached");
self.close(selector);
}
Err(err) => {
if err.kind() == io::ErrorKind::WouldBlock {
// rethrow
return Err(err);
}
error!(target: TAG, "Cannot read: [{:?}] {}", err.kind(), err);
self.close(selector);
}
}
Ok(())
}
pub fn send_to_client(
&mut self,
selector: &mut Selector,
ipv4_packet: &Ipv4Packet,
) -> io::Result<()> {
if ipv4_packet.length() as usize <= self.network_to_client.remaining() {
self.network_to_client.read_from(ipv4_packet.raw());
self.update_interests(selector);
Ok(())
} else {
warn!(target: TAG, "Client buffer full");
Err(io::Error::new(
io::ErrorKind::WouldBlock,
"Client buffer full",
))
}
}
pub fn register_pending_packet_source(&mut self, source: Rc>) {
self.pending_packet_sources.push(source);
}
fn send_id(&mut self) -> io::Result<()> {
assert!(self.must_send_id());
let raw_id = binary::to_byte_array(self.id);
let w = self.stream.write(&raw_id[4 - self.pending_id_bytes..])?;
self.pending_id_bytes -= w;
Ok(())
}
fn update_interests(&mut self, selector: &mut Selector) {
self.channel().update_interests(selector);
}
fn read(&mut self) -> io::Result {
self.client_to_network.read_from(&mut self.stream)
}
fn write(&mut self) -> io::Result<()> {
self.network_to_client.write_to(&mut self.stream)?;
Ok(())
}
fn push_to_network(&mut self, selector: &mut Selector) {
while self.push_one_packet_to_network(selector) {
self.client_to_network.next();
}
}
fn push_one_packet_to_network(&mut self, selector: &mut Selector) -> bool {
match self.client_to_network.as_ipv4_packet() {
Some(ref packet) => {
let mut client_channel = ClientChannel::new(
&mut self.network_to_client,
&self.stream,
self.token,
&mut self.interests,
);
self.router
.send_to_network(selector, &mut client_channel, packet);
true
}
None => false,
}
}
fn process_pending(&mut self, selector: &mut Selector) {
let mut vec = Vec::new();
mem::swap(&mut self.pending_packet_sources, &mut vec);
for pending in vec.into_iter() {
let consumed = {
let mut source = pending.borrow_mut();
let result = {
let ipv4_packet = source
.get()
.expect("Unexpected pending source with no packet");
self.send_to_client(selector, &ipv4_packet)
};
#[allow(clippy::match_wild_err_arm)]
match result {
Ok(_) => {
source.next(selector);
true
}
Err(ref err) if err.kind() == io::ErrorKind::WouldBlock => false,
Err(_) => {
panic!("Cannot send packet to client for unknown reason");
}
}
};
if !consumed {
// keep it pending
self.pending_packet_sources.push(pending);
}
}
}
pub fn clean_expired_connections(&mut self, selector: &mut Selector) {
self.router.clean_expired_connections(selector);
}
fn must_send_id(&self) -> bool {
self.pending_id_bytes > 0
}
}
================================================
FILE: relay-rust/src/relay/close_listener.rs
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
pub trait CloseListener {
fn on_closed(&self, target: &T);
}
impl CloseListener for F
where
F: Fn(&T),
{
fn on_closed(&self, target: &T) {
self(target);
}
}
================================================
FILE: relay-rust/src/relay/connection.rs
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use std::fmt;
use std::net::SocketAddrV4;
use super::client::ClientChannel;
use super::ipv4_header::{Ipv4HeaderData, Protocol};
use super::ipv4_packet::Ipv4Packet;
use super::net;
use super::selector::Selector;
use super::transport_header::TransportHeaderData;
const LOCALHOST_FORWARD: u32 = 0x0A_00_02_02; // 10.0.2.2
const LOCALHOST: u32 = 0x7F_00_00_01; // 127.0.0.1
pub trait Connection {
fn id(&self) -> &ConnectionId;
fn send_to_network(
&mut self,
selector: &mut Selector,
client_channel: &mut ClientChannel,
ipv4_packet: &Ipv4Packet,
);
fn close(&mut self, selector: &mut Selector);
fn is_expired(&self) -> bool;
fn is_closed(&self) -> bool;
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ConnectionId {
protocol: Protocol,
source_ip: u32,
source_port: u16,
destination_ip: u32,
destination_port: u16,
id_string: String,
}
impl ConnectionId {
pub fn from_headers(
ipv4_header_data: &Ipv4HeaderData,
transport_header_data: &TransportHeaderData,
) -> Self {
let source_ip = ipv4_header_data.source();
let source_port = transport_header_data.source_port();
let destination_ip = ipv4_header_data.destination();
let destination_port = transport_header_data.destination_port();
let id_string = format!(
"{} -> {}",
net::to_socket_addr(source_ip, source_port),
net::to_socket_addr(destination_ip, destination_port)
);
Self {
protocol: ipv4_header_data.protocol(),
source_ip,
source_port,
destination_ip,
destination_port,
id_string,
}
}
pub fn protocol(&self) -> Protocol {
self.protocol
}
pub fn rewritten_destination(&self) -> SocketAddrV4 {
let ip = if self.destination_ip == LOCALHOST_FORWARD {
LOCALHOST
} else {
self.destination_ip
};
net::to_socket_addr(ip, self.destination_port)
}
}
impl fmt::Display for ConnectionId {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.id_string)
}
}
// macros to log connection id along with the message
macro_rules! cx_format {
($id:tt, $str:tt, $($arg:tt)+) => {
format!(concat!("{} ", $str), $id, $($arg)+)
};
($id:tt, $str:tt) => {
format!(concat!("{} ", $str), $id)
};
}
macro_rules! cx_trace {
(target: $target:expr, $id:expr, $($arg:tt)*) => {
log::trace!(target: $target, "{}", cx_format!($id, $($arg)+))
}
}
macro_rules! cx_debug {
(target: $target:expr, $id:expr, $($arg:tt)*) => {
log::debug!(target: $target, "{}", cx_format!($id, $($arg)+))
}
}
macro_rules! cx_info {
(target: $target:expr, $id:expr, $($arg:tt)*) => {
log::info!(target: $target, "{}", cx_format!($id, $($arg)+))
}
}
macro_rules! cx_warn {
(target: $target:expr, $id:expr, $($arg:tt)*) => {
log::warn!(target: $target, "{}", cx_format!($id, $($arg)+))
}
}
macro_rules! cx_error {
(target: $target:expr, $id:expr, $($arg:tt)*) => {
log::error!(target: $target, "{}", cx_format!($id, $($arg)+))
}
}
================================================
FILE: relay-rust/src/relay/datagram.rs
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use mio::net::UdpSocket;
use std::cmp;
use std::io;
pub const MAX_DATAGRAM_LENGTH: usize = 1 << 16;
pub trait DatagramSender {
fn send(&mut self, buf: &[u8]) -> io::Result;
}
pub trait DatagramReceiver {
fn recv(&mut self, buf: &mut [u8]) -> io::Result;
}
// Expose UdpSocket as DatagramSender
impl DatagramSender for UdpSocket {
fn send(&mut self, buf: &[u8]) -> io::Result {
// call the Self implementation
(self as &Self).send(buf)
}
}
// Expose UdpSocket as DatagramReceiver
impl DatagramReceiver for UdpSocket {
fn recv(&mut self, buf: &mut [u8]) -> io::Result {
// call the Self implementation
(self as &Self).recv(buf)
}
}
// Convert a Read to a DatagramReceiver
pub struct ReadAdapter<'a, R>
where
R: io::Read + 'a,
{
read: &'a mut R,
max_chunk_size: Option,
}
impl<'a, R> ReadAdapter<'a, R>
where
R: io::Read + 'a,
{
pub fn new(read: &'a mut R, max_chunk_size: Option) -> Self {
Self {
read,
max_chunk_size,
}
}
}
impl<'a, R> DatagramReceiver for ReadAdapter<'a, R>
where
R: io::Read + 'a,
{
fn recv(&mut self, buf: &mut [u8]) -> io::Result {
let len = if let Some(max_chunk_size) = self.max_chunk_size {
cmp::min(max_chunk_size, buf.len())
} else {
buf.len()
};
self.read.read(&mut buf[..len])
}
}
#[cfg(test)]
pub mod tests {
use super::*;
// Mock datagram socket to be used in other tests
pub struct MockDatagramSocket {
buf: [u8; MAX_DATAGRAM_LENGTH],
len: usize,
}
impl MockDatagramSocket {
pub fn new() -> Self {
Self {
buf: [0; MAX_DATAGRAM_LENGTH],
len: 0,
}
}
pub fn from_data(data: &[u8]) -> Self {
let mut mock = MockDatagramSocket::new();
mock.send(data).unwrap();
mock
}
pub fn data(&self) -> &[u8] {
&self.buf[..self.len]
}
}
impl DatagramSender for MockDatagramSocket {
fn send(&mut self, buf: &[u8]) -> io::Result {
let len = cmp::min(self.buf.len(), buf.len());
self.buf[..len].copy_from_slice(&buf[..len]);
self.len = len;
Ok(len)
}
}
impl DatagramReceiver for MockDatagramSocket {
fn recv(&mut self, buf: &mut [u8]) -> io::Result {
let len = cmp::min(self.len, buf.len());
buf[..len].copy_from_slice(&self.buf[..len]);
Ok(len)
}
}
#[test]
fn mock_send() {
let mut mock = MockDatagramSocket::new();
let data = [1, 2, 3, 4, 5];
let sent = mock.send(&data).unwrap();
assert_eq!(5, sent);
assert_eq!([1, 2, 3, 4, 5], mock.data());
}
#[test]
fn mock_recv() {
let mut mock = MockDatagramSocket::from_data(&[1, 2, 3, 4, 5]);
let mut buf = [0u8; 10];
let recved = mock.recv(&mut buf).unwrap();
assert_eq!(5, recved);
assert_eq!([1, 2, 3, 4, 5], &buf[..5]);
}
#[test]
fn read_adapter() {
let mut cursor = io::Cursor::new([1, 2, 3, 4, 5]);
let mut buf = [0u8; 10];
let mut adapter = ReadAdapter::new(&mut cursor, None);
let recved = adapter.recv(&mut buf).unwrap();
assert_eq!(5, recved);
assert_eq!([1, 2, 3, 4, 5], &buf[..5]);
}
#[test]
fn read_adapter_chunks() {
let mut cursor = io::Cursor::new([1, 2, 3, 4, 5]);
let mut buf = [0u8; 10];
{
let mut adapter = ReadAdapter::new(&mut cursor, Some(2));
let recved = adapter.recv(&mut buf).unwrap();
assert_eq!(2, recved);
assert_eq!([1, 2], &buf[..2]);
}
{
let mut adapter = ReadAdapter::new(&mut cursor, Some(1));
let recved = adapter.recv(&mut buf).unwrap();
assert_eq!(1, recved);
assert_eq!([3], &buf[..1]);
}
{
let mut adapter = ReadAdapter::new(&mut cursor, None);
let recved = adapter.recv(&mut buf).unwrap();
assert_eq!(2, recved);
assert_eq!([4, 5], &buf[..2]);
}
}
}
================================================
FILE: relay-rust/src/relay/datagram_buffer.rs
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use byteorder::{BigEndian, ByteOrder};
use log::*;
use std::io;
use super::datagram::{DatagramSender, MAX_DATAGRAM_LENGTH};
const HEADER_LENGTH: usize = 2;
const MAX_BLOCK_LENGTH: usize = HEADER_LENGTH + MAX_DATAGRAM_LENGTH;
const TAG: &str = "DatagramBuffer";
/// Circular buffer to store datagrams (preserving their boundaries).
///
/// ```text
/// circularBufferLength
/// |<------------------------->| extra space for storing the last datagram in one block
/// +---------------------------+------+
/// | | |
/// |[D4] [ D1 ][ D2 ][ D3 ] |
/// +---------------------------+------+
/// ^ ^
/// head tail
/// ```
pub struct DatagramBuffer {
buf: Box<[u8]>,
head: usize,
tail: usize,
circular_buffer_length: usize,
}
impl DatagramBuffer {
pub fn new(capacity: usize) -> Self {
Self {
buf: vec![0; capacity + MAX_BLOCK_LENGTH].into_boxed_slice(),
head: 0,
tail: 0,
circular_buffer_length: capacity + 1,
}
}
pub fn is_empty(&self) -> bool {
self.head == self.tail
}
pub fn has_enough_space_for(&self, datagram_length: usize) -> bool {
if self.head >= self.tail {
// there is at least the extra space for storing 1 packet
return true;
}
// 1 extra byte to distinguish empty vs full
let remaining = self.tail - self.head - 1;
HEADER_LENGTH + datagram_length <= remaining
}
pub fn write_to(&mut self, destination: &mut S) -> io::Result<()> {
assert!(
!self.is_empty(),
"DatagramBuffer.write_to() called while empty"
);
let length = self.read_length() as usize;
let source_slice = &self.buf[self.tail..self.tail + length];
self.tail += length;
if self.tail >= self.circular_buffer_length {
self.tail = 0;
}
let w = destination.send(source_slice)?;
if w != length {
error!(
target: TAG,
"Cannot write the whole datagram to the buffer (only {}/{})", w, length
);
return Err(io::Error::new(
io::ErrorKind::Other,
"Cannot write the whole datagram",
));
}
Ok(())
}
pub fn read_from(&mut self, source: &[u8]) -> io::Result<()> {
let length = source.len();
assert!(
length <= MAX_DATAGRAM_LENGTH,
"Datagram length may not be greater than {} bytes",
MAX_DATAGRAM_LENGTH
);
if !self.has_enough_space_for(length) {
return Err(io::Error::new(
io::ErrorKind::Other,
"Datagram buffer is full",
));
}
self.write_length(length as u16);
let target_slice = &mut self.buf[self.head..self.head + length];
target_slice.copy_from_slice(source);
self.head += length;
if self.head >= self.circular_buffer_length {
self.head = 0;
}
Ok(())
}
fn read_length(&mut self) -> u16 {
self.tail += 2;
BigEndian::read_u16(&self.buf[self.tail - 2..self.tail])
}
fn write_length(&mut self, length: u16) {
BigEndian::write_u16(&mut self.buf[self.head..self.head + 2], length);
self.head += 2;
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::relay::datagram::tests::MockDatagramSocket;
fn create_datagram(length: u8) -> Vec {
(0..length).collect()
}
#[test]
fn bufferize_datagram() {
let datagram = create_datagram(5);
let mut datagram_buffer = DatagramBuffer::new(9);
datagram_buffer.read_from(&datagram).unwrap();
assert_eq!(read_datagram(&mut datagram_buffer), datagram);
}
#[test]
fn split_datagrams_at_boundaries() {
let mut datagram_buffer = DatagramBuffer::new(32);
let datagram5 = create_datagram(5);
let datagram0 = create_datagram(0);
let datagram3 = create_datagram(3);
let datagram4 = create_datagram(4);
datagram_buffer.read_from(&datagram5).unwrap();
datagram_buffer.read_from(&datagram0).unwrap();
datagram_buffer.read_from(&datagram3).unwrap();
datagram_buffer.read_from(&datagram4).unwrap();
assert_eq!(read_datagram(&mut datagram_buffer), datagram5);
assert_eq!(read_datagram(&mut datagram_buffer), datagram0);
assert_eq!(read_datagram(&mut datagram_buffer), datagram3);
assert_eq!(read_datagram(&mut datagram_buffer), datagram4);
}
#[test]
fn circular() {
let datagram5 = create_datagram(5);
let datagram3 = create_datagram(3);
let mut datagram_buffer = DatagramBuffer::new(14);
// write and consume 10 bytes
datagram_buffer.read_from(&create_datagram(10)).unwrap();
{
// write and forget
let mut mock = MockDatagramSocket::new();
datagram_buffer.write_to(&mut mock).unwrap();
}
// DatagramBuffer is expected to store the whole datagram, even if it exceeds its "capacity"
datagram_buffer.read_from(&datagram5).unwrap();
datagram_buffer.read_from(&datagram3).unwrap();
assert_eq!(read_datagram(&mut datagram_buffer), datagram5);
assert_eq!(read_datagram(&mut datagram_buffer), datagram3);
}
fn read_datagram(datagram_buffer: &mut DatagramBuffer) -> Vec {
let mut mock = MockDatagramSocket::new();
datagram_buffer.write_to(&mut mock).unwrap();
mock.data().to_vec()
}
}
================================================
FILE: relay-rust/src/relay/interrupt.rs
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/// Reexecute the expression if the it returns an `Interrupted` error
macro_rules! retry_on_intr {
($e:expr) => {{
let result;
loop {
match $e {
Err(ref err) if err.kind() == io::ErrorKind::Interrupted => {
continue;
}
x => {
result = x;
break;
}
}
}
result
}};
}
================================================
FILE: relay-rust/src/relay/ipv4_header.rs
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use byteorder::{BigEndian, ByteOrder};
use std::mem;
pub struct Ipv4Header<'a> {
raw: &'a [u8],
data: &'a Ipv4HeaderData,
}
pub struct Ipv4HeaderMut<'a> {
raw: &'a mut [u8],
data: &'a mut Ipv4HeaderData,
}
#[derive(Clone)]
pub struct Ipv4HeaderData {
_version: u8,
header_length: u8,
total_length: u16,
protocol: Protocol,
source: u32,
destination: u32,
}
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum Protocol {
Tcp,
Udp,
Other,
}
#[allow(dead_code)]
impl Ipv4HeaderData {
pub fn parse(raw: &[u8]) -> Self {
Self {
_version: raw[0] >> 4,
header_length: (raw[0] & 0xf) << 2,
total_length: BigEndian::read_u16(&raw[2..4]),
protocol: match raw[9] {
6 => Protocol::Tcp,
17 => Protocol::Udp,
_ => Protocol::Other,
},
source: BigEndian::read_u32(&raw[12..16]),
destination: BigEndian::read_u32(&raw[16..20]),
}
}
pub fn bind<'c, 'a: 'c, 'b: 'c>(&'a self, raw: &'b [u8]) -> Ipv4Header<'c> {
Ipv4Header::new(raw, self)
}
pub fn bind_mut<'c, 'a: 'c, 'b: 'c>(&'a mut self, raw: &'b mut [u8]) -> Ipv4HeaderMut<'c> {
Ipv4HeaderMut::new(raw, self)
}
pub fn header_length(&self) -> u8 {
self.header_length
}
pub fn total_length(&self) -> u16 {
self.total_length
}
pub fn protocol(&self) -> Protocol {
self.protocol
}
pub fn source(&self) -> u32 {
self.source
}
pub fn destination(&self) -> u32 {
self.destination
}
}
pub fn peek_version_length(raw: &[u8]) -> Option<(u8, u16)> {
if raw.len() >= 4 {
// version is stored in the 4 first bits
let version = raw[0] >> 4;
// packet length is 16 bits starting at offset 2
let length = BigEndian::read_u16(&raw[2..4]);
Some((version, length))
} else {
None
}
}
// shared definition for Ipv4Header and Ipv4HeaderMut
macro_rules! ipv4_header_common {
($name:ident, $raw_type:ty, $data_type:ty) => {
// for readability, declare structs manually outside the macro
#[allow(dead_code)]
impl<'a> $name<'a> {
pub fn new(raw: $raw_type, data: $data_type) -> Self {
Self {
raw: raw,
data: data,
}
}
pub fn raw(&self) -> &[u8] {
self.raw
}
pub fn data(&self) -> &Ipv4HeaderData {
self.data
}
pub fn header_length(&self) -> u8 {
self.data.header_length
}
pub fn total_length(&self) -> u16 {
self.data.total_length
}
pub fn protocol(&self) -> Protocol {
self.data.protocol
}
pub fn source(&self) -> u32 {
self.data.source
}
pub fn destination(&self) -> u32 {
self.data.destination
}
}
};
}
ipv4_header_common!(Ipv4Header, &'a [u8], &'a Ipv4HeaderData);
ipv4_header_common!(Ipv4HeaderMut, &'a mut [u8], &'a mut Ipv4HeaderData);
// additional methods for the mutable version
#[allow(dead_code)]
impl<'a> Ipv4HeaderMut<'a> {
pub fn raw_mut(&mut self) -> &mut [u8] {
self.raw
}
pub fn data_mut(&mut self) -> &mut Ipv4HeaderData {
self.data
}
pub fn set_total_length(&mut self, total_length: u16) {
self.data.total_length = total_length;
BigEndian::write_u16(&mut self.raw[2..4], total_length);
}
pub fn set_source(&mut self, source: u32) {
self.data.source = source;
BigEndian::write_u32(&mut self.raw[12..16], source);
}
pub fn set_destination(&mut self, destination: u32) {
self.data.destination = destination;
BigEndian::write_u32(&mut self.raw[16..20], destination);
}
pub fn swap_source_and_destination(&mut self) {
mem::swap(&mut self.data.source, &mut self.data.destination);
for i in 12..16 {
self.raw.swap(i, i + 4);
}
}
fn checksum(&self) -> u16 {
BigEndian::read_u16(&self.raw[10..12])
}
fn set_checksum(&mut self, checksum: u16) {
BigEndian::write_u16(&mut self.raw[10..12], checksum);
}
pub fn update_checksum(&mut self) {
let j = self.data.header_length as usize / 2;
// skip checksum field at 10..12
let mut sum = (0..5)
.chain(6..j)
.map(|i| {
let range = 2 * i..2 * (i + 1);
u32::from(BigEndian::read_u16(&self.raw[range]))
})
.sum::();
while (sum & !0xffff) != 0 {
sum = (sum & 0xffff) + (sum >> 16);
}
self.set_checksum(!sum as u16);
}
}
#[cfg(test)]
mod tests {
use super::*;
use byteorder::{BigEndian, WriteBytesExt};
fn create_header() -> Vec {
let mut raw: Vec = Vec::new();
raw.reserve(20);
raw.write_u8(4u8 << 4 | 5).unwrap(); // version_and_ihl
raw.write_u8(0).unwrap(); //ToS
raw.write_u16::(28).unwrap(); // total length
raw.write_u32::(0).unwrap(); // id_flags_fragment_offset
raw.write_u8(0).unwrap(); // TTL
raw.write_u8(17).unwrap(); // protocol (UDP)
raw.write_u16::(0).unwrap(); // checksum
raw.write_u32::(0x12345678).unwrap(); // source address
raw.write_u32::(0x42424242).unwrap(); // destination address
raw
}
#[test]
fn parse_header() {
let raw = &create_header()[..];
let data = Ipv4HeaderData::parse(raw);
assert_eq!(4, data._version);
assert_eq!(20, data.header_length);
assert_eq!(28, data.total_length);
assert_eq!(Protocol::Udp, data.protocol);
assert_eq!(0x12345678, data.source);
assert_eq!(0x42424242, data.destination);
}
#[test]
fn edit_header() {
let raw = &mut create_header()[..];
let mut header_data = Ipv4HeaderData::parse(raw);
let mut header = header_data.bind_mut(raw);
header.set_source(0x87654321);
header.set_destination(0x24242424);
header.set_total_length(42);
assert_eq!(0x87654321, header.source());
assert_eq!(0x24242424, header.destination());
assert_eq!(42, header.total_length());
// assert that the buffer has been modified
let raw_source = BigEndian::read_u32(&header.raw[12..16]);
let raw_destination = BigEndian::read_u32(&header.raw[16..20]);
let raw_total_length = BigEndian::read_u16(&header.raw[2..4]);
assert_eq!(0x87654321, raw_source);
assert_eq!(0x24242424, raw_destination);
assert_eq!(42, raw_total_length);
header.swap_source_and_destination();
assert_eq!(0x24242424, header.source());
assert_eq!(0x87654321, header.destination());
let raw_source = BigEndian::read_u32(&header.raw[12..16]);
let raw_destination = BigEndian::read_u32(&header.raw[16..20]);
assert_eq!(0x24242424, raw_source);
assert_eq!(0x87654321, raw_destination);
}
#[test]
fn compute_checksum() {
let raw = &mut create_header()[..];
let mut header_data = Ipv4HeaderData::parse(raw);
let mut header = header_data.bind_mut(raw);
// set a fake checksum value to assert that it is correctly computed
header.set_checksum(0x79);
header.update_checksum();
let mut sum: u32 =
0x4500 + 0x001C + 0x0000 + 0x0000 + 0x0011 + 0x0000 + 0x1234 + 0x5678 + 0x4242 + 0x4242;
while (sum & !0xffff) != 0 {
sum = (sum & 0xffff) + (sum >> 16);
}
let sum = !sum as u16;
assert_eq!(sum, header.checksum());
}
#[test]
fn peek_version_length_unavailable() {
let raw: [u8; 0] = [];
assert!(peek_version_length(&raw).is_none());
let raw = [0x40, 2];
assert!(peek_version_length(&raw).is_none());
}
#[test]
fn peek_version_length_available() {
let raw = [4u8 << 4 | 5, 0, 0x01, 0x23];
let (version, length) = peek_version_length(&raw).unwrap();
assert_eq!(4, version);
assert_eq!(0x123, length);
}
}
================================================
FILE: relay-rust/src/relay/ipv4_packet.rs
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use super::ipv4_header::{Ipv4Header, Ipv4HeaderData, Ipv4HeaderMut};
use super::transport_header::{TransportHeader, TransportHeaderData, TransportHeaderMut};
pub const MAX_PACKET_LENGTH: usize = 1 << 16;
pub struct Ipv4Packet<'a> {
raw: &'a mut [u8],
ipv4_header_data: Ipv4HeaderData,
transport_header_data: Option,
}
impl<'a> Ipv4Packet<'a> {
pub fn parse(raw: &'a mut [u8]) -> Self {
let ipv4_header_data = Ipv4HeaderData::parse(raw);
let transport_header_data = {
let payload = &raw[ipv4_header_data.header_length() as usize..];
TransportHeaderData::parse(ipv4_header_data.protocol(), payload)
};
Self {
raw: &mut raw[..ipv4_header_data.total_length() as usize],
ipv4_header_data,
transport_header_data,
}
}
pub fn new(
raw: &'a mut [u8],
ipv4_header_data: Ipv4HeaderData,
transport_header_data: TransportHeaderData,
) -> Self {
Self {
raw,
ipv4_header_data,
transport_header_data: Some(transport_header_data),
}
}
#[inline]
pub fn raw(&self) -> &[u8] {
self.raw
}
#[inline]
pub fn headers_data(&self) -> (&Ipv4HeaderData, Option<&TransportHeaderData>) {
(&self.ipv4_header_data, self.transport_header_data.as_ref())
}
pub fn headers(&self) -> (Ipv4Header, Option) {
let transport_index = self.ipv4_header_data.header_length() as usize;
if let Some(ref transport_header_data) = self.transport_header_data {
let (ipv4_header_slice, transport_slice) = self.raw.split_at(transport_index);
// payload_index is relative to transport
let payload_index = transport_header_data.header_length() as usize;
let transport_header_slice = &transport_slice[..payload_index];
let ipv4_header = self.ipv4_header_data.bind(ipv4_header_slice);
let transport_header = transport_header_data.bind(transport_header_slice);
(ipv4_header, Some(transport_header))
} else {
let ipv4_header_slice = &self.raw[..transport_index];
let ipv4_header = self.ipv4_header_data.bind(ipv4_header_slice);
(ipv4_header, None)
}
}
#[inline]
#[allow(dead_code)]
pub fn ipv4_header_data(&self) -> &Ipv4HeaderData {
&self.ipv4_header_data
}
#[inline]
#[allow(dead_code)]
pub fn ipv4_header(&self) -> Ipv4Header {
let slice = &self.raw[..self.ipv4_header_data.header_length() as usize];
self.ipv4_header_data.bind(slice)
}
#[inline]
#[allow(dead_code)]
pub fn ipv4_header_mut(&mut self) -> Ipv4HeaderMut {
let slice = &mut self.raw[..self.ipv4_header_data.header_length() as usize];
self.ipv4_header_data.bind_mut(slice)
}
#[inline]
#[allow(dead_code)]
pub fn transport_header_data(&self) -> Option<&TransportHeaderData> {
self.transport_header_data.as_ref()
}
#[inline]
pub fn transport_header(&self) -> Option {
if let Some(ref transport_header_data) = self.transport_header_data {
let start = self.ipv4_header_data.header_length() as usize;
let end = start + transport_header_data.header_length() as usize;
let slice = &self.raw[start..end];
Some(transport_header_data.bind(slice))
} else {
None
}
/* self.transport_header_data.as_ref().map(|transport_header_data| {
let start = self.ipv4_header_data.header_length() as usize;
let end = start + transport_header_data.header_length() as usize;
let slice = &self.raw[start..end];
transport_header_data.bind(slice)
})*/
}
#[inline]
#[allow(dead_code)]
fn transport_header_mut(&mut self) -> Option {
if let Some(ref mut transport_header_data) = self.transport_header_data {
let start = self.ipv4_header_data.header_length() as usize;
let end = start + transport_header_data.header_length() as usize;
let slice = &mut self.raw[start..end];
Some(transport_header_data.bind_mut(slice))
} else {
None
}
/* self.transport_header_data.as_mut().map(|transport_header_data| {
let start = self.ipv4_header_data.header_length() as usize;
let end = start + transport_header_data.header_length() as usize;
let slice = &mut self.raw[start..end];
transport_header_data.bind_mut(slice)
})*/
}
/// Devide the packet into parts:
/// - the IP v4 header
/// - the transport header (if any)
/// - the payload (if there is a transport at all)
#[allow(dead_code)]
pub fn split(&self) -> (Ipv4Header, Option<(TransportHeader, &[u8])>) {
let transport_index = self.ipv4_header_data.header_length() as usize;
if let Some(ref transport_header_data) = self.transport_header_data {
// payload_index is relative to transport
let payload_index = transport_header_data.header_length() as usize;
let (ipv4_header_slice, transport_slice) = self.raw.split_at(transport_index);
let (transport_header_slice, payload_slice) = transport_slice.split_at(payload_index);
let ipv4_header = self.ipv4_header_data.bind(ipv4_header_slice);
let transport_header = transport_header_data.bind(transport_header_slice);
(ipv4_header, Some((transport_header, payload_slice)))
} else {
let ipv4_header_slice = &self.raw[..transport_index];
let ipv4_header = self.ipv4_header_data.bind(ipv4_header_slice);
(ipv4_header, None)
}
}
/// Devide the packet into mutable parts:
/// - the IP v4 header
/// - the transport header (if any)
/// - the payload (if there is a transport at all)
pub fn split_mut(&mut self) -> (Ipv4HeaderMut, Option<(TransportHeaderMut, &mut [u8])>) {
let transport_index = self.ipv4_header_data.header_length() as usize;
if let Some(ref mut transport_header_data) = self.transport_header_data {
// payload_index is relative to transport
let payload_index = transport_header_data.header_length() as usize;
let (ipv4_header_slice, transport_slice) = self.raw.split_at_mut(transport_index);
let (transport_header_slice, payload_slice) =
transport_slice.split_at_mut(payload_index);
let ipv4_header = self.ipv4_header_data.bind_mut(ipv4_header_slice);
let transport_header = transport_header_data.bind_mut(transport_header_slice);
(ipv4_header, Some((transport_header, payload_slice)))
} else {
let ipv4_header_slice = &mut self.raw[..transport_index];
let ipv4_header = self.ipv4_header_data.bind_mut(ipv4_header_slice);
(ipv4_header, None)
}
}
#[inline]
pub fn is_valid(&self) -> bool {
self.transport_header_data.is_some()
}
#[inline]
pub fn length(&self) -> u16 {
self.ipv4_header_data.total_length()
}
pub fn payload(&self) -> Option<&[u8]> {
self.transport_header_data
.as_ref()
.map(|transport_header_data| {
let range = self.ipv4_header_data.header_length() as usize
+ transport_header_data.header_length() as usize..;
&self.raw[range]
})
}
pub fn compute_checksums(&mut self) {
let (mut ipv4_header, transport) = self.split_mut();
ipv4_header.update_checksum();
if let Some((mut transport_header, payload)) = transport {
transport_header.update_checksum(ipv4_header.data(), payload);
}
}
/*#[inline]
pub fn swap_source_and_destination(&mut self) {
self.ipv4_header_mut().swap_source_and_destination();
if let Some(mut transport_header) = self.transport_header_mut() {
transport_header.swap_source_and_destination();
}
}*/
}
#[cfg(test)]
mod tests {
use super::*;
use crate::relay::ipv4_header::Protocol;
use byteorder::{BigEndian, WriteBytesExt};
fn create_packet() -> Vec {
let mut raw = Vec::new();
raw.reserve(32);
raw.write_u8(4u8 << 4 | 5).unwrap(); // version_and_ihl
raw.write_u8(0).unwrap(); //ToS
raw.write_u16::(32).unwrap(); // total length 20 + 8 + 4
raw.write_u32::(0).unwrap(); // id_flags_fragment_offset
raw.write_u8(0).unwrap(); // TTL
raw.write_u8(17).unwrap(); // protocol (UDP)
raw.write_u16::(0).unwrap(); // checksum
raw.write_u32::(0x12345678).unwrap(); // source address
raw.write_u32::(0x42424242).unwrap(); // destination address
raw.write_u16::(1234).unwrap(); // source port
raw.write_u16::(5678).unwrap(); // destination port
raw.write_u16::(4).unwrap(); // length
raw.write_u16::(0).unwrap(); // checksum
raw.write_u32::(0x11223344).unwrap(); // payload
raw
}
#[test]
fn parse_headers() {
let raw = &mut create_packet()[..];
let ipv4_packet = Ipv4Packet::parse(raw);
{
let ipv4_header = ipv4_packet.ipv4_header();
assert_eq!(20, ipv4_header.header_length());
assert_eq!(32, ipv4_header.total_length());
assert_eq!(Protocol::Udp, ipv4_header.protocol());
assert_eq!(0x12345678, ipv4_header.source());
assert_eq!(0x42424242, ipv4_header.destination());
if let Some(&TransportHeaderData::Udp(ref udp_header)) =
ipv4_packet.transport_header_data()
{
assert_eq!(1234, udp_header.source_port());
assert_eq!(5678, udp_header.destination_port());
} else {
panic!("No UDP transport header");
}
}
}
#[test]
fn payload() {
let raw = &mut create_packet()[..];
let ipv4_packet = Ipv4Packet::parse(raw);
assert_eq!([0x11, 0x22, 0x33, 0x44], ipv4_packet.payload().unwrap());
}
}
================================================
FILE: relay-rust/src/relay/ipv4_packet_buffer.rs
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use super::binary;
use super::byte_buffer::ByteBuffer;
use super::ipv4_header;
use super::ipv4_packet::{Ipv4Packet, MAX_PACKET_LENGTH};
use log::*;
use std::io;
pub struct Ipv4PacketBuffer {
buf: ByteBuffer,
}
impl Ipv4PacketBuffer {
pub fn new() -> Self {
Self {
buf: ByteBuffer::new(MAX_PACKET_LENGTH),
}
}
pub fn read_from(&mut self, source: &mut R) -> io::Result {
self.buf.read_from(source)
}
fn available_packet_length(&self) -> Option {
let data = self.buf.peek();
trace!("Parse packet: {}", binary::build_packet_string(data));
if let Some((version, length)) = ipv4_header::peek_version_length(data) {
assert!(version == 4, "Not an Ipv4 packet, version={}", version);
if length as usize <= data.len() {
// full packet available
Some(length)
} else {
// no full packet available
None
}
} else {
// no packet
None
}
}
pub fn as_ipv4_packet(&mut self) -> Option {
if self.available_packet_length().is_some() {
let data = self.buf.peek_mut();
Some(Ipv4Packet::parse(data))
} else {
None
}
}
pub fn next(&mut self) {
// remove the packet in front of the buffer
let length = self
.available_packet_length()
.expect("next() called while there was no packet") as usize;
self.buf.consume(length);
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::relay::ipv4_header::Protocol;
use crate::relay::transport_header::TransportHeaderData;
use byteorder::{BigEndian, WriteBytesExt};
use std::io;
fn create_packet() -> Vec {
let mut raw = Vec::new();
write_packet_to(&mut raw);
raw
}
fn write_packet_to(raw: &mut Vec) {
raw.write_u8(4u8 << 4 | 5).unwrap();
raw.write_u8(0).unwrap(); // ToS
raw.write_u16::(32).unwrap(); // total length 20 + 8 + 4
raw.write_u32::(0).unwrap(); // id_flags_fragment_offset
raw.write_u8(0).unwrap(); // TTL
raw.write_u8(17).unwrap(); // protocol (UDP)
raw.write_u16::(0).unwrap(); // checksum
raw.write_u32::(0x12345678).unwrap(); // source address
raw.write_u32::(0x42424242).unwrap(); // destination address
raw.write_u16::(1234).unwrap(); // source port
raw.write_u16::(5678).unwrap(); // destination port
raw.write_u16::(12).unwrap(); // length
raw.write_u16::(0).unwrap(); // checksum
raw.write_u32::(0x11223344).unwrap(); // payload
}
fn write_another_packet_to(raw: &mut Vec) {
raw.write_u8(4u8 << 4 | 5).unwrap();
raw.write_u8(0).unwrap(); // ToS
raw.write_u16::(29).unwrap(); // total length 20 + 8 + 1
raw.write_u32::(0).unwrap(); // id_flags_fragment_offset
raw.write_u8(0).unwrap(); // TTL
raw.write_u8(17).unwrap(); // protocol (UDP)
raw.write_u16::(0).unwrap(); // checksum
raw.write_u32::(0x11111111).unwrap(); // source address
raw.write_u32::(0x22222222).unwrap(); // destination address
raw.write_u16::(1111).unwrap(); // source port
raw.write_u16::(2222).unwrap(); // destination port
raw.write_u16::(9).unwrap(); // length
raw.write_u16::(0).unwrap(); // checksum
raw.write_u8(0x99).unwrap(); // payload
}
fn check_packet_headers(ipv4_packet: &Ipv4Packet) {
let ipv4_header = ipv4_packet.ipv4_header();
assert_eq!(20, ipv4_header.header_length());
assert_eq!(32, ipv4_header.total_length());
assert_eq!(Protocol::Udp, ipv4_header.protocol());
assert_eq!(0x12345678, ipv4_header.source());
assert_eq!(0x42424242, ipv4_header.destination());
if let Some(&TransportHeaderData::Udp(ref udp_header)) = ipv4_packet.transport_header_data()
{
assert_eq!(1234, udp_header.source_port());
assert_eq!(5678, udp_header.destination_port());
} else {
panic!("No UDP transport header");
}
}
fn check_another_packet_headers(ipv4_packet: &Ipv4Packet) {
let ipv4_header = ipv4_packet.ipv4_header();
assert_eq!(20, ipv4_header.header_length());
assert_eq!(29, ipv4_header.total_length());
assert_eq!(Protocol::Udp, ipv4_header.protocol());
assert_eq!(0x11111111, ipv4_header.source());
assert_eq!(0x22222222, ipv4_header.destination());
if let Some(&TransportHeaderData::Udp(ref udp_header)) = ipv4_packet.transport_header_data()
{
assert_eq!(1111, udp_header.source_port());
assert_eq!(2222, udp_header.destination_port());
} else {
panic!("No UDP transport header");
}
}
#[test]
fn parse_ipv4_packet_buffer() {
let raw = create_packet();
let mut packet_buffer = Ipv4PacketBuffer::new();
let mut cursor = io::Cursor::new(raw);
packet_buffer.read_from(&mut cursor).unwrap();
let packet = packet_buffer.as_ipv4_packet().unwrap();
check_packet_headers(&packet);
}
#[test]
fn parse_fragmented_ipv4_packet_buffer() {
let raw = create_packet();
let mut packet_buffer = Ipv4PacketBuffer::new();
let mut cursor = io::Cursor::new(&raw[..14]);
packet_buffer.read_from(&mut cursor).unwrap();
assert!(packet_buffer.as_ipv4_packet().is_none());
let mut cursor = io::Cursor::new(&raw[14..]);
packet_buffer.read_from(&mut cursor).unwrap();
let packet = packet_buffer.as_ipv4_packet().unwrap();
check_packet_headers(&packet);
}
fn create_multi_packets() -> Vec {
let mut raw = Vec::new();
write_packet_to(&mut raw);
write_another_packet_to(&mut raw);
write_packet_to(&mut raw);
raw
}
#[test]
fn parse_multi_packets() {
let raw = create_multi_packets();
let mut packet_buffer = Ipv4PacketBuffer::new();
let mut cursor = io::Cursor::new(raw);
packet_buffer.read_from(&mut cursor).unwrap();
check_packet_headers(&packet_buffer.as_ipv4_packet().unwrap());
packet_buffer.next();
check_another_packet_headers(&packet_buffer.as_ipv4_packet().unwrap());
packet_buffer.next();
check_packet_headers(&packet_buffer.as_ipv4_packet().unwrap());
packet_buffer.next();
assert!(packet_buffer.as_ipv4_packet().is_none());
}
}
================================================
FILE: relay-rust/src/relay/mod.rs
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
pub use self::relay::Relay;
pub mod byte_buffer;
mod binary;
mod client;
mod close_listener;
#[macro_use]
mod connection;
mod datagram;
mod datagram_buffer;
#[macro_use]
mod interrupt;
mod ipv4_header;
mod ipv4_packet;
mod ipv4_packet_buffer;
mod net;
mod packet_source;
mod packetizer;
#[allow(clippy::module_inception)] // relay.rs is in relay/
mod relay;
mod router;
mod selector;
mod stream_buffer;
mod tcp_connection;
mod tcp_header;
mod transport_header;
mod tunnel_server;
mod udp_connection;
mod udp_header;
================================================
FILE: relay-rust/src/relay/net.rs
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use super::binary;
use std::net::{Ipv4Addr, SocketAddrV4};
pub fn to_addr(ipv4: u32) -> Ipv4Addr {
let raw = binary::to_byte_array(ipv4);
Ipv4Addr::new(raw[0], raw[1], raw[2], raw[3])
}
pub fn to_socket_addr(ipv4: u32, port: u16) -> SocketAddrV4 {
let addr = to_addr(ipv4);
SocketAddrV4::new(addr, port)
}
================================================
FILE: relay-rust/src/relay/packet_source.rs
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use super::ipv4_packet::Ipv4Packet;
use super::selector::Selector;
/// Source that may produce packets.
///
/// When a `TcpConnection` sends a packet to the `Client` while its buffers are full, then it
/// fails. To recover, once some space becomes available, the `Client` must pull the available
/// packets.
///
/// This trait provides the abstraction of a packet source from which it can pull packets.
///
/// It is implemented by `TcpConnection`.
pub trait PacketSource {
fn get(&mut self) -> Option;
fn next(&mut self, selector: &mut Selector);
}
================================================
FILE: relay-rust/src/relay/packetizer.rs
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use std::io;
use super::datagram::{DatagramReceiver, ReadAdapter};
use super::ipv4_header::{Ipv4Header, Ipv4HeaderData, Ipv4HeaderMut};
use super::ipv4_packet::{Ipv4Packet, MAX_PACKET_LENGTH};
use super::transport_header::{TransportHeader, TransportHeaderData, TransportHeaderMut};
/// Convert from level 5 to level 3 by appending correct IP and transport headers.
pub struct Packetizer {
buffer: Box<[u8; MAX_PACKET_LENGTH]>,
transport_index: usize,
payload_index: usize,
ipv4_header_data: Ipv4HeaderData,
transport_header_data: TransportHeaderData,
}
impl Packetizer {
pub fn new(
reference_ipv4_header: &Ipv4Header,
reference_transport_header: &TransportHeader,
) -> Self {
let mut buffer = Box::new([0; MAX_PACKET_LENGTH]);
let transport_index = reference_ipv4_header.header_length() as usize;
let payload_index = transport_index + reference_transport_header.header_length() as usize;
let mut ipv4_header_data = reference_ipv4_header.data().clone();
let mut transport_header_data = reference_transport_header.data_clone();
{
let ipv4_header_raw = &mut buffer[..transport_index];
ipv4_header_raw.copy_from_slice(reference_ipv4_header.raw());
let mut ipv4_header = ipv4_header_data.bind_mut(ipv4_header_raw);
ipv4_header.swap_source_and_destination();
}
{
let transport_header_raw = &mut buffer[transport_index..payload_index];
transport_header_raw.copy_from_slice(reference_transport_header.raw());
let mut transport_header = transport_header_data.bind_mut(transport_header_raw);
transport_header.swap_source_and_destination();
}
Self {
buffer,
transport_index,
payload_index,
ipv4_header_data,
transport_header_data,
}
}
pub fn packetize_empty_payload(&mut self) -> Ipv4Packet {
self.build(0)
}
pub fn packetize(&mut self, source: &mut R) -> io::Result {
let r = source.recv(&mut self.buffer[self.payload_index..])?;
let ipv4_packet = self.build(r as u16);
Ok(ipv4_packet)
}
/// Packetize from stream (`Read`) source.
///
/// `Ok(Some(_))` when packet is available
/// `Ok(None)` on EOF (read 0 byte)
/// `Err(_)` on error
pub fn packetize_read(
&mut self,
source: &mut R,
max_chunk_size: Option,
) -> io::Result> {
let mut adapter = ReadAdapter::new(source, max_chunk_size);
let r = adapter.recv(&mut self.buffer[self.payload_index..])?;
let option = if r > 0 {
let ipv4_packet = self.build(r as u16);
Some(ipv4_packet)
} else {
None
};
Ok(option)
}
pub fn ipv4_header_mut(&mut self) -> Ipv4HeaderMut {
let raw = &mut self.buffer[..self.transport_index];
self.ipv4_header_data.bind_mut(raw)
}
pub fn transport_header_mut(&mut self) -> TransportHeaderMut {
let raw = &mut self.buffer[self.transport_index..self.payload_index];
self.transport_header_data.bind_mut(raw)
}
fn build(&mut self, payload_length: u16) -> Ipv4Packet {
let total_length = self.payload_index as u16 + payload_length;
self.ipv4_header_mut().set_total_length(total_length);
self.transport_header_mut()
.set_payload_length(payload_length);
let mut ipv4_packet = Ipv4Packet::new(
&mut self.buffer[..total_length as usize],
self.ipv4_header_data.clone(),
self.transport_header_data.clone(),
);
ipv4_packet.compute_checksums();
ipv4_packet
}
pub fn inflate(&mut self, packet_length: u16) -> Ipv4Packet {
Ipv4Packet::new(
&mut self.buffer[..packet_length as usize],
self.ipv4_header_data.clone(),
self.transport_header_data.clone(),
)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::relay::datagram::tests::MockDatagramSocket;
use byteorder::{BigEndian, WriteBytesExt};
use std::io;
fn create_packet() -> Vec {
let mut raw = Vec::new();
raw.write_u8(4u8 << 4 | 5).unwrap();
raw.write_u8(0).unwrap(); // ToS
raw.write_u16::(32).unwrap(); // total length 20 + 8 + 4
raw.write_u32::(0).unwrap(); // id_flags_fragment_offset
raw.write_u8(0).unwrap(); // TTL
raw.write_u8(17).unwrap(); // protocol (UDP)
raw.write_u16::(0).unwrap(); // checksum
raw.write_u32::(0x12345678).unwrap(); // source address
raw.write_u32::(0x42424242).unwrap(); // destination address
raw.write_u16::(1234).unwrap(); // source port
raw.write_u16::(5678).unwrap(); // destination port
raw.write_u16::(12).unwrap(); // length
raw.write_u16::(0).unwrap(); // checksum
raw.write_u32::(0x11223344).unwrap(); // payload
raw
}
#[test]
fn merge_headers_and_payload() {
let raw = &mut create_packet()[..];
let reference_packet = Ipv4Packet::parse(raw);
let data = [0x11u8, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88];
let mut mock = MockDatagramSocket::from_data(&data);
let ipv4_header = reference_packet.ipv4_header();
let transport_header = reference_packet.transport_header().unwrap();
let mut packetizer = Packetizer::new(&ipv4_header, &transport_header);
let packet = packetizer.packetize(&mut mock).unwrap();
assert_eq!(36, packet.ipv4_header_data().total_length());
assert_eq!(data, &packet.raw()[28..36]);
}
#[test]
fn last_packet() {
let raw = &mut create_packet()[..];
let reference_packet = Ipv4Packet::parse(raw);
let data = [0x11u8, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88];
let mut mock = MockDatagramSocket::from_data(&data);
let ipv4_header = reference_packet.ipv4_header();
let transport_header = reference_packet.transport_header().unwrap();
let mut packetizer = Packetizer::new(&ipv4_header, &transport_header);
let packet_length = packetizer.packetize(&mut mock).unwrap().length();
let packet = packetizer.inflate(packet_length);
assert_eq!(36, packet.ipv4_header_data().total_length());
assert_eq!(data, &packet.raw()[28..36]);
}
#[test]
fn packetize_chunks() {
let raw = &mut create_packet()[..];
let reference_packet = Ipv4Packet::parse(raw);
let data = [0x11u8, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88];
let mut cursor = io::Cursor::new(&data);
let ipv4_header = reference_packet.ipv4_header();
let transport_header = reference_packet.transport_header().unwrap();
let mut packetizer = Packetizer::new(&ipv4_header, &transport_header);
{
let packet = packetizer
.packetize_read(&mut cursor, Some(2))
.unwrap()
.unwrap();
assert_eq!(30, packet.ipv4_header_data().total_length());
assert_eq!([0x11, 0x22], packet.payload().unwrap());
}
{
let packet = packetizer
.packetize_read(&mut cursor, Some(3))
.unwrap()
.unwrap();
assert_eq!(31, packet.ipv4_header_data().total_length());
assert_eq!([0x33, 0x44, 0x55], packet.payload().unwrap());
}
{
let packet = packetizer
.packetize_read(&mut cursor, Some(1024))
.unwrap()
.unwrap();
assert_eq!(31, packet.ipv4_header_data().total_length());
assert_eq!([0x66, 0x77, 0x88], packet.payload().unwrap());
}
}
}
================================================
FILE: relay-rust/src/relay/relay.rs
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use chrono::Local;
use log::*;
use mio::Events;
use std::cell::RefCell;
use std::cmp::max;
use std::io;
use std::rc::Rc;
use std::time::Duration;
use super::selector::Selector;
use super::tunnel_server::TunnelServer;
use super::udp_connection::IDLE_TIMEOUT_SECONDS;
const TAG: &str = "Relay";
const CLEANING_INTERVAL_SECONDS: i64 = 60;
pub struct Relay {
port: u16,
}
impl Relay {
pub fn new(port: u16) -> Self {
Self { port }
}
pub fn run(&self) -> io::Result<()> {
let mut selector = Selector::create().unwrap();
let tunnel_server = TunnelServer::create(self.port, &mut selector)?;
info!(target: TAG, "Relay server started");
self.poll_loop(&mut selector, &tunnel_server)
}
fn poll_loop(
&self,
selector: &mut Selector,
tunnel_server: &Rc>,
) -> io::Result<()> {
let mut events = Events::with_capacity(1024);
// no connection may expire before the UDP idle timeout delay
let mut next_cleaning_deadline = Local::now().timestamp() + IDLE_TIMEOUT_SECONDS as i64;
loop {
retry_on_intr!({
let timeout_seconds = max(0, next_cleaning_deadline - Local::now().timestamp());
let timeout = Some(Duration::new(timeout_seconds as u64, 0));
selector.poll(&mut events, timeout)
})?;
let now = Local::now().timestamp();
if now >= next_cleaning_deadline {
tunnel_server.borrow_mut().clean_up(selector);
next_cleaning_deadline = now + CLEANING_INTERVAL_SECONDS;
} else if events.is_empty() {
debug!(
target: TAG,
"Spurious wakeup: poll() returned without any event"
);
continue;
}
selector.run_handlers(&events);
}
}
}
================================================
FILE: relay-rust/src/relay/router.rs
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use log::*;
use std::cell::RefCell;
use std::io;
use std::rc::{Rc, Weak};
use super::binary;
use super::client::{Client, ClientChannel};
use super::connection::{Connection, ConnectionId};
use super::ipv4_header::Protocol;
use super::ipv4_packet::Ipv4Packet;
use super::selector::Selector;
use super::tcp_connection::TcpConnection;
use super::udp_connection::UdpConnection;
const TAG: &str = "Router";
pub struct Router {
client: Weak>,
// there are typically only few connections per client, HashMap would be less efficient
connections: Vec>>,
}
impl Router {
pub fn new() -> Self {
Self {
client: Weak::new(),
connections: Vec::new(),
}
}
// expose client initialization after construction to break cyclic initialization dependencies
pub fn set_client(&mut self, client: Weak>) {
self.client = client;
}
pub fn send_to_network(
&mut self,
selector: &mut Selector,
client_channel: &mut ClientChannel,
ipv4_packet: &Ipv4Packet,
) {
if ipv4_packet.is_valid() {
match self.connection(selector, ipv4_packet) {
Ok(index) => {
let closed = {
let connection_ref = &self.connections[index];
let mut connection = connection_ref.borrow_mut();
connection.send_to_network(selector, client_channel, ipv4_packet);
if connection.is_closed() {
debug!(
target: TAG,
"Removing connection from router: {}",
connection.id()
);
true
} else {
false
}
};
if closed {
// the connection is closed, remove it
self.connections.swap_remove(index);
}
}
Err(err) => error!(target: TAG, "Cannot create route, dropping packet: {}", err),
}
} else {
warn!(target: TAG, "Dropping invalid packet");
if log_enabled!(target: TAG, Level::Trace) {
trace!(
target: TAG,
"{}",
binary::build_packet_string(ipv4_packet.raw())
);
}
}
}
fn connection(
&mut self,
selector: &mut Selector,
ipv4_packet: &Ipv4Packet,
) -> io::Result {
let (ipv4_header_data, transport_header_data) = ipv4_packet.headers_data();
let transport_header_data = transport_header_data.expect("No transport");
let id = ConnectionId::from_headers(ipv4_header_data, transport_header_data);
let index = match self.find_index(&id) {
Some(index) => index,
None => {
let connection =
Self::create_connection(selector, id, self.client.clone(), ipv4_packet)?;
let index = self.connections.len();
self.connections.push(connection);
index
}
};
Ok(index)
}
fn create_connection(
selector: &mut Selector,
id: ConnectionId,
client: Weak>,
ipv4_packet: &Ipv4Packet,
) -> io::Result>> {
let (ipv4_header, transport_header) = ipv4_packet.headers();
let transport_header = transport_header.expect("No transport");
match id.protocol() {
Protocol::Tcp => Ok(TcpConnection::create(
selector,
id,
client,
ipv4_header,
transport_header,
)?),
Protocol::Udp => Ok(UdpConnection::create(
selector,
id,
client,
ipv4_header,
transport_header,
)?),
p => Err(io::Error::new(
io::ErrorKind::Other,
format!("Unsupported protocol: {:?}", p),
)),
}
}
fn find_index(&self, id: &ConnectionId) -> Option {
self.connections
.iter()
.position(|connection| connection.borrow().id() == id)
}
pub fn remove(&mut self, connection: &dyn Connection) {
let index = self
.connections
.iter()
.position(|item| {
// compare (thin) pointers to find the connection to remove
binary::ptr_data_eq(connection, item.as_ptr())
})
.expect("Removing an unknown connection");
debug!(
target: TAG,
"Self-removing connection from router: {}",
connection.id()
);
self.connections.swap_remove(index);
}
pub fn clear(&mut self, selector: &mut Selector) {
for connection in &mut self.connections {
connection.borrow_mut().close(selector);
}
self.connections.clear();
}
pub fn clean_expired_connections(&mut self, selector: &mut Selector) {
// remove the last items first, otherwise i might not be less than len() on swap_remove(i)
for i in (0..self.connections.len()).rev() {
let expired = {
let mut connection = self.connections[i].borrow_mut();
if connection.is_expired() {
debug!(
target: TAG,
"Removing expired connection from router: {}",
connection.id()
);
connection.close(selector);
true
} else {
false
}
};
if expired {
self.connections.swap_remove(i);
}
}
}
}
================================================
FILE: relay-rust/src/relay/selector.rs
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use log::*;
use mio::{Event, Evented, Events, Poll, PollOpt, Ready, Token};
use slab::Slab;
use std::io;
use std::rc::Rc;
use std::time::Duration;
const TAG: &str = "Selector";
pub trait EventHandler {
fn on_ready(&self, selector: &mut Selector, event: Event);
}
impl EventHandler for F
where
F: Fn(&mut Selector, Event),
{
fn on_ready(&self, selector: &mut Selector, event: Event) {
self(selector, event);
}
}
pub struct Selector {
poll: Poll,
handlers: Slab>,
// tokens to be removed after all the current poll events are executed
tokens_to_remove: Vec,
}
impl Selector {
pub fn create() -> io::Result {
Ok(Self {
poll: Poll::new()?,
handlers: Slab::with_capacity(1024),
tokens_to_remove: Vec::new(),
})
}
pub fn register(
&mut self,
handle: &E,
handler: H,
interest: Ready,
opts: PollOpt,
) -> io::Result
where
E: Evented + ?Sized,
H: EventHandler + 'static,
{
let token = Token(self.handlers.insert(Rc::new(handler)));
if let Err(err) = self.poll.register(handle, token, interest, opts) {
// remove the token we just added
self.handlers.remove(token.0);
Err(err)
} else {
Ok(token)
}
}
pub fn reregister(
&mut self,
handle: &E,
token: Token,
interest: Ready,
opts: PollOpt,
) -> io::Result<()>
where
E: Evented + ?Sized,
{
self.poll.reregister(handle, token, interest, opts)
}
pub fn deregister(&mut self, handle: &E, token: Token) -> io::Result<()>
where
E: Evented + ?Sized,
{
self.poll.deregister(handle)?;
// remove them before next poll()
self.tokens_to_remove.push(token);
Ok(())
}
fn clean_removed_tokens(&mut self) {
for &token in &self.tokens_to_remove {
self.handlers.remove(token.0);
}
self.tokens_to_remove.clear();
}
pub fn poll(&mut self, events: &mut Events, timeout: Option) -> io::Result {
self.poll.poll(events, timeout)
}
pub fn run_handlers(&mut self, events: &Events) {
for event in events {
debug!(target: TAG, "event={:?}", event);
let handler = self
.handlers
.get_mut(event.token().0)
.expect("Token not found")
.clone();
handler.on_ready(self, event);
}
// remove the tokens marked as removed
self.clean_removed_tokens();
}
}
================================================
FILE: relay-rust/src/relay/stream_buffer.rs
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use std::io;
/// Circular buffer to store a stream. Read/write boundaries are not preserved.
pub struct StreamBuffer {
buf: Box<[u8]>,
head: usize,
tail: usize,
}
impl StreamBuffer {
pub fn new(capacity: usize) -> Self {
Self {
buf: vec![0; capacity + 1].into_boxed_slice(),
head: 0,
tail: 0,
}
}
pub fn is_empty(&self) -> bool {
self.head == self.tail
}
pub fn size(&self) -> usize {
if self.head < self.tail {
self.head + self.buf.len() - self.tail
} else {
self.head - self.tail
}
}
pub fn capacity(&self) -> usize {
self.buf.len() - 1
}
pub fn remaining(&self) -> usize {
self.capacity() - self.size()
}
pub fn write_to(&mut self, destination: &mut W) -> io::Result {
if self.head == self.tail {
// buffer is empty, nothing to do
Ok(0)
} else {
let w;
if self.head > self.tail {
let source_slice = &self.buf[self.tail..self.head];
w = destination.write(source_slice)?;
self.tail += w;
} else {
// self.head < self.tail
let source_slice = &self.buf[self.tail..];
w = destination.write(source_slice)?;
self.tail = (self.tail + w) % self.buf.len();
}
self.optimize();
Ok(w)
}
}
pub fn read_from(&mut self, source: &[u8]) {
assert!(
source.len() <= self.remaining(),
"StreamBuffer is full, check remaining() before calling read_from()"
);
let source_len = source.len();
let buf_len = self.buf.len();
if source_len <= buf_len - self.head {
let target_slice = &mut self.buf[self.head..self.head + source_len];
target_slice.copy_from_slice(source);
} else {
{
// fill until the right-end of the buffer
let target_slice = &mut self.buf[self.head..];
let source_slice = &source[..buf_len - self.head];
target_slice.copy_from_slice(source_slice);
}
// fill the remaining from the left-end of the buffer
let target_slice = &mut self.buf[..self.head + source_len - buf_len];
let source_slice = &source[buf_len - self.head..];
target_slice.copy_from_slice(source_slice);
}
self.head = (self.head + source_len) % buf_len;
}
/// To avoid unnecessary copies, StreamBuffer writes at most until the "end" of the circular
/// buffer, which is suboptimal (it could have written more data if they have been contiguous).
///
/// In order to minimize the occurrence of this event, reset the head and tail to 0 when the
/// buffer is empty (no copy is involved).
///
/// This is especially useful when the StreamBuffer is used to read/write one packet at a time,
/// so the "end" of the buffer is guaranteed to never be reached.
fn optimize(&mut self) {
if self.is_empty() {
self.head = 0;
self.tail = 0;
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn create_data() -> Vec {
(0..6).collect()
}
#[test]
fn bufferize_data() {
let data = create_data();
let mut stream_buffer = StreamBuffer::new(9);
let mut cursor = io::Cursor::new(Vec::new());
stream_buffer.read_from(&data);
stream_buffer.write_to(&mut cursor).unwrap();
assert_eq!(cursor.get_ref(), &data);
}
#[test]
fn circular() {
let data = create_data();
let mut stream_buffer = StreamBuffer::new(9);
// put 6 bytes
stream_buffer.read_from(&data);
// consume 3 bytes
read_some(&mut stream_buffer, 3);
// put test data
stream_buffer.read_from(&data);
// consume 3 bytes (so that the first 6 bytes are consumed, and the "tail" position is 6)
read_some(&mut stream_buffer, 3);
// consume test data
let result = read(&mut stream_buffer);
// StreamBuffer is expected to break writes at circular buffer boundaries (capacity + 1)
// This is not a requirement, but this verifies that the implementation works as expected
assert_eq!([0u8, 1, 2, 3], &result[..]);
// consume the remaining
let result = read(&mut stream_buffer);
assert_eq!([4u8, 5], &result[..]);
}
#[test]
fn just_enough_space() {
let data = create_data();
let mut stream_buffer = StreamBuffer::new(9);
// fill the buffer twice
stream_buffer.read_from(&data);
assert_eq!(3, stream_buffer.remaining());
stream_buffer.read_from(&[0, 1, 2]);
let result = read(&mut stream_buffer);
assert_eq!([0, 1, 2, 3, 4, 5, 0, 1, 2], &result[..]);
}
fn read_some(stream_buffer: &mut StreamBuffer, bytes: usize) -> Vec {
let mut vec = vec![0u8; bytes];
{
let mut cursor = io::Cursor::new(&mut vec[..bytes]);
stream_buffer.write_to(&mut cursor).unwrap();
}
vec
}
fn read(stream_buffer: &mut StreamBuffer) -> Vec {
let mut cursor = io::Cursor::new(Vec::new());
stream_buffer.write_to(&mut cursor).unwrap();
cursor.into_inner()
}
}
================================================
FILE: relay-rust/src/relay/tcp_connection.rs
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use log::*;
use mio::net::TcpStream;
use mio::{Event, PollOpt, Ready, Token};
use rand::random;
use std::cell::RefCell;
use std::cmp;
use std::io;
use std::num::Wrapping;
use std::rc::{Rc, Weak};
use super::binary;
use super::client::{Client, ClientChannel};
use super::connection::{Connection, ConnectionId};
use super::ipv4_header::Ipv4Header;
use super::ipv4_packet::{Ipv4Packet, MAX_PACKET_LENGTH};
use super::packet_source::PacketSource;
use super::packetizer::Packetizer;
use super::selector::Selector;
use super::stream_buffer::StreamBuffer;
use super::tcp_header::{self, TcpHeader, TcpHeaderMut};
use super::transport_header::{TransportHeader, TransportHeaderMut};
const TAG: &str = "TcpConnection";
// same value as GnirehtetService.MTU in the client
const MTU: u16 = 0x4000;
// 20 bytes for IP headers, 20 bytes for TCP headers
const MAX_PAYLOAD_LENGTH: u16 = MTU - 20 - 20 as u16;
pub struct TcpConnection {
self_weak: Weak>,
id: ConnectionId,
client: Weak>,
stream: TcpStream,
interests: Ready,
token: Token,
client_to_network: StreamBuffer,
network_to_client: Packetizer,
packet_for_client_length: Option,
closed: bool,
tcb: Tcb,
}
// Transport Control Block
struct Tcb {
state: TcpState,
syn_sequence_number: u32,
sequence_number: Wrapping,
acknowledgement_number: Wrapping,
their_acknowledgement_number: u32,
fin_sequence_number: Option,
fin_received: bool,
client_window: u16,
}
// See RFC793:
#[derive(Debug, PartialEq, Eq)]
enum TcpState {
Init,
SynSent,
SynReceived,
Established,
CloseWait,
LastAck,
Closing,
FinWait1,
FinWait2,
}
impl TcpState {
fn is_connected(&self) -> bool {
self != &TcpState::Init && self != &TcpState::SynSent && self != &TcpState::SynReceived
}
fn is_closed(&self) -> bool {
self == &TcpState::FinWait1
|| self == &TcpState::FinWait2
|| self == &TcpState::Closing
|| self == &TcpState::LastAck
}
}
impl Tcb {
fn new() -> Self {
Self {
state: TcpState::Init,
syn_sequence_number: 0,
sequence_number: Wrapping(0),
acknowledgement_number: Wrapping(0),
their_acknowledgement_number: 0,
fin_sequence_number: None,
fin_received: false,
client_window: 0,
}
}
fn remaining_client_window(&self) -> u16 {
let wrapped_remaining = Wrapping(self.their_acknowledgement_number)
+ Wrapping(u32::from(self.client_window))
- self.sequence_number;
let remaining = wrapped_remaining.0;
if remaining <= u32::from(self.client_window) {
remaining as u16
} else {
0
}
}
fn numbers(&self) -> String {
format!(
"(seq={}, ack={})",
self.sequence_number, self.acknowledgement_number
)
}
}
impl TcpConnection {
#[allow(clippy::needless_pass_by_value)] // semantically, headers are consumed
pub fn create(
selector: &mut Selector,
id: ConnectionId,
client: Weak>,
ipv4_header: Ipv4Header,
transport_header: TransportHeader,
) -> io::Result>> {
cx_info!(target: TAG, id, "Open");
let stream = Self::create_stream(&id)?;
let tcp_header = Self::tcp_header_of_transport(transport_header);
// shrink the TCP options to pass a minimal refrence header to the packetizer
let mut shrinked_tcp_header_raw = [0u8; 20];
shrinked_tcp_header_raw.copy_from_slice(&tcp_header.raw()[..20]);
let mut shrinked_tcp_header_data = tcp_header.data().clone();
{
let mut shrinked_tcp_header =
shrinked_tcp_header_data.bind_mut(&mut shrinked_tcp_header_raw);
shrinked_tcp_header.shrink_options();
assert_eq!(20, shrinked_tcp_header.header_length());
}
let shrinked_transport_header = shrinked_tcp_header_data
.bind(&shrinked_tcp_header_raw)
.into();
let packetizer = Packetizer::new(&ipv4_header, &shrinked_transport_header);
// interests will be set on the first packet received
// set the initial value now so that they won't need to be updated
let interests = Ready::writable();
let rc = Rc::new(RefCell::new(Self {
self_weak: Weak::new(),
id,
client,
stream,
interests,
token: Token(0), // default value, will be set afterwards
client_to_network: StreamBuffer::new(4 * MAX_PACKET_LENGTH),
network_to_client: packetizer,
packet_for_client_length: None,
closed: false,
tcb: Tcb::new(),
}));
{
let mut self_ref = rc.borrow_mut();
// keep a shared reference to this
self_ref.self_weak = Rc::downgrade(&rc);
let rc2 = rc.clone();
// must annotate selector type: https://stackoverflow.com/a/44004103/1987178
let handler =
move |selector: &mut Selector, event| rc2.borrow_mut().on_ready(selector, event);
let token =
selector.register(&self_ref.stream, handler, interests, PollOpt::level())?;
self_ref.token = token;
}
Ok(rc)
}
fn create_stream(id: &ConnectionId) -> io::Result {
TcpStream::connect(&id.rewritten_destination().into())
}
fn remove_from_router(&self) {
// route is embedded in router which is embedded in client: the client necessarily exists
let client_rc = self.client.upgrade().expect("Expected client not found");
let mut client = client_rc.borrow_mut();
client.router().remove(self);
}
fn on_ready(&mut self, selector: &mut Selector, event: Event) {
#[allow(clippy::match_wild_err_arm)]
match self.process(selector, event) {
Ok(_) => (),
Err(ref err) if err.kind() == io::ErrorKind::WouldBlock => {
cx_debug!(target: TAG, self.id, "Spurious event, ignoring")
}
Err(_) => panic!("Unexpected unhandled error"),
}
}
// return Err(err) with err.kind() == io::ErrorKind::WouldBlock on spurious event
fn process(&mut self, selector: &mut Selector, event: Event) -> io::Result<()> {
if !self.closed {
let ready = event.readiness();
if ready.is_readable() || ready.is_writable() {
if ready.is_writable() {
if self.tcb.state == TcpState::SynSent {
// writable is first triggered when the stream is connected
self.process_connect(selector);
} else {
self.process_send(selector)?;
}
}
if !self.closed && ready.is_readable() {
self.process_receive(selector)?;
}
if !self.closed {
self.update_interests(selector);
}
} else {
cx_debug!(target: TAG, self.id, "received ready = {:?}", ready);
// error or hup
self.close(selector);
}
if self.closed {
// on_ready is not called from the router, so the connection must remove itself
self.remove_from_router();
}
}
Ok(())
}
// return Err(err) with err.kind() == io::ErrorKind::WouldBlock on spurious event
fn process_send(&mut self, selector: &mut Selector) -> io::Result<()> {
match self.client_to_network.write_to(&mut self.stream) {
Ok(w) => {
if w != 0 {
self.tcb.acknowledgement_number += Wrapping(w as u32);
if self.tcb.fin_received && self.client_to_network.is_empty() {
let client_rc = self.client.upgrade().expect("Expected client not found");
let mut client = client_rc.borrow_mut();
cx_debug!(
target: TAG,
self.id,
"No more pending data, process the pending FIN"
);
self.do_handle_fin(selector, &mut client.channel());
} else {
cx_debug!(
target: TAG,
self.id,
"Sending ACK {} to client",
self.tcb.numbers()
);
self.send_empty_packet_to_client(selector, tcp_header::FLAG_ACK);
}
} else {
self.close(selector);
}
}
Err(err) => {
if err.kind() == io::ErrorKind::WouldBlock {
// rethrow
return Err(err);
}
cx_error!(
target: TAG,
self.id,
"Cannot write: [{:?}] {}",
err.kind(),
err
);
self.send_empty_packet_to_client(selector, tcp_header::FLAG_RST);
self.close(selector);
}
}
Ok(())
}
// return Err(err) with err.kind() == io::ErrorKind::WouldBlock on spurious event
fn process_receive(&mut self, selector: &mut Selector) -> io::Result<()> {
assert!(
self.packet_for_client_length.is_none(),
"A pending packet was not sent"
);
let remaining_client_window = self.tcb.remaining_client_window();
assert!(
remaining_client_window > 0,
"process_received() must not be called when window == 0"
);
let max_payload_length =
Some(cmp::min(remaining_client_window, MAX_PAYLOAD_LENGTH) as usize);
Self::update_headers(
&mut self.network_to_client,
&self.tcb,
tcp_header::FLAG_ACK | tcp_header::FLAG_PSH,
);
match self
.network_to_client
.packetize_read(&mut self.stream, max_payload_length)
{
Ok(Some(ipv4_packet)) => {
match Self::send_to_client(&self.client, selector, &ipv4_packet) {
Ok(_) => {
let len = ipv4_packet.payload().unwrap().len();
cx_debug!(
target: TAG,
self.id,
"Packet ({} bytes) sent to client {}",
len,
self.tcb.numbers()
);
self.tcb.sequence_number += Wrapping(len as u32);
}
Err(_) => {
// ask to the client to pull when its buffer is not full
let client_rc = self.client.upgrade().expect("Expected client not found");
let mut client = client_rc.borrow_mut();
let self_rc = self.self_weak.upgrade().unwrap();
client.register_pending_packet_source(self_rc);
self.packet_for_client_length = Some(ipv4_packet.length());
}
};
}
Ok(None) => {
self.eof(selector);
}
Err(err) => {
if err.kind() == io::ErrorKind::WouldBlock {
// rethrow
return Err(err);
}
cx_error!(
target: TAG,
self.id,
"Cannot read: [{:?}] {}",
err.kind(),
err
);
self.send_empty_packet_to_client(selector, tcp_header::FLAG_RST);
self.close(selector);
}
}
Ok(())
}
fn process_connect(&mut self, selector: &mut Selector) {
assert_eq!(self.tcb.state, TcpState::SynSent);
self.tcb.state = TcpState::SynReceived;
cx_debug!(target: TAG, self.id, "State = {:?}", self.tcb.state);
self.send_empty_packet_to_client(selector, tcp_header::FLAG_SYN | tcp_header::FLAG_ACK);
self.tcb.sequence_number += Wrapping(1); // SYN counts for 1 byte
}
fn send_to_client(
client: &Weak>,
selector: &mut Selector,
ipv4_packet: &Ipv4Packet,
) -> io::Result<()> {
let client_rc = client.upgrade().expect("Expected client not found");
let mut client = client_rc.borrow_mut();
client.send_to_client(selector, &ipv4_packet)
}
/// Borrow self.client and send empty packet to it
///
/// To be used if called by on_ready() (so the client is not borrowed yet).
fn send_empty_packet_to_client(&mut self, selector: &mut Selector, flags: u16) {
let client_rc = self.client.upgrade().expect("Expected client not found");
let mut client = client_rc.borrow_mut();
self.reply_empty_packet_to_client(selector, &mut client.channel(), flags)
}
/// Send empty packet to the client channel (that already borrows the client)
///
/// To be used if called by send_to_network() (called by the client, so it is already
/// borrowed).
fn reply_empty_packet_to_client(
&mut self,
selector: &mut Selector,
client_channel: &mut ClientChannel,
flags: u16,
) {
let ipv4_packet = Self::create_empty_response_packet(
&self.id,
&mut self.network_to_client,
&self.tcb,
flags,
);
if let Err(err) = client_channel.send_to_client(selector, &ipv4_packet) {
// losing such an empty packet will not break the TCP connection
cx_warn!(
target: TAG,
self.id,
"Cannot send packet to client: {}",
err
);
}
}
fn eof(&mut self, selector: &mut Selector) {
self.send_empty_packet_to_client(selector, tcp_header::FLAG_FIN | tcp_header::FLAG_ACK);
self.tcb.fin_sequence_number = Some(self.tcb.sequence_number.0);
self.tcb.sequence_number += Wrapping(1); // FIN counts for 1 byte
self.tcb.state = if self.tcb.state == TcpState::CloseWait {
TcpState::LastAck
} else {
TcpState::FinWait1
};
cx_debug!(target: TAG, self.id, "State = {:?}", self.tcb.state);
}
#[inline]
fn tcp_header_of_transport(transport_header: TransportHeader) -> TcpHeader {
if let TransportHeader::Tcp(tcp_header) = transport_header {
tcp_header
} else {
panic!("Not a TCP header");
}
}
#[inline]
fn tcp_header_of_transport_mut(transport_header: TransportHeaderMut) -> TcpHeaderMut {
if let TransportHeaderMut::Tcp(tcp_header) = transport_header {
tcp_header
} else {
panic!("Not a TCP header");
}
}
#[inline]
fn tcp_header_of_packet<'a>(ipv4_packet: &'a Ipv4Packet) -> TcpHeader<'a> {
if let Some(TransportHeader::Tcp(tcp_header)) = ipv4_packet.transport_header() {
tcp_header
} else {
panic!("Not a TCP packet");
}
}
fn update_headers(packetizer: &mut Packetizer, tcb: &Tcb, flags: u16) {
let mut tcp_header = Self::tcp_header_of_transport_mut(packetizer.transport_header_mut());
tcp_header.set_sequence_number(tcb.sequence_number.0);
tcp_header.set_acknowledgement_number(tcb.acknowledgement_number.0);
tcp_header.set_flags(flags);
}
fn handle_packet(
&mut self,
selector: &mut Selector,
client_channel: &mut ClientChannel,
ipv4_packet: &Ipv4Packet,
) {
let tcp_header = Self::tcp_header_of_packet(ipv4_packet);
if self.tcb.state == TcpState::Init {
self.handle_first_packet(selector, client_channel, ipv4_packet);
return;
}
if tcp_header.is_syn() {
self.handle_duplicate_syn(selector, client_channel, ipv4_packet);
return;
}
let expected_packet =
(self.tcb.acknowledgement_number + Wrapping(self.client_to_network.size() as u32)).0;
if tcp_header.sequence_number() != expected_packet {
// ignore packet already received or out-of-order, retransmission is already
// managed by both sides
cx_warn!(
target: TAG,
self.id,
"Ignoring packet {} (acking {}); expecting {}; flags={}",
tcp_header.sequence_number(),
tcp_header.acknowledgement_number(),
expected_packet,
tcp_header.flags()
);
return;
}
self.tcb.client_window = tcp_header.window();
self.tcb.their_acknowledgement_number = tcp_header.acknowledgement_number();
cx_debug!(
target: TAG,
self.id,
"Receiving expected packet {} (flags={})",
tcp_header.sequence_number(),
tcp_header.flags()
);
if tcp_header.is_rst() {
self.close(selector);
return;
}
if tcp_header.is_ack() {
cx_debug!(
target: TAG,
self.id,
"Client acked {}",
tcp_header.acknowledgement_number()
);
self.handle_ack(selector, client_channel, ipv4_packet);
}
if tcp_header.is_fin() {
self.handle_fin(selector, client_channel);
}
if let Some(fin_sequence_number) = self.tcb.fin_sequence_number {
if tcp_header.acknowledgement_number() == fin_sequence_number + 1 {
cx_debug!(target: TAG, self.id, "Received ACK of FIN");
self.handle_fin_ack(selector);
}
}
}
fn handle_first_packet(
&mut self,
selector: &mut Selector,
client_channel: &mut ClientChannel,
ipv4_packet: &Ipv4Packet,
) {
cx_debug!(target: TAG, self.id, "handle_first_packet()");
let tcp_header = Self::tcp_header_of_packet(ipv4_packet);
if tcp_header.is_syn() {
let their_sequence_number = tcp_header.sequence_number();
self.tcb.acknowledgement_number = Wrapping(their_sequence_number) + Wrapping(1);
self.tcb.syn_sequence_number = their_sequence_number;
self.tcb.sequence_number = Wrapping(random::());
cx_debug!(
target: TAG,
self.id,
"Initialized seq={}; ack={}",
self.tcb.sequence_number,
self.tcb.acknowledgement_number
);
self.tcb.client_window = tcp_header.window();
self.tcb.state = TcpState::SynSent;
cx_debug!(target: TAG, self.id, "State = {:?}", self.tcb.state);
} else {
cx_warn!(
target: TAG,
self.id,
"Unexpected first packet {}; acking {}; flags={}",
tcp_header.sequence_number(),
tcp_header.acknowledgement_number(),
tcp_header.flags()
);
// make a RST in the window client
self.tcb.sequence_number = Wrapping(tcp_header.acknowledgement_number());
self.reply_empty_packet_to_client(selector, client_channel, tcp_header::FLAG_RST);
self.close(selector);
}
}
fn handle_duplicate_syn(
&mut self,
selector: &mut Selector,
client_channel: &mut ClientChannel,
ipv4_packet: &Ipv4Packet,
) {
let tcp_header = Self::tcp_header_of_packet(ipv4_packet);
let their_sequence_number = tcp_header.sequence_number();
if self.tcb.state == TcpState::SynSent {
// the connection is not established yet, we can accept this packet as if it were the
// first SYN
self.tcb.syn_sequence_number = their_sequence_number;
self.tcb.acknowledgement_number = Wrapping(their_sequence_number) + Wrapping(1);
} else if their_sequence_number != self.tcb.syn_sequence_number {
// duplicate SYN with different sequence number
self.reply_empty_packet_to_client(selector, client_channel, tcp_header::FLAG_RST);
self.close(selector);
}
}
fn handle_fin(&mut self, selector: &mut Selector, client_channel: &mut ClientChannel) {
cx_debug!(
target: TAG,
self.id,
"Received a FIN from the client {}",
self.tcb.numbers()
);
self.tcb.fin_received = true;
if self.client_to_network.is_empty() {
cx_debug!(
target: TAG,
self.id,
"No pending data, process the FIN immediately"
);
self.do_handle_fin(selector, client_channel);
}
// otherwise, the FIN will be processed once client_to_network is empty
}
fn do_handle_fin(&mut self, selector: &mut Selector, client_channel: &mut ClientChannel) {
self.tcb.acknowledgement_number += Wrapping(1); // received FIN counts for 1 byte
if self.tcb.state == TcpState::Established {
self.reply_empty_packet_to_client(
selector,
client_channel,
tcp_header::FLAG_FIN | tcp_header::FLAG_ACK,
);
self.tcb.fin_sequence_number = Some(self.tcb.sequence_number.0);
self.tcb.sequence_number += Wrapping(1); // FIN counts for 1 byte
// the connection will be closed by RAII, so switch immediately to LastAck
// (bypass CloseWait)
self.tcb.state = TcpState::LastAck;
cx_debug!(target: TAG, self.id, "State = {:?}", self.tcb.state);
} else if self.tcb.state == TcpState::FinWait1 {
self.reply_empty_packet_to_client(selector, client_channel, tcp_header::FLAG_ACK);
self.tcb.state = TcpState::Closing;
cx_debug!(target: TAG, self.id, "State = {:?}", self.tcb.state);
} else if self.tcb.state == TcpState::FinWait2 {
self.reply_empty_packet_to_client(selector, client_channel, tcp_header::FLAG_ACK);
self.close(selector);
} else {
cx_warn!(
target: TAG,
self.id,
"Received FIN was state was {:?}",
self.tcb.state
);
}
}
fn handle_fin_ack(&mut self, selector: &mut Selector) {
if self.tcb.state == TcpState::LastAck || self.tcb.state == TcpState::Closing {
self.close(selector);
} else if self.tcb.state == TcpState::FinWait1 {
self.tcb.state = TcpState::FinWait2;
cx_debug!(target: TAG, self.id, "State = {:?}", self.tcb.state);
} else if self.tcb.state != TcpState::FinWait2 {
cx_warn!(
target: TAG,
self.id,
"Received FIN ACK while state was {:?}",
self.tcb.state
);
}
}
fn handle_ack(
&mut self,
_selector: &mut Selector,
_client_channel: &mut ClientChannel,
ipv4_packet: &Ipv4Packet,
) {
cx_debug!(target: TAG, self.id, "handle_ack()");
if self.tcb.state == TcpState::SynReceived {
self.tcb.state = TcpState::Established;
cx_debug!(target: TAG, self.id, "State = {:?}", self.tcb.state);
return;
}
if log_enabled!(target: TAG, Level::Trace) {
cx_trace!(
target: TAG,
self.id,
"{}",
binary::build_packet_string(ipv4_packet.raw())
);
}
let payload = ipv4_packet.payload().expect("No payload");
if payload.is_empty() {
// no data to transmit
return;
}
if self.client_to_network.remaining() < payload.len() {
cx_warn!(target: TAG, self.id, "Not enough space, dropping packet");
return;
}
self.client_to_network.read_from(payload);
// data will be ACKed once written to the network socket
}
fn create_empty_response_packet<'a>(
id: &ConnectionId,
packetizer: &'a mut Packetizer,
tcb: &Tcb,
flags: u16,
) -> Ipv4Packet<'a> {
Self::update_headers(packetizer, tcb, flags);
cx_debug!(
target: TAG,
id,
"Forging empty response (flags={}) {}",
flags,
tcb.numbers()
);
if (flags & tcp_header::FLAG_ACK) != 0 {
cx_debug!(target: TAG, id, "Acking {}", tcb.numbers());
}
let ipv4_packet = packetizer.packetize_empty_payload();
if log_enabled!(target: TAG, Level::Trace) {
cx_trace!(
target: TAG,
id,
"{}",
binary::build_packet_string(ipv4_packet.raw())
);
}
ipv4_packet
}
fn update_interests(&mut self, selector: &mut Selector) {
assert!(!self.closed);
let mut ready = Ready::empty();
if self.tcb.state == TcpState::SynSent {
// waiting for connectable
ready = Ready::writable()
} else {
if self.may_read() {
ready |= Ready::readable()
}
if self.may_write() {
ready |= Ready::writable()
}
}
cx_debug!(target: TAG, self.id, "interests: {:?}", ready);
if self.interests != ready {
// interests must be changed
self.interests = ready;
selector
.reregister(&self.stream, self.token, ready, PollOpt::level())
.expect("Cannot register on poll");
}
}
fn may_read(&self) -> bool {
if !self.tcb.state.is_connected() || self.tcb.state.is_closed() {
return false;
}
if self.packet_for_client_length.is_some() {
// a packet is already pending
return false;
}
self.tcb.remaining_client_window() > 0
}
fn may_write(&self) -> bool {
!self.client_to_network.is_empty()
}
}
impl Connection for TcpConnection {
fn id(&self) -> &ConnectionId {
&self.id
}
fn send_to_network(
&mut self,
selector: &mut Selector,
client_channel: &mut ClientChannel,
ipv4_packet: &Ipv4Packet,
) {
self.handle_packet(selector, client_channel, ipv4_packet);
if !self.closed {
self.update_interests(selector);
}
}
fn close(&mut self, selector: &mut Selector) {
cx_info!(target: TAG, self.id, "Close");
self.closed = true;
if let Err(err) = selector.deregister(&self.stream, self.token) {
// do not panic, this can happen in mio
// see
cx_warn!(
target: TAG,
self.id,
"Fail to deregister TCP stream: {:?}",
err
);
}
// socket will be closed by RAII
}
fn is_expired(&self) -> bool {
// no external timeout expiration
false
}
fn is_closed(&self) -> bool {
self.closed
}
}
impl PacketSource for TcpConnection {
fn get(&mut self) -> Option {
if let Some(len) = self.packet_for_client_length {
Some(self.network_to_client.inflate(len))
} else {
None
}
}
fn next(&mut self, selector: &mut Selector) {
let len = self
.packet_for_client_length
.expect("next() called on empty packet source");
cx_debug!(
target: TAG,
self.id,
"Deferred packet ({} bytes) sent to client {}",
len,
self.tcb.numbers()
);
self.tcb.sequence_number += Wrapping(u32::from(len));
self.packet_for_client_length = None;
self.update_interests(selector);
}
}
================================================
FILE: relay-rust/src/relay/tcp_header.rs
================================================
/*
* Copyright (C) 2017 Genymobile
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use super::ipv4_header::Ipv4HeaderData;
use byteorder::{BigEndian, ByteOrder};
use std::mem;
pub struct TcpHeader<'a> {
raw: &'a [u8],
data: &'a TcpHeaderData,
}
pub struct TcpHeaderMut<'a> {
raw: &'a mut [u8],
data: &'a mut TcpHeaderData,
}
#[derive(Clone)]
pub struct TcpHeaderData {
source_port: u16,
destination_port: u16,
sequence_number: u32,
acknowledgement_number: u32,
header_length: u8,
flags: u16,
window: u16,
}
pub const FLAG_FIN: u16 = 1;
pub const FLAG_SYN: u16 = 1 << 1;
pub const FLAG_RST: u16 = 1 << 2;
pub const FLAG_PSH: u16 = 1 << 3;
pub const FLAG_ACK: u16 = 1 << 4;
#[allow(dead_code)]
impl TcpHeaderData {
pub fn parse(raw: &[u8]) -> Self {
let data_offset_and_flags = BigEndian::read_u16(&raw[12..14]);
Self {
source_port: BigEndian::read_u16(&raw[0..2]),
destination_port: BigEndian::read_u16(&raw[2..4]),
sequence_number: BigEndian::read_u32(&raw[4..8]),
acknowledgement_number: BigEndian::read_u32(&raw[8..12]),
header_length: ((data_offset_and_flags & 0xF000) >> 10) as u8,
flags: data_offset_and_flags & 0x1FF,
window: BigEndian::read_u16(&raw[14..16]),
}
}
#[inline]
pub fn bind<'c, 'a: 'c, 'b: 'c>(&'a self, raw: &'b [u8]) -> TcpHeader<'c> {
TcpHeader::new(raw, self)
}
#[inline]
pub fn bind_mut<'c, 'a: 'c, 'b: 'c>(&'a mut self, raw: &'b mut [u8]) -> TcpHeaderMut<'c> {
TcpHeaderMut::new(raw, self)
}
#[inline]
pub fn header_length(&self) -> u8 {
self.header_length
}
#[inline]
pub fn source_port(&self) -> u16 {
self.source_port
}
#[inline]
pub fn destination_port(&self) -> u16 {
self.destination_port
}
#[inline]
pub fn sequence_number(&self) -> u32 {
self.sequence_number
}
#[inline]
pub fn acknowledgement_number(&self) -> u32 {
self.acknowledgement_number
}
#[inline]
pub fn window(&self) -> u16 {
self.window
}
#[inline]
pub fn flags(&self) -> u16 {
self.flags
}
#[inline]
pub fn is_fin(&self) -> bool {
self.flags & FLAG_FIN != 0
}
#[inline]
pub fn is_syn(&self) -> bool {
self.flags & FLAG_SYN != 0
}
#[inline]
pub fn is_rst(&self) -> bool {
self.flags & FLAG_RST != 0
}
#[inline]
pub fn is_psh(&self) -> bool {
self.flags & FLAG_PSH != 0
}
#[inline]
pub fn is_ack(&self) -> bool {
self.flags & FLAG_ACK != 0
}
}
// shared definition for UdpHeader and UdpHeaderMut
macro_rules! tcp_header_common {
($name:ident, $raw_type:ty, $data_type:ty) => {
// for readability, declare structs manually outside the macro
#[allow(dead_code)]
impl<'a> $name<'a> {
pub fn new(raw: $raw_type, data: $data_type) -> Self {
Self {
raw: raw,
data: data,
}
}
#[inline]
pub fn raw(&self) -> &[u8] {
self.raw
}
#[inline]
pub fn data(&self) -> &TcpHeaderData {
self.data
}
#[inline]
pub fn header_length(&self) -> u8 {
self.data.header_length
}
#[inline]
pub fn source_port(&self) -> u16 {
self.data.source_port
}
#[inline]
pub fn destination_port(&self) -> u16 {
self.data.destination_port
}
#[inline]
pub fn sequence_number(&self) -> u32 {
self.data.sequence_number
}
#[inline]
pub fn acknowledgement_number(&self) -> u32 {
self.data.acknowledgement_number
}
#[inline]
pub fn window(&self) -> u16 {
self.data.window
}
#[inline]
pub fn flags(&self) -> u16 {
self.data.flags
}
#[inline]
pub fn is_fin(&self) -> bool {
self.data.is_fin()
}
#[inline]
pub fn is_syn(&self) -> bool {
self.data.is_syn()
}
#[inline]
pub fn is_rst(&self) -> bool {
self.data.is_rst()
}
#[inline]
pub fn is_psh(&self) -> bool {
self.data.is_psh()
}
#[inline]
pub fn is_ack(&self) -> bool {
self.data.is_ack()
}
}
};
}
tcp_header_common!(TcpHeader, &'a [u8], &'a TcpHeaderData);
tcp_header_common!(TcpHeaderMut, &'a mut [u8], &'a mut TcpHeaderData);
// additional methods for the mutable version
#[allow(dead_code)]
impl<'a> TcpHeaderMut<'a> {
#[inline]
pub fn raw_mut(&mut self) -> &mut [u8] {
self.raw
}
#[inline]
pub fn data_mut(&mut self) -> &mut TcpHeaderData {
self.data
}
#[inline]
pub fn set_source_port(&mut self, source_port: u16) {
self.data.source_port = source_port;
BigEndian::write_u16(&mut self.raw[0..2], source_port);
}
#[inline]
pub fn set_destination_port(&mut self, destination_port: u16) {
self.data.destination_port = destination_port;
BigEndian::write_u16(&mut self.raw[2..4], destination_port);
}
pub fn swap_source_and_destination(&mut self) {
mem::swap(&mut self.data.source_port, &mut self.data.destination_port);
for i in 0..2 {
self.raw.swap(i, i + 2);
}
}
#[inline]
pub fn set_sequence_number(&mut self, sequence_number: u32) {
self.data.sequence_number = sequence_number;
BigEndian::write_u32(&mut self.raw[4..8], sequence_number);
}
#[inline]
pub fn set_acknowledgement_number(&mut self, acknowledgement_number: u32) {
self.data.acknowledgement_number = acknowledgement_number;
BigEndian::write_u32(&mut self.raw[8..12], acknowledgement_number);
}
#[inline]
pub fn set_flags(&mut self, flags: u16) {
self.data.flags = flags;
let mut data_offset_and_flags = BigEndian::read_u16(&self.raw[12..14]);
data_offset_and_flags = data_offset_and_flags & 0xFE00 | flags & 0x1FF;
BigEndian::write_u16(&mut self.raw[12..14], data_offset_and_flags);
}
#[inline]
pub fn shrink_options(&mut self) {
self.set_data_offset(5);
}
#[inline]
fn set_data_offset(&mut self, data_offset: u8) {
let mut data_offset_and_flags = BigEndian::read_u16(&self.raw[12..14]);
data_offset_and_flags = data_offset_and_flags & 0x0FFF | (u16::from(data_offset) << 12);
BigEndian::write_u16(&mut self.raw[12..14], data_offset_and_flags);
self.data.header_length = data_offset << 2;
}
#[inline]
fn checksum(&self) -> u16 {
BigEndian::read_u16(&self.raw[16..18])
}
#[inline]
fn set_checksum(&mut self, checksum: u16) {
BigEndian::write_u16(&mut self.raw[16..18], checksum);
}
pub fn update_checksum(&mut self, ipv4_header_data: &Ipv4HeaderData, payload: &[u8]) {
// pseudo-header checksum (cf rfc793 section 3.1)
let source = ipv4_header_data.source();
let destination = ipv4_header_data.destination();
let transport_length =
ipv4_header_data.total_length() - u16::from(ipv4_header_data.header_length());
let header_length = self.header_length();
debug_assert!(header_length % 2 == 0 && header_length >= 20);
let payload_length = transport_length - u16::from(header_length);
debug_assert_eq!(
payload_length as usize,
payload.len(),
"Payload length does not match"
);
let mut sum = 6u32; // protocol: TCP = 6
sum += source >> 16;
sum += source & 0xFFFF;
sum += destination >> 16;
sum += destination & 0xFFFF;
sum += u32::from(transport_length);
// reset checksum field, so that it can be added with other bytes
self.set_checksum(0);
// checksum computation is the most CPU-intensive task in gnirehtet
// prefer optimization over readability/safety
let mut hsum = 0; // high-order bytes sum
unsafe {
let mut p = self.raw.as_ptr();
let end = p.offset(header_length as isize);
while p < end {
hsum += u32::from(*p);
sum += u32::from(*p.offset(1));
p = p.offset(2);
}
let mut p = payload.as_ptr();
// -1 to ignore the last if payload_length is odd
let end = p.offset(payload_length as isize - 1);
while p < end {
hsum += u32::from(*p);
sum += u32::from(*p.offset(1));
p = p.offset(2);
}
if payload_length % 2 != 0 {
// if payload length is odd, the last byte is considered high-order
hsum += u32::from(*payload.get_unchecked((payload_length - 1) as usize));
}
}
// add high-order bytes sum to the global sum
sum += hsum << 8;
while (sum & !0xFFFF) != 0 {
sum = (sum & 0xFFFF) + (sum >> 16);
}
self.set_checksum(!sum as u16);
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::relay::ipv4_packet::Ipv4Packet;
use crate::relay::transport_header::TransportHeaderMut;
use byteorder::{BigEndian, WriteBytesExt};
fn create_packet() -> Vec {
let mut raw = Vec::new();
raw.reserve(44);
raw.write_u8(4u8 << 4 | 5).unwrap(); // version_and_ihl
raw.write_u8(0).unwrap(); //ToS
raw.write_u16::(44).unwrap(); // total length
raw.write_u32::(0).unwrap(); // id_flags_fragment_offset
raw.write_u8(0).unwrap(); // TTL
raw.write_u8(6).unwrap(); // protocol (TCP)
raw.write_u16::(0).unwrap(); // checksum
raw.write_u32::(0x12345678).unwrap(); // source address
raw.write_u32::(0xA2A24242).unwrap(); // destination address
raw.write_u16::(0x1234).unwrap(); // source port
raw.write_u16::(0x5678).unwrap(); // destination port
raw.write_u32::(0x111).unwrap(); // sequence number
raw.write_u32::(0x222).unwrap(); // acknowledgement number
raw.write_u16::(5 << 12).unwrap(); // data offset + flags(0)
raw.write_u16::(0).unwrap(); // window (don't care for these tests)
raw.write_u16::(0).unwrap(); // checksum
raw.write_u16::(0).unwrap(); // urgent pointer
raw.write_u32::(0x1122EEFF).unwrap(); // payload
raw
}
fn create_odd_packet() -> Vec {
let mut raw = Vec::new();
raw.reserve(45);
raw.write_u8(4u8 << 4 | 5).unwrap(); // version_and_ihl
raw.write_u8(0).unwrap(); //ToS
raw.write_u16::(45).unwrap(); // total length
raw.write_u32::(0).unwrap(); // id_flags_fragment_offset
raw.write_u8(0).unwrap(); // TTL
raw.write_u8(6).unwrap(); // protocol (TCP)
raw.write_u16::(0).unwrap(); // checksum
raw.write_u32::(0x12345678).unwrap(); // source address
raw.write_u32::(0xA2A24242).unwrap(); // destination address
raw.write_u16::(0x1234).unwrap(); // source port
raw.write_u16::(0x5678).unwrap(); // destination port
raw.write_u32::(0x111).unwrap(); // sequence number
raw.write_u32::(0x222).unwrap(); // acknowledgement number
raw.write_u16::(5 << 12).unwrap(); // data offset + flags(0)
raw.write_u16::(0).unwrap(); // window (don't care for these tests)
raw.write_u16::(0).unwrap(); // checksum
raw.write_u16::(0).unwrap(); // urgent pointer
// payload
raw.write_u32::(0x1122EEFF).unwrap();
raw.write_u8(0x88).unwrap();
raw
}
fn create_empty_packet() -> Vec {
let mut raw = Vec::new();
raw.reserve(40);
raw.write_u8(4u8 << 4 | 5).unwrap(); // version_and_ihl
raw.write_u8(0).unwrap(); //ToS
raw.write_u16::(40).unwrap(); // total length
raw.write_u32::(0).unwrap(); // id_flags_fragment_offset
raw.write_u8(0).unwrap(); // TTL
raw.write_u8(6).unwrap(); // protocol (TCP)
raw.write_u16::(0).unwrap(); // checksum
raw.write_u32::(0x12345678).unwrap(); // source address
raw.write_u32::(0xA2A24242).unwrap(); // destination address
raw.write_u16::(0x1234).unwrap(); // source port
raw.write_u16::(0x5678).unwrap(); // destination port
raw.write_u32::(0x111).unwrap(); // sequence number
raw.write_u32::(0x222).unwrap(); // acknowledgement number
raw.write_u16::(5 << 12).unwrap(); // data offset + flags(0)
raw.write_u16::(0).unwrap(); // window (don't care for these tests)
raw.write_u16::(0).unwrap(); // checksum
raw.write_u16::(0).unwrap(); // urgent pointer
raw
}
fn create_tcp_header() -> Vec {
let mut raw = Vec::new();
raw.reserve(20);
raw.write_u16::(0x1234).unwrap(); // source port
raw.write_u16::(0x5678).unwrap(); // destination port
raw.write_u32::(0x111).unwrap(); // sequence number
raw.write_u32::(0x222).unwrap(); // acknowledgement number
raw.write_u16::(5 << 12).unwrap(); // data offset + flags(0)
raw.write_u16::(0).unwrap(); // window (don't care for these tests)
raw.write_u16::(0).unwrap(); // checksum
raw.write_u16::(0).unwrap(); // urgent pointer
raw
}
#[test]
fn edit_header() {
let raw = &mut create_tcp_header()[..];
let mut header_data = TcpHeaderData::parse(raw);
let mut header = header_data.bind_mut(raw);
header.set_source_port(1111);
header.set_destination_port(2222);
header.set_sequence_number(300);
header.set_acknowledgement_number(101);
header.set_flags(FLAG_FIN | FLAG_ACK);
assert_eq!(1111, header.source_port());
assert_eq!(2222, header.destination_port());
assert_eq!(300, header.sequence_number());
assert_eq!(101, header.acknowledgement_number());
assert_eq!(FLAG_FIN | FLAG_ACK, header.flags());
{
let raw = header.raw();
// assert that the buffer has been modified
let raw_source_port = BigEndian::read_u16(&raw[0..2]);
let raw_destination_port = BigEndian::read_u16(&raw[2..4]);
let raw_sequence_number = BigEndian::read_u32(&raw[4..8]);
let raw_acknowledgement_number = BigEndian::read_u32(&raw[8..12]);
let raw_data_offset_and_flags = BigEndian::read_u16(&raw[12..14]);
assert_eq!(1111, raw_source_port);
assert_eq!(2222, raw_destination_port);
assert_eq!(300, raw_sequence_number);
assert_eq!(101, raw_acknowledgement_number);
assert_eq!(0x5011, raw_data_offset_and_flags);
}
header.swap_source_and_destination();
assert_eq!(2222, header.source_port());
assert_eq!(1111, header.destination_port());
let raw = header.raw();
let raw_source_port = BigEndian::read_u16(&raw[0..2]);
let raw_destination_port = BigEndian::read_u16(&raw[2..4]);
assert_eq!(2222, raw_source_port);
assert_eq!(1111, raw_destination_port);
}
#[test]
fn compute_checksum() {
let raw = &mut create_packet()[..];
let mut ipv4_packet = Ipv4Packet::parse(raw);
let (ipv4_header, mut transport) = ipv4_packet.split_mut();
if let Some((TransportHeaderMut::Tcp(ref mut tcp_header), ref payload)) = transport {
// set a fake checksum value to assert that it is correctly computed
tcp_header.set_checksum(0x79);
tcp_header.update_checksum(ipv4_header.data(), payload);
let checksum = tcp_header.checksum();
let expected_checksum = {
// pseudo-header
let mut sum: u32 = 0x1234 + 0x5678 + 0xA2A2 + 0x4242 + 0x0006 + 0x0018;
// header
sum += 0x1234
+ 0x5678
+ 0x0000
+ 0x0111
+ 0x0000
+ 0x0222
+ 0x5000
+ 0x0000
+ 0x0000
+ 0x0000;
// payload
sum += 0x1122 + 0xEEFF;
while (sum & !0xFFFF) != 0 {
sum = (sum & 0xFFFF) + (sum >> 16);
}
!sum as u16
};
assert_eq!(expected_checksum, checksum);
} else {
panic!("Not a TCP packet");
}
}
#[test]
fn compute_checksum_odd() {
let raw = &mut create_odd_packet()[..];
let mut ipv4_packet = Ipv4Packet::parse(raw);
let (ipv4_header, mut transport) = ipv4_packet.split_mut();
if let Some((TransportHeaderMut::Tcp(ref mut tcp_header), ref payload)) = transport {
// set a fake checksum value to assert that it is correctly computed
tcp_header.set_checksum(0x79);
tcp_header.update_checksum(ipv4_header.data(), payload);
let checksum = tcp_header.checksum();
let expected_checksum = {
// pseudo-header
let mut sum: u32 = 0x1234 + 0x5678 + 0xA2A2 + 0x4242 + 0x0006 + 0x0019;
// header
sum += 0x1234
+ 0x5678
+ 0x0000
+ 0x0111
+ 0x0000
+ 0x0222
+ 0x5000
+ 0x0000
+ 0x0000
+ 0x0000;
// payload
sum += 0x1122 + 0xEEFF + 0x8800;
while (sum & !0xFFFF) != 0 {
sum = (sum & 0xFFFF) + (sum >> 16);
}
!sum as u16
};
assert_eq!(expected_checksum, checksum);
} else {
panic!("Not a TCP packet");
}
}
#[test]
fn compute_checksum_empty_payload() {
let raw = &mut create_empty_packet()[..];
let mut ipv4_packet = Ipv4Packet::parse(raw);
let (ipv4_header, mut transport) = ipv4_packet.split_mut();
if let Some((TransportHeaderMut::Tcp(ref mut tcp_header), ref payload)) = transport {
// set a fake checksum value to assert that it is correctly computed
tcp_header.set_checksum(0x79);
tcp_header.update_checksum(ipv4_header.data(), payload);
let checksum = tcp_header.checksum();
let expected_checksum = {
// pseudo-header
let mut sum: u32 = 0x1234 + 0x5678 + 0xA2A2 + 0x4242 + 0x0006 + 0x0014;
// header
sum += 0x1234
+ 0x5678
+ 0x0000
+ 0x0111
+ 0x0000
+ 0x0222
+ 0x5000
+ 0x0000
+ 0x0000
+ 0x0000;
while (sum & !0xFFFF) != 0 {
sum = (sum & 0xFFFF) + (sum >> 16);
}
!sum as u16
};
assert_eq!(expected_checksum, checksum);
} else {
panic!("Not a TCP packet");
}
}
fn create_long_packet() -> Vec {
let mut raw = Vec::new();
raw.reserve(45);
raw.write_u8(4u8 << 4 | 5).unwrap(); // version_and_ihl
raw.write_u8(0).unwrap(); //ToS
raw.write_u16::(1240).unwrap(); // total length
raw.write_u32::(0).unwrap(); // id_flags_fragment_offset
raw.write_u8(0).unwrap(); // TTL
raw.write_u8(6).unwrap(); // protocol (TCP)
raw.write_u16::(0).unwrap(); // checksum
raw.write_u32::(0x12345678).unwrap(); // source address
raw.write_u32::(0xA2A24242).unwrap(); // destination address
raw.write_u16::