├── XamarinAndroidVPNExample
    ├── Resources
    │   ├── values
    │   │   ├── dimens.xml
    │   │   ├── ic_launcher_background.xml
    │   │   ├── Strings.xml
    │   │   ├── colors.xml
    │   │   └── styles.xml
    │   ├── mipmap-hdpi
    │   │   ├── ic_launcher.png
    │   │   ├── ic_launcher_round.png
    │   │   └── ic_launcher_foreground.png
    │   ├── mipmap-mdpi
    │   │   ├── ic_launcher.png
    │   │   ├── ic_launcher_round.png
    │   │   └── ic_launcher_foreground.png
    │   ├── mipmap-xhdpi
    │   │   ├── ic_launcher.png
    │   │   ├── ic_launcher_round.png
    │   │   └── ic_launcher_foreground.png
    │   ├── mipmap-xxhdpi
    │   │   ├── ic_launcher.png
    │   │   ├── ic_launcher_round.png
    │   │   └── ic_launcher_foreground.png
    │   ├── mipmap-xxxhdpi
    │   │   ├── ic_launcher.png
    │   │   ├── ic_launcher_round.png
    │   │   └── ic_launcher_foreground.png
    │   ├── mipmap-anydpi-v26
    │   │   ├── ic_launcher.xml
    │   │   └── ic_launcher_round.xml
    │   ├── layout
    │   │   └── activity_main.axml
    │   └── AboutResources.txt
    ├── Assets
    │   └── AboutAssets.txt
    ├── Properties
    │   ├── AndroidManifest.xml
    │   └── AssemblyInfo.cs
    ├── VPNService
    │   ├── LRUCache.cs
    │   ├── ByteBufferPool.cs
    │   ├── UDPInput.cs
    │   ├── TCB.cs
    │   ├── UDPOutput.cs
    │   ├── TCPInput.cs
    │   ├── LocalVPNService.cs
    │   ├── TCPOutput.cs
    │   └── Packet.cs
    ├── packages.config
    ├── MainActivity.cs
    └── XamarinAndroidVPNExample.csproj
├── XamarinAndroidVPNExample.sln
├── .gitattributes
└── .gitignore


/XamarinAndroidVPNExample/Resources/values/dimens.xml:
--------------------------------------------------------------------------------
1 | <resources>
2 |     <dimen name="fab_margin">16dp</dimen>
3 | </resources>
4 | 


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/Resources/mipmap-hdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/manicoder/XamarinAndroidVPNExample/HEAD/XamarinAndroidVPNExample/Resources/mipmap-hdpi/ic_launcher.png


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/Resources/mipmap-mdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/manicoder/XamarinAndroidVPNExample/HEAD/XamarinAndroidVPNExample/Resources/mipmap-mdpi/ic_launcher.png


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/Resources/mipmap-xhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/manicoder/XamarinAndroidVPNExample/HEAD/XamarinAndroidVPNExample/Resources/mipmap-xhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/Resources/mipmap-xxhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/manicoder/XamarinAndroidVPNExample/HEAD/XamarinAndroidVPNExample/Resources/mipmap-xxhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/Resources/mipmap-xxxhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/manicoder/XamarinAndroidVPNExample/HEAD/XamarinAndroidVPNExample/Resources/mipmap-xxxhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/Resources/values/ic_launcher_background.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <resources>
3 |     <color name="ic_launcher_background">#2C3E50</color>
4 | </resources>


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/Resources/mipmap-hdpi/ic_launcher_round.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/manicoder/XamarinAndroidVPNExample/HEAD/XamarinAndroidVPNExample/Resources/mipmap-hdpi/ic_launcher_round.png


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/Resources/mipmap-mdpi/ic_launcher_round.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/manicoder/XamarinAndroidVPNExample/HEAD/XamarinAndroidVPNExample/Resources/mipmap-mdpi/ic_launcher_round.png


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/Resources/mipmap-xhdpi/ic_launcher_round.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/manicoder/XamarinAndroidVPNExample/HEAD/XamarinAndroidVPNExample/Resources/mipmap-xhdpi/ic_launcher_round.png


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/Resources/mipmap-xxhdpi/ic_launcher_round.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/manicoder/XamarinAndroidVPNExample/HEAD/XamarinAndroidVPNExample/Resources/mipmap-xxhdpi/ic_launcher_round.png


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/Resources/mipmap-xxxhdpi/ic_launcher_round.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/manicoder/XamarinAndroidVPNExample/HEAD/XamarinAndroidVPNExample/Resources/mipmap-xxxhdpi/ic_launcher_round.png


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/Resources/values/Strings.xml:
--------------------------------------------------------------------------------
1 | <resources>
2 |     <string name="app_name">XamarinAndroidVPNExample</string>
3 |     <string name="action_settings">Settings</string>
4 | </resources>
5 | 


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/Resources/mipmap-hdpi/ic_launcher_foreground.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/manicoder/XamarinAndroidVPNExample/HEAD/XamarinAndroidVPNExample/Resources/mipmap-hdpi/ic_launcher_foreground.png


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/Resources/mipmap-mdpi/ic_launcher_foreground.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/manicoder/XamarinAndroidVPNExample/HEAD/XamarinAndroidVPNExample/Resources/mipmap-mdpi/ic_launcher_foreground.png


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/Resources/mipmap-xhdpi/ic_launcher_foreground.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/manicoder/XamarinAndroidVPNExample/HEAD/XamarinAndroidVPNExample/Resources/mipmap-xhdpi/ic_launcher_foreground.png


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/Resources/mipmap-xxhdpi/ic_launcher_foreground.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/manicoder/XamarinAndroidVPNExample/HEAD/XamarinAndroidVPNExample/Resources/mipmap-xxhdpi/ic_launcher_foreground.png


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/Resources/mipmap-xxxhdpi/ic_launcher_foreground.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/manicoder/XamarinAndroidVPNExample/HEAD/XamarinAndroidVPNExample/Resources/mipmap-xxxhdpi/ic_launcher_foreground.png


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/Resources/values/colors.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <resources>
3 |     <color name="colorPrimary">#2c3e50</color>
4 |     <color name="colorPrimaryDark">#1B3147</color>
5 |     <color name="colorAccent">#3498db</color>
6 | </resources>
7 | 


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/Resources/mipmap-anydpi-v26/ic_launcher.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
3 |     <background android:drawable="@color/ic_launcher_background"/>
4 |     <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
5 | </adaptive-icon>


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/Resources/mipmap-anydpi-v26/ic_launcher_round.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
3 |     <background android:drawable="@color/ic_launcher_background"/>
4 |     <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
5 | </adaptive-icon>


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/Resources/layout/activity_main.axml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3 |                 xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent"
 4 |                 android:layout_height="match_parent">
 5 | 
 6 | 
 7 | 
 8 | 
 9 | 
10 | 	<Button android:id="@+id/btStart" android:layout_width="fill_parent"
11 |         android:layout_height="wrap_content"
12 |    android:text="Start VPN"/>
13 | 
14 | 
15 | 
16 | 
17 | 
18 | 
19 | </RelativeLayout>
20 | 


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/Assets/AboutAssets.txt:
--------------------------------------------------------------------------------
 1 | Any raw assets you want to be deployed with your application can be placed in
 2 | this directory (and child directories) and given a Build Action of "AndroidAsset".
 3 | 
 4 | These files will be deployed with you package and will be accessible using Android's
 5 | AssetManager, like this:
 6 | 
 7 | public class ReadAsset : Activity
 8 | {
 9 |     protected override void OnCreate (Bundle bundle)
10 |     {
11 |         base.OnCreate (bundle);
12 | 
13 |         InputStream input = Assets.Open ("my_asset.txt");
14 |     }
15 | }
16 | 
17 | Additionally, some Android functions will automatically load asset files:
18 | 
19 | Typeface tf = Typeface.CreateFromAsset (Context.Assets, "fonts/samplefont.ttf");


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/Properties/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <manifest xmlns:android="http://schemas.android.com/apk/res/android" android:versionCode="1" android:versionName="1.0" package="XamarinAndroidVPNExample.XamarinAndroidVPNExample">
3 | 	<uses-sdk android:minSdkVersion="16" android:targetSdkVersion="21" />
4 | 	<application android:allowBackup="true" android:icon="@mipmap/ic_launcher" android:label="@string/app_name" android:supportsRtl="true" android:theme="@style/AppTheme"></application>
5 | 	<uses-permission android:name="android.permission.INTERNET" />
6 |   <uses-permission android:name="android.permission.ACCESS_LOCATION_EXTRA_COMMANDS" />
7 |   <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
8 | </manifest>


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/VPNService/LRUCache.cs:
--------------------------------------------------------------------------------
 1 | using Java.Util;
 2 | 
 3 | namespace XamarinAndroidVPNExample.VPNService
 4 | {
 5 |     public abstract class LRUCache<K, V> : LinkedHashMap
 6 |     {
 7 |         private int maxSize;
 8 | 
 9 |         public LRUCache(int maxSize)
10 |             : base(maxSize + 1, 1, true)
11 |         {
12 |             this.maxSize = maxSize;
13 |         }
14 | 
15 |         protected override bool RemoveEldestEntry(IMapEntry eldest)
16 |         {
17 |             if (this.Size() > maxSize)
18 |             {
19 |                 Cleanup(eldest);
20 |                 return true;
21 |             }
22 | 
23 |             return false;
24 |         }
25 | 
26 |         public virtual void Cleanup(IMapEntry eldest)
27 |         {
28 |         }
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/Resources/values/styles.xml:
--------------------------------------------------------------------------------
 1 | <resources>
 2 | 
 3 |     <!-- Base application theme. -->
 4 |     <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
 5 |         <!-- Customize your theme here. -->
 6 |         <item name="colorPrimary">@color/colorPrimary</item>
 7 |         <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
 8 |         <item name="colorAccent">@color/colorAccent</item>
 9 |     </style>
10 | 
11 |     <style name="AppTheme.NoActionBar">
12 |         <item name="windowActionBar">false</item>
13 |         <item name="windowNoTitle">true</item>
14 |     </style>
15 | 
16 |     <style name="AppTheme.AppBarOverlay" parent="ThemeOverlay.AppCompat.Dark.ActionBar" />
17 | 
18 |     <style name="AppTheme.PopupOverlay" parent="ThemeOverlay.AppCompat.Light" />
19 | 
20 | </resources>
21 | 


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/VPNService/ByteBufferPool.cs:
--------------------------------------------------------------------------------
 1 | using Java.Nio;
 2 | using Java.Util.Concurrent;
 3 | 
 4 | namespace XamarinAndroidVPNExample.VPNService
 5 | {
 6 |     public class ByteBufferPool: Java.Lang.Object
 7 |     {
 8 |         private const int BUFFER_SIZE = 16384; // XXX: Is this ideal?
 9 |         private static ConcurrentLinkedQueue pool = new ConcurrentLinkedQueue();
10 | 
11 |         public static ByteBuffer acquire()
12 |         {
13 |             var buffer = (ByteBuffer)pool.Poll();
14 |             if (buffer == null)
15 |                 buffer = ByteBuffer.AllocateDirect(BUFFER_SIZE); // Using DirectBuffer for zero-copy
16 |             return buffer;
17 |         }
18 | 
19 |         public static void Release(ByteBuffer buffer)
20 |         {
21 |             buffer.Clear();
22 |             pool.Offer(buffer);
23 |         }
24 | 
25 |         public static void Clear()
26 |         {
27 |             pool.Clear();
28 |         }
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Runtime.CompilerServices;
 3 | using System.Runtime.InteropServices;
 4 | using Android.App;
 5 | 
 6 | // General Information about an assembly is controlled through the following 
 7 | // set of attributes. Change these attribute values to modify the information
 8 | // associated with an assembly.
 9 | [assembly: AssemblyTitle("XamarinAndroidVPNExample")]
10 | [assembly: AssemblyDescription("")]
11 | [assembly: AssemblyConfiguration("")]
12 | [assembly: AssemblyCompany("")]
13 | [assembly: AssemblyProduct("XamarinAndroidVPNExample")]
14 | [assembly: AssemblyCopyright("Copyright ©  2018")]
15 | [assembly: AssemblyTrademark("")]
16 | [assembly: AssemblyCulture("")]
17 | [assembly: ComVisible(false)]
18 | 
19 | // Version information for an assembly consists of the following four values:
20 | //
21 | //      Major Version
22 | //      Minor Version 
23 | //      Build Number
24 | //      Revision
25 | //
26 | // You can specify all the values or you can default the Build and Revision Numbers 
27 | // by using the '*' as shown below:
28 | // [assembly: AssemblyVersion("1.0.*")]
29 | [assembly: AssemblyVersion("1.0.0.0")]
30 | [assembly: AssemblyFileVersion("1.0.0.0")]
31 | 


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio 15
 4 | VisualStudioVersion = 15.0.28307.438
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "XamarinAndroidVPNExample", "XamarinAndroidVPNExample\XamarinAndroidVPNExample.csproj", "{3BC0AC7E-3B3B-4D3F-9CC0-B2BDECC460A6}"
 7 | EndProject
 8 | Global
 9 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
10 | 		Debug|Any CPU = Debug|Any CPU
11 | 		Release|Any CPU = Release|Any CPU
12 | 	EndGlobalSection
13 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
14 | 		{3BC0AC7E-3B3B-4D3F-9CC0-B2BDECC460A6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
15 | 		{3BC0AC7E-3B3B-4D3F-9CC0-B2BDECC460A6}.Debug|Any CPU.Build.0 = Debug|Any CPU
16 | 		{3BC0AC7E-3B3B-4D3F-9CC0-B2BDECC460A6}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
17 | 		{3BC0AC7E-3B3B-4D3F-9CC0-B2BDECC460A6}.Release|Any CPU.ActiveCfg = Release|Any CPU
18 | 		{3BC0AC7E-3B3B-4D3F-9CC0-B2BDECC460A6}.Release|Any CPU.Build.0 = Release|Any CPU
19 | 		{3BC0AC7E-3B3B-4D3F-9CC0-B2BDECC460A6}.Release|Any CPU.Deploy.0 = Release|Any CPU
20 | 	EndGlobalSection
21 | 	GlobalSection(SolutionProperties) = preSolution
22 | 		HideSolutionNode = FALSE
23 | 	EndGlobalSection
24 | 	GlobalSection(ExtensibilityGlobals) = postSolution
25 | 		SolutionGuid = {22A2A42F-428B-424F-9885-87E76F6C0996}
26 | 	EndGlobalSection
27 | EndGlobal
28 | 


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/packages.config:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <packages>
 3 |   <package id="Xamarin.Android.Arch.Core.Common" version="1.1.1.1" targetFramework="monoandroid80" />
 4 |   <package id="Xamarin.Android.Arch.Lifecycle.Common" version="1.1.1.1" targetFramework="monoandroid80" />
 5 |   <package id="Xamarin.Android.Arch.Lifecycle.Runtime" version="1.1.1.1" targetFramework="monoandroid80" />
 6 |   <package id="Xamarin.Android.Support.Animated.Vector.Drawable" version="28.0.0.1" targetFramework="monoandroid80" />
 7 |   <package id="Xamarin.Android.Support.Annotations" version="28.0.0.1" targetFramework="monoandroid80" />
 8 |   <package id="Xamarin.Android.Support.Compat" version="28.0.0.1" targetFramework="monoandroid80" />
 9 |   <package id="Xamarin.Android.Support.Core.UI" version="28.0.0.1" targetFramework="monoandroid80" />
10 |   <package id="Xamarin.Android.Support.Core.Utils" version="28.0.0.1" targetFramework="monoandroid80" />
11 |   <package id="Xamarin.Android.Support.Design" version="28.0.0.1" targetFramework="monoandroid80" />
12 |   <package id="Xamarin.Android.Support.Fragment" version="28.0.0.1" targetFramework="monoandroid80" />
13 |   <package id="Xamarin.Android.Support.Media.Compat" version="28.0.0.1" targetFramework="monoandroid80" />
14 |   <package id="Xamarin.Android.Support.Transition" version="28.0.0.1" targetFramework="monoandroid80" />
15 |   <package id="Xamarin.Android.Support.v7.AppCompat" version="28.0.0.1" targetFramework="monoandroid80" />
16 |   <package id="Xamarin.Android.Support.v7.RecyclerView" version="28.0.0.1" targetFramework="monoandroid80" />
17 |   <package id="Xamarin.Android.Support.Vector.Drawable" version="28.0.0.1" targetFramework="monoandroid80" />
18 | </packages>


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/Resources/AboutResources.txt:
--------------------------------------------------------------------------------
 1 | Images, layout descriptions, binary blobs and string dictionaries can be included 
 2 | in your application as resource files.  Various Android APIs are designed to 
 3 | operate on the resource IDs instead of dealing with images, strings or binary blobs 
 4 | directly.
 5 | 
 6 | For example, a sample Android app that contains a user interface layout (main.axml),
 7 | an internationalization string table (strings.xml) and some icons (drawable-XXX/icon.png) 
 8 | would keep its resources in the "Resources" directory of the application:
 9 | 
10 | Resources/
11 |     drawable/
12 |         icon.png
13 | 
14 |     layout/
15 |         main.axml
16 | 
17 |     values/
18 |         strings.xml
19 | 
20 | In order to get the build system to recognize Android resources, set the build action to
21 | "AndroidResource".  The native Android APIs do not operate directly with filenames, but 
22 | instead operate on resource IDs.  When you compile an Android application that uses resources, 
23 | the build system will package the resources for distribution and generate a class called "R" 
24 | (this is an Android convention) that contains the tokens for each one of the resources 
25 | included. For example, for the above Resources layout, this is what the R class would expose:
26 | 
27 | public class R {
28 |     public class drawable {
29 |         public const int icon = 0x123;
30 |     }
31 | 
32 |     public class layout {
33 |         public const int main = 0x456;
34 |     }
35 | 
36 |     public class strings {
37 |         public const int first_string = 0xabc;
38 |         public const int second_string = 0xbcd;
39 |     }
40 | }
41 | 
42 | You would then use R.drawable.icon to reference the drawable/icon.png file, or R.layout.main 
43 | to reference the layout/main.axml file, or R.strings.first_string to reference the first 
44 | string in the dictionary file values/strings.xml.


--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
 1 | ###############################################################################
 2 | # Set default behavior to automatically normalize line endings.
 3 | ###############################################################################
 4 | * text=auto
 5 | 
 6 | ###############################################################################
 7 | # Set default behavior for command prompt diff.
 8 | #
 9 | # This is need for earlier builds of msysgit that does not have it on by
10 | # default for csharp files.
11 | # Note: This is only used by command line
12 | ###############################################################################
13 | #*.cs     diff=csharp
14 | 
15 | ###############################################################################
16 | # Set the merge driver for project and solution files
17 | #
18 | # Merging from the command prompt will add diff markers to the files if there
19 | # are conflicts (Merging from VS is not affected by the settings below, in VS
20 | # the diff markers are never inserted). Diff markers may cause the following 
21 | # file extensions to fail to load in VS. An alternative would be to treat
22 | # these files as binary and thus will always conflict and require user
23 | # intervention with every merge. To do so, just uncomment the entries below
24 | ###############################################################################
25 | #*.sln       merge=binary
26 | #*.csproj    merge=binary
27 | #*.vbproj    merge=binary
28 | #*.vcxproj   merge=binary
29 | #*.vcproj    merge=binary
30 | #*.dbproj    merge=binary
31 | #*.fsproj    merge=binary
32 | #*.lsproj    merge=binary
33 | #*.wixproj   merge=binary
34 | #*.modelproj merge=binary
35 | #*.sqlproj   merge=binary
36 | #*.wwaproj   merge=binary
37 | 
38 | ###############################################################################
39 | # behavior for image files
40 | #
41 | # image files are treated as binary by default.
42 | ###############################################################################
43 | #*.jpg   binary
44 | #*.png   binary
45 | #*.gif   binary
46 | 
47 | ###############################################################################
48 | # diff behavior for common document formats
49 | # 
50 | # Convert binary document formats to text before diffing them. This feature
51 | # is only available from the command line. Turn it on by uncommenting the 
52 | # entries below.
53 | ###############################################################################
54 | #*.doc   diff=astextplain
55 | #*.DOC   diff=astextplain
56 | #*.docx  diff=astextplain
57 | #*.DOCX  diff=astextplain
58 | #*.dot   diff=astextplain
59 | #*.DOT   diff=astextplain
60 | #*.pdf   diff=astextplain
61 | #*.PDF   diff=astextplain
62 | #*.rtf   diff=astextplain
63 | #*.RTF   diff=astextplain
64 | 


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/VPNService/UDPInput.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections;
 3 | using System.Collections.Generic;
 4 | using System.Linq;
 5 | using Android.Util;
 6 | using Java.IO;
 7 | using Java.Lang;
 8 | using Java.Nio;
 9 | using Java.Nio.Channels;
10 | using Java.Util.Concurrent;
11 | 
12 | namespace XamarinAndroidVPNExample.VPNService
13 | {
14 |     public class UDPInput : Java.Lang.Object, Java.Lang.IRunnable
15 |     {
16 |         private const string TAG = "UDPInput";
17 |         private const int HEADER_SIZE = Packet.IP4_HEADER_SIZE + Packet.UDP_HEADER_SIZE;
18 | 
19 |         private Selector selector;
20 |         private ConcurrentLinkedQueue outputQueue;
21 | 
22 |         public UDPInput(ConcurrentLinkedQueue outputQueue, Selector selector)
23 |         {
24 |             this.outputQueue = outputQueue;
25 |             this.selector = selector;
26 |         }
27 | 
28 |         public void Run()
29 |         {
30 |             try
31 |             {
32 |                 Log.Info(TAG, "Started");
33 |                 while (!Thread.Interrupted())
34 |                 {
35 |                     int readyChannels = selector.Select();
36 | 
37 |                     if (readyChannels == 0)
38 |                     {
39 |                         Thread.Sleep(10);
40 |                         continue;
41 |                     }
42 | 
43 |                     System.Console.WriteLine("UDP In");
44 | 
45 |                     var keys = selector.SelectedKeys().ToList();
46 | 
47 |                     foreach(var key in keys)
48 |                     {
49 |                         if (!Thread.Interrupted())
50 |                         {
51 |                             if (key.IsValid && key.IsReadable)
52 |                             {
53 |                                 selector.SelectedKeys().Remove(key);
54 | 
55 |                                 ByteBuffer receiveBuffer = ByteBufferPool.acquire();
56 |                                 // Leave space for the header
57 |                                 receiveBuffer.Position(HEADER_SIZE);
58 | 
59 |                                 DatagramChannel inputChannel = (DatagramChannel)key.Channel();
60 |                                 // XXX: We should handle any IOExceptions here immediately,
61 |                                 // but that probably won't happen with UDP
62 |                                 int readBytes = inputChannel.Read(receiveBuffer);
63 | 
64 |                                 Packet referencePacket = (Packet)key.Attachment();
65 |                                 referencePacket.updateUDPBuffer(receiveBuffer, readBytes);
66 |                                 receiveBuffer.Position(HEADER_SIZE + readBytes);
67 | 
68 |                                 outputQueue.Offer(receiveBuffer);
69 |                             }
70 |                         }
71 |                     }
72 |                 }
73 |             }
74 |             catch (InterruptedException e)
75 |             {
76 |                 Log.Info(TAG, "Stopping");
77 |             }
78 |             catch (IOException e)
79 |             {
80 |                 Log.Warn(TAG, e.ToString(), e);
81 |             }
82 |         }
83 |     }
84 | }
85 | 


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/VPNService/TCB.cs:
--------------------------------------------------------------------------------
  1 | using Java.IO;
  2 | using Java.Lang;
  3 | using Java.Nio.Channels;
  4 | using Java.Util;
  5 | using System.Collections.Generic;
  6 | 
  7 | namespace XamarinAndroidVPNExample.VPNService
  8 | {
  9 |     public class TCB : Object
 10 |     {
 11 |         public String ipAndPort;
 12 | 
 13 |         public long mySequenceNum, theirSequenceNum;
 14 |         public long myAcknowledgementNum, theirAcknowledgementNum;
 15 |         public TCBStatus status;
 16 | 
 17 |         // TCP has more states, but we need only these
 18 |         public enum TCBStatus
 19 |         {
 20 |             SYN_SENT,
 21 |             SYN_RECEIVED,
 22 |             ESTABLISHED,
 23 |             CLOSE_WAIT,
 24 |             LAST_ACK,
 25 |         }
 26 | 
 27 |         public Packet referencePacket;
 28 | 
 29 |         public SocketChannel channel;
 30 |         public bool waitingForNetworkData;
 31 |         public SelectionKey selectionKey;
 32 | 
 33 |         private const int MAX_CACHE_SIZE = 50; // XXX: Is this ideal?
 34 | 
 35 |         private static TCBLRUCache tcbCache = new TCBLRUCache(MAX_CACHE_SIZE);
 36 | 
 37 |         public static TCB GetTCB(String ipAndPort)
 38 |         {
 39 |             lock (tcbCache)
 40 |             {
 41 |                 return (TCB)tcbCache.Get(ipAndPort);
 42 |             }
 43 |         }
 44 | 
 45 |         public static void PutTCB(String ipAndPort, TCB tcb)
 46 |         {
 47 |             lock (tcbCache)
 48 |             {
 49 |                 tcbCache.Put(ipAndPort, tcb);
 50 |             }
 51 |         }
 52 | 
 53 |         public TCB(String ipAndPort, long mySequenceNum, long theirSequenceNum, long myAcknowledgementNum, long theirAcknowledgementNum,
 54 |                    SocketChannel channel, Packet referencePacket)
 55 |         {
 56 |             this.ipAndPort = ipAndPort;
 57 | 
 58 |             this.mySequenceNum = mySequenceNum;
 59 |             this.theirSequenceNum = theirSequenceNum;
 60 |             this.myAcknowledgementNum = myAcknowledgementNum;
 61 |             this.theirAcknowledgementNum = theirAcknowledgementNum;
 62 | 
 63 |             this.channel = channel;
 64 |             this.referencePacket = referencePacket;
 65 |         }
 66 | 
 67 |         public static void CloseTCB(TCB tcb)
 68 |         {
 69 |             tcb.CloseChannel();
 70 |             lock (tcbCache)
 71 |             {
 72 |                 tcbCache.Remove(tcb.ipAndPort);
 73 |             }
 74 |         }
 75 | 
 76 |         public static void CloseAll()
 77 |         {
 78 |             lock (tcbCache)
 79 |             {
 80 |                 var it = tcbCache.EntrySet().GetEnumerator();
 81 |                 while (it.MoveNext())
 82 |                 {
 83 |                     try
 84 |                     {
 85 |                         var tcb = (TCB)((IMapEntry)it.Current).Value;
 86 |                         tcb.CloseChannel();
 87 |                         tcbCache.Remove(tcb);
 88 |                     }
 89 |                     catch { }
 90 |                 }
 91 |             }
 92 |         }
 93 | 
 94 |         private void CloseChannel()
 95 |         {
 96 |             try
 97 |             {
 98 |                 channel.Close();
 99 |             }
100 |             catch (IOException e)
101 |             {
102 |                 // Ignore
103 |             }
104 |         }
105 | 
106 |         public class TCBLRUCache : LRUCache<string, TCB>
107 |         {
108 |             public TCBLRUCache(int maxSize) : base(maxSize)
109 |             {
110 |             }
111 | 
112 |             public override void Cleanup(IMapEntry eldest)
113 |             {
114 |                 ((TCB)eldest).CloseChannel();
115 |             }
116 |         }
117 |     }
118 | }
119 | 


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/MainActivity.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using Android.App;
  3 | using Android.Content;
  4 | using Android.Net;
  5 | using Android.OS;
  6 | using Android.Runtime;
  7 | using Android.Support.V4.Content;
  8 | using Android.Support.V7.App;
  9 | using Android.Views;
 10 | using Android.Widget;
 11 | using XamarinAndroidVPNExample.VPNService;
 12 | 
 13 | namespace XamarinAndroidVPNExample
 14 | {
 15 |     [Activity(Label = "@string/app_name", Theme = "@style/AppTheme.NoActionBar", MainLauncher = true)]
 16 |     public class MainActivity : AppCompatActivity
 17 |     {
 18 |         private const int VPN_REQUEST_CODE = 0x0F;
 19 | 
 20 |         private bool _waitingForVPNStart;
 21 | 
 22 |         VpnStateReceiver vpnStateReceiver;
 23 | 
 24 |         public class VpnStateReceiver : BroadcastReceiver
 25 |         {
 26 |             MainActivity c;
 27 | 
 28 |             public VpnStateReceiver(MainActivity c)
 29 |             {
 30 |                 this.c = c;
 31 |             }
 32 | 
 33 |             public Action<Intent> Receive { get; set; }
 34 | 
 35 |             public override void OnReceive(Context context, Intent intent)
 36 |             {
 37 |                 if (LocalVPNService.BROADCAST_VPN_STATE.Equals(intent.Action))
 38 |                 {
 39 |                     if (intent.GetBooleanExtra("running", false))
 40 |                     {
 41 |                         c._waitingForVPNStart = false;
 42 |                     }
 43 |                 }
 44 |             }
 45 |         }
 46 | 
 47 |         protected override void OnCreate(Bundle savedInstanceState)
 48 |         {
 49 |             base.OnCreate(savedInstanceState);
 50 |             SetContentView(Resource.Layout.activity_main);
 51 | 
 52 |            Button btStart = FindViewById<Button>(Resource.Id.btStart);
 53 |             btStart.Click += BtStart_Click;
 54 | 
 55 |             _waitingForVPNStart = false;
 56 | 
 57 |             vpnStateReceiver = new VpnStateReceiver(this);
 58 | 
 59 |             LocalBroadcastManager.GetInstance(this).RegisterReceiver(vpnStateReceiver,
 60 |                     new IntentFilter(LocalVPNService.BROADCAST_VPN_STATE));
 61 |         }
 62 | 
 63 |         private void BtStart_Click(object sender, EventArgs e)
 64 |         {
 65 |             StartVPN();
 66 |         }       
 67 | 
 68 |         private void StartVPN()
 69 |         {
 70 |             Intent vpnIntent = VpnService.Prepare(this);
 71 |             if (vpnIntent != null)
 72 |                 StartActivityForResult(vpnIntent, VPN_REQUEST_CODE);
 73 |             else
 74 |                 OnActivityResult(VPN_REQUEST_CODE, Result.Ok, null);
 75 |         }
 76 | 
 77 |         protected override void OnActivityResult(int requestCode, Result resultCode, Intent data)
 78 |         {
 79 |             base.OnActivityResult(requestCode, resultCode, data);
 80 | 
 81 |             if (requestCode == VPN_REQUEST_CODE && resultCode == Result.Ok)
 82 |             {
 83 |                 _waitingForVPNStart = true;
 84 |                 StartService(new Intent(this, typeof(LocalVPNService)));
 85 |                 EnableButton(false);
 86 |             }
 87 |         }
 88 | 
 89 |         protected override void OnResume()
 90 |         {
 91 |             base.OnResume();
 92 | 
 93 |             EnableButton(!_waitingForVPNStart && !LocalVPNService.IsRunning);
 94 |         }
 95 | 
 96 |         private void EnableButton(bool enable)
 97 |         {
 98 |             Button vpnButton = FindViewById<Button>(Resource.Id.btStart);
 99 |             if (enable)
100 |             {
101 |                 vpnButton.Enabled = true;
102 |                 vpnButton.Text = "Start VPN";
103 |             }
104 |             else
105 |             {
106 |                 vpnButton.Enabled = false;
107 |                 vpnButton.Text = "Stop VPN via VPN settings";
108 |             }
109 |         }
110 |     }
111 | }
112 | 
113 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | ## Ignore Visual Studio temporary files, build results, and
  2 | ## files generated by popular Visual Studio add-ons.
  3 | 
  4 | # User-specific files
  5 | *.suo
  6 | *.user
  7 | *.userosscache
  8 | *.sln.docstates
  9 | 
 10 | # User-specific files (MonoDevelop/Xamarin Studio)
 11 | *.userprefs
 12 | 
 13 | # Build results
 14 | [Dd]ebug/
 15 | [Dd]ebugPublic/
 16 | [Rr]elease/
 17 | [Rr]eleases/
 18 | x64/
 19 | x86/
 20 | bld/
 21 | [Bb]in/
 22 | [Oo]bj/
 23 | [Ll]og/
 24 | 
 25 | # Visual Studio 2015 cache/options directory
 26 | .vs/
 27 | # Uncomment if you have tasks that create the project's static files in wwwroot
 28 | #wwwroot/
 29 | 
 30 | # MSTest test Results
 31 | [Tt]est[Rr]esult*/
 32 | [Bb]uild[Ll]og.*
 33 | 
 34 | # NUNIT
 35 | *.VisualState.xml
 36 | TestResult.xml
 37 | 
 38 | # Build Results of an ATL Project
 39 | [Dd]ebugPS/
 40 | [Rr]eleasePS/
 41 | dlldata.c
 42 | 
 43 | # DNX
 44 | project.lock.json
 45 | project.fragment.lock.json
 46 | artifacts/
 47 | 
 48 | *_i.c
 49 | *_p.c
 50 | *_i.h
 51 | *.ilk
 52 | *.meta
 53 | *.obj
 54 | *.pch
 55 | *.pdb
 56 | *.pgc
 57 | *.pgd
 58 | *.rsp
 59 | *.sbr
 60 | *.tlb
 61 | *.tli
 62 | *.tlh
 63 | *.tmp
 64 | *.tmp_proj
 65 | *.log
 66 | *.vspscc
 67 | *.vssscc
 68 | .builds
 69 | *.pidb
 70 | *.svclog
 71 | *.scc
 72 | 
 73 | # Chutzpah Test files
 74 | _Chutzpah*
 75 | 
 76 | # Visual C++ cache files
 77 | ipch/
 78 | *.aps
 79 | *.ncb
 80 | *.opendb
 81 | *.opensdf
 82 | *.sdf
 83 | *.cachefile
 84 | *.VC.db
 85 | *.VC.VC.opendb
 86 | 
 87 | # Visual Studio profiler
 88 | *.psess
 89 | *.vsp
 90 | *.vspx
 91 | *.sap
 92 | 
 93 | # TFS 2012 Local Workspace
 94 | $tf/
 95 | 
 96 | # Guidance Automation Toolkit
 97 | *.gpState
 98 | 
 99 | # ReSharper is a .NET coding add-in
100 | _ReSharper*/
101 | *.[Rr]e[Ss]harper
102 | *.DotSettings.user
103 | 
104 | # JustCode is a .NET coding add-in
105 | .JustCode
106 | 
107 | # TeamCity is a build add-in
108 | _TeamCity*
109 | 
110 | # DotCover is a Code Coverage Tool
111 | *.dotCover
112 | 
113 | # NCrunch
114 | _NCrunch_*
115 | .*crunch*.local.xml
116 | nCrunchTemp_*
117 | 
118 | # MightyMoose
119 | *.mm.*
120 | AutoTest.Net/
121 | 
122 | # Web workbench (sass)
123 | .sass-cache/
124 | 
125 | # Installshield output folder
126 | [Ee]xpress/
127 | 
128 | # DocProject is a documentation generator add-in
129 | DocProject/buildhelp/
130 | DocProject/Help/*.HxT
131 | DocProject/Help/*.HxC
132 | DocProject/Help/*.hhc
133 | DocProject/Help/*.hhk
134 | DocProject/Help/*.hhp
135 | DocProject/Help/Html2
136 | DocProject/Help/html
137 | 
138 | # Click-Once directory
139 | publish/
140 | 
141 | # Publish Web Output
142 | *.[Pp]ublish.xml
143 | *.azurePubxml
144 | # TODO: Comment the next line if you want to checkin your web deploy settings
145 | # but database connection strings (with potential passwords) will be unencrypted
146 | #*.pubxml
147 | *.publishproj
148 | 
149 | # Microsoft Azure Web App publish settings. Comment the next line if you want to
150 | # checkin your Azure Web App publish settings, but sensitive information contained
151 | # in these scripts will be unencrypted
152 | PublishScripts/
153 | 
154 | # NuGet Packages
155 | *.nupkg
156 | # The packages folder can be ignored because of Package Restore
157 | **/packages/*
158 | # except build/, which is used as an MSBuild target.
159 | !**/packages/build/
160 | # Uncomment if necessary however generally it will be regenerated when needed
161 | #!**/packages/repositories.config
162 | # NuGet v3's project.json files produces more ignoreable files
163 | *.nuget.props
164 | *.nuget.targets
165 | 
166 | # Microsoft Azure Build Output
167 | csx/
168 | *.build.csdef
169 | 
170 | # Microsoft Azure Emulator
171 | ecf/
172 | rcf/
173 | 
174 | # Windows Store app package directories and files
175 | AppPackages/
176 | BundleArtifacts/
177 | Package.StoreAssociation.xml
178 | _pkginfo.txt
179 | 
180 | # Visual Studio cache files
181 | # files ending in .cache can be ignored
182 | *.[Cc]ache
183 | # but keep track of directories ending in .cache
184 | !*.[Cc]ache/
185 | 
186 | # Others
187 | ClientBin/
188 | ~$*
189 | *~
190 | *.dbmdl
191 | *.dbproj.schemaview
192 | *.jfm
193 | *.pfx
194 | *.publishsettings
195 | node_modules/
196 | orleans.codegen.cs
197 | 
198 | # Since there are multiple workflows, uncomment next line to ignore bower_components
199 | # (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
200 | #bower_components/
201 | 
202 | # RIA/Silverlight projects
203 | Generated_Code/
204 | 
205 | # Backup & report files from converting an old project file
206 | # to a newer Visual Studio version. Backup files are not needed,
207 | # because we have git ;-)
208 | _UpgradeReport_Files/
209 | Backup*/
210 | UpgradeLog*.XML
211 | UpgradeLog*.htm
212 | 
213 | # SQL Server files
214 | *.mdf
215 | *.ldf
216 | 
217 | # Business Intelligence projects
218 | *.rdl.data
219 | *.bim.layout
220 | *.bim_*.settings
221 | 
222 | # Microsoft Fakes
223 | FakesAssemblies/
224 | 
225 | # GhostDoc plugin setting file
226 | *.GhostDoc.xml
227 | 
228 | # Node.js Tools for Visual Studio
229 | .ntvs_analysis.dat
230 | 
231 | # Visual Studio 6 build log
232 | *.plg
233 | 
234 | # Visual Studio 6 workspace options file
235 | *.opt
236 | 
237 | # Visual Studio LightSwitch build output
238 | **/*.HTMLClient/GeneratedArtifacts
239 | **/*.DesktopClient/GeneratedArtifacts
240 | **/*.DesktopClient/ModelManifest.xml
241 | **/*.Server/GeneratedArtifacts
242 | **/*.Server/ModelManifest.xml
243 | _Pvt_Extensions
244 | 
245 | # Paket dependency manager
246 | .paket/paket.exe
247 | paket-files/
248 | 
249 | # FAKE - F# Make
250 | .fake/
251 | 
252 | # JetBrains Rider
253 | .idea/
254 | *.sln.iml
255 | 
256 | # CodeRush
257 | .cr/
258 | 
259 | # Python Tools for Visual Studio (PTVS)
260 | __pycache__/
261 | *.pyc


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/VPNService/UDPOutput.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using Android.Util;
  4 | using Java.IO;
  5 | using Java.Lang;
  6 | using Java.Net;
  7 | using Java.Nio;
  8 | using Java.Nio.Channels;
  9 | using Java.Util;
 10 | using Java.Util.Concurrent;
 11 | 
 12 | namespace XamarinAndroidVPNExample.VPNService
 13 | {
 14 |     public class UDPOutput : Java.Lang.Object, Java.Lang.IRunnable
 15 |     {
 16 |         private const string TAG = "UDPOutput";
 17 | 
 18 |         private LocalVPNService vpnService;
 19 |         private ConcurrentLinkedQueue inputQueue;
 20 |         private Selector selector;
 21 | 
 22 |         private const int MAX_CACHE_SIZE = 50;
 23 | 
 24 |         private LRUChannelCache channelCache;
 25 | 
 26 |         public UDPOutput(ConcurrentLinkedQueue inputQueue, Selector selector, LocalVPNService vpnService)
 27 |         {
 28 |             this.inputQueue = inputQueue;
 29 |             this.selector = selector;
 30 |             this.vpnService = vpnService;
 31 |             this.channelCache = new LRUChannelCache(this, MAX_CACHE_SIZE);
 32 |         }
 33 | 
 34 |         public void Run()
 35 |         {
 36 |             Log.Info(TAG, "Started");
 37 |             try
 38 |             {
 39 |                 Thread currentThread = Thread.CurrentThread();
 40 |                 while (true)
 41 |                 {
 42 |                     Packet currentPacket;
 43 |                     // TODO: Block when not connected
 44 |                     do
 45 |                     {
 46 |                         currentPacket = (Packet)inputQueue.Poll();
 47 |                         if (currentPacket != null)
 48 |                             break;
 49 |                         Thread.Sleep(10);
 50 |                     } while (!currentThread.IsInterrupted);
 51 | 
 52 |                     if (currentThread.IsInterrupted)
 53 |                         break;
 54 | 
 55 |                     InetAddress destinationAddress = currentPacket.ip4Header.destinationAddress;
 56 |                     int destinationPort = currentPacket.udpHeader.destinationPort;
 57 |                     int sourcePort = currentPacket.udpHeader.sourcePort;
 58 | 
 59 |                     Java.Lang.String ipAndPort = new Java.Lang.String(destinationAddress.HostAddress + ":" + destinationPort + ":" + sourcePort);
 60 | 
 61 |                     System.Console.WriteLine("UDP Out: " + ipAndPort);
 62 | 
 63 |                     DatagramChannel outputChannel = (DatagramChannel)channelCache.Get(ipAndPort);
 64 | 
 65 |                     if (outputChannel == null)
 66 |                     {
 67 |                         outputChannel = DatagramChannel.Open();
 68 |                         vpnService.Protect(outputChannel.Socket());
 69 |                         try
 70 |                         {
 71 |                             outputChannel.Connect(new InetSocketAddress(destinationAddress, destinationPort));
 72 |                         }
 73 |                         catch (IOException e)
 74 |                         {
 75 |                             Log.Error(TAG, "Connection error: " + ipAndPort, e);
 76 |                             closeChannel(outputChannel);
 77 |                             ByteBufferPool.Release(currentPacket.backingBuffer);
 78 |                             continue;
 79 |                         }
 80 | 
 81 |                         outputChannel.ConfigureBlocking(false);
 82 |                         currentPacket.SwapSourceAndDestination();
 83 | 
 84 |                         selector.Wakeup();
 85 |                         outputChannel.Register(selector, SelectionKey.OpRead, currentPacket);
 86 | 
 87 |                         channelCache.Put(ipAndPort, outputChannel);
 88 |                     }
 89 | 
 90 |                     try
 91 |                     {
 92 |                         ByteBuffer payloadBuffer = currentPacket.backingBuffer;
 93 |                         while (payloadBuffer.HasRemaining)
 94 |                             outputChannel.Write(payloadBuffer);
 95 |                     }
 96 |                     catch (IOException e)
 97 |                     {
 98 |                         Log.Error(TAG, "Network write error: " + ipAndPort, e);
 99 |                         channelCache.Remove(ipAndPort);
100 |                         closeChannel(outputChannel);
101 |                     }
102 | 
103 |                     ByteBufferPool.Release(currentPacket.backingBuffer);
104 |                 }
105 |             }
106 |             catch (InterruptedException e)
107 |             {
108 |                 Log.Info(TAG, "Stopping");
109 |             }
110 |             catch (IOException e)
111 |             {
112 |                 Log.Info(TAG, e.ToString(), e);
113 |             }
114 |             finally
115 |             {
116 |                 closeAll();
117 |             }
118 |         }
119 | 
120 |         public void Dispose()
121 |         {
122 |             closeAll();
123 |         }
124 | 
125 |         private void closeAll()
126 |         {
127 |             var enumerator = channelCache.EntrySet().GetEnumerator();
128 | 
129 |             while (enumerator.MoveNext())
130 |             {
131 |                 try
132 |                 {
133 |                     var o = (DatagramChannel)enumerator.Current;
134 |                     closeChannel(o);
135 |                 }
136 |                 catch { }
137 |             }
138 |         }
139 | 
140 |         private void closeChannel(DatagramChannel channel)
141 |         {
142 |             try
143 |             {
144 |                 channel.Close();
145 |             }
146 |             catch (IOException e)
147 |             {
148 |                 // Ignore
149 |             }
150 |         }
151 | 
152 |         public class LRUChannelCache : LRUCache<string, DatagramChannel>
153 |         {
154 |             UDPOutput output;
155 | 
156 |             public LRUChannelCache(UDPOutput output, int maxSize) : base(maxSize)
157 |             {
158 |                 this.output = output;
159 |             }
160 | 
161 |             public override void Cleanup(IMapEntry eldest)
162 |             {
163 |                 output.closeChannel((DatagramChannel)eldest.Value);
164 |             }
165 |         }
166 |     }
167 | }
168 | 


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/VPNService/TCPInput.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Linq;
  4 | using System.Text;
  5 | 
  6 | using Android.App;
  7 | using Android.Content;
  8 | using Android.OS;
  9 | using Android.Runtime;
 10 | using Android.Util;
 11 | using Android.Views;
 12 | using Android.Widget;
 13 | using Java.IO;
 14 | using Java.Lang;
 15 | using Java.Nio;
 16 | using Java.Nio.Channels;
 17 | using Java.Util.Concurrent;
 18 | using static XamarinAndroidVPNExample.VPNService.TCB;
 19 | 
 20 | namespace XamarinAndroidVPNExample.VPNService
 21 | {
 22 |     public class TCPInput : Java.Lang.Object, Java.Lang.IRunnable
 23 |     {
 24 |         private const string TAG = "TCPInput";
 25 |         private const int HEADER_SIZE = Packet.IP4_HEADER_SIZE + Packet.TCP_HEADER_SIZE;
 26 | 
 27 |         private ConcurrentLinkedQueue outputQueue;
 28 |         private Selector selector;
 29 | 
 30 |         public TCPInput(ConcurrentLinkedQueue outputQueue, Selector selector)
 31 |         {
 32 |             this.outputQueue = outputQueue;
 33 |             this.selector = selector;
 34 |         }
 35 | 
 36 |         public void Run()
 37 |         {
 38 |             try
 39 |             {
 40 |                 Log.Debug(TAG, "Started");
 41 |                 while (!Thread.Interrupted())
 42 |                 {
 43 |                     int readyChannels = selector.Select();
 44 | 
 45 |                     if (readyChannels == 0)
 46 |                     {
 47 |                         Thread.Sleep(10);
 48 |                         continue;
 49 |                     }
 50 | 
 51 |                     var keys = selector.SelectedKeys();
 52 |                     List<SelectionKey> keyIterator = keys.ToList();
 53 | 
 54 |                     foreach (var key in keys)
 55 |                     {
 56 |                         if (!Thread.Interrupted())
 57 |                         {
 58 |                             if (key.IsValid)
 59 |                             {
 60 |                                 if (key.IsConnectable)
 61 |                                     ProcessConnect(key, keyIterator);
 62 |                                 else if (key.IsReadable)
 63 |                                     processInput(key, keyIterator);
 64 |                             }
 65 |                         }
 66 |                     }
 67 |                 }
 68 |             }
 69 |             catch (InterruptedException e)
 70 |             {
 71 |                 Log.Info(TAG, "Stopping");
 72 |             }
 73 |             catch (IOException e)
 74 |             {
 75 |                 Log.Warn(TAG, e.ToString(), e);
 76 |             }
 77 |         }
 78 | 
 79 |         private void ProcessConnect(SelectionKey key, List<SelectionKey> keyIterator)
 80 |         {
 81 |             TCB tcb = (TCB)key.Attachment();
 82 |             Packet referencePacket = tcb.referencePacket;
 83 |             try
 84 |             {
 85 |                 if (tcb.channel.FinishConnect())
 86 |                 {
 87 |                     if (keyIterator[0] != null)
 88 |                     {
 89 |                         keyIterator.RemoveAt(0);
 90 |                     }
 91 |                     tcb.status = TCBStatus.SYN_RECEIVED;
 92 | 
 93 |                     // TODO: Set MSS for receiving larger packets from the device
 94 |                     ByteBuffer responseBuffer = ByteBufferPool.acquire();
 95 |                     referencePacket.updateTCPBuffer(responseBuffer, (byte)(Packet.TCPHeader.SYN | Packet.TCPHeader.ACK),
 96 |                             tcb.mySequenceNum, tcb.myAcknowledgementNum, 0);
 97 |                     outputQueue.Offer(responseBuffer);
 98 | 
 99 |                     tcb.mySequenceNum++; // SYN counts as a byte
100 |                     //key.InterestOps(Operations.Read);
101 |                     key.InterestOps();
102 |                 }
103 |             }
104 |             catch (IOException e)
105 |             {
106 |                 Log.Error(TAG, "Connection error: " + tcb.ipAndPort, e);
107 |                 ByteBuffer responseBuffer = ByteBufferPool.acquire();
108 |                 referencePacket.updateTCPBuffer(responseBuffer, (byte)Packet.TCPHeader.RST, 0, tcb.myAcknowledgementNum, 0);
109 |                 outputQueue.Offer(responseBuffer);
110 |                 TCB.CloseTCB(tcb);
111 |             }
112 |         }
113 | 
114 |         private void processInput(SelectionKey key, List<SelectionKey> keyIterator)
115 |         {
116 |             System.Console.WriteLine("TCP In");
117 | 
118 |             try
119 |             {
120 | 
121 |                 if (keyIterator[0] != null)
122 |                 {
123 |                     keyIterator.RemoveAt(0);
124 |                 }
125 | 
126 |                 ByteBuffer receiveBuffer = ByteBufferPool.acquire();
127 |                 // Leave space for the header
128 |                 receiveBuffer.Position(HEADER_SIZE);
129 | 
130 |                 TCB tcb = (TCB)key.Attachment();
131 |                 lock (tcb)
132 |                 {
133 |                     Packet referencePacket = tcb.referencePacket;
134 |                     SocketChannel inputChannel = (SocketChannel)key.Channel();
135 |                     int readBytes;
136 |                     try
137 |                     {
138 |                         readBytes = inputChannel.Read(receiveBuffer);
139 |                     }
140 |                     catch (IOException e)
141 |                     {
142 |                         Log.Error(TAG, "Network read error: " + tcb.ipAndPort, e);
143 |                         referencePacket.updateTCPBuffer(receiveBuffer, (byte)Packet.TCPHeader.RST, 0, tcb.myAcknowledgementNum, 0);
144 |                         outputQueue.Offer(receiveBuffer);
145 |                         TCB.CloseTCB(tcb);
146 |                         return;
147 |                     }
148 | 
149 |                     if (readBytes == -1)
150 |                     {
151 |                         // End of stream, stop waiting until we push more data
152 |                         //key.InterestOps(0);
153 |                         key.InterestOps();
154 |                         tcb.waitingForNetworkData = false;
155 | 
156 |                         if (tcb.status != TCBStatus.CLOSE_WAIT)
157 |                         {
158 |                             ByteBufferPool.Release(receiveBuffer);
159 |                             return;
160 |                         }
161 | 
162 |                         tcb.status = TCBStatus.LAST_ACK;
163 |                         referencePacket.updateTCPBuffer(receiveBuffer, (byte)Packet.TCPHeader.FIN, tcb.mySequenceNum, tcb.myAcknowledgementNum, 0);
164 |                         tcb.mySequenceNum++; // FIN counts as a byte
165 |                     }
166 |                     else
167 |                     {
168 |                         // XXX: We should ideally be splitting segments by MTU/MSS, but this seems to work without
169 |                         referencePacket.updateTCPBuffer(receiveBuffer, (byte)(Packet.TCPHeader.PSH | Packet.TCPHeader.ACK),
170 |                                 tcb.mySequenceNum, tcb.myAcknowledgementNum, readBytes);
171 |                         tcb.mySequenceNum += readBytes; // Next sequence number
172 |                         receiveBuffer.Position(HEADER_SIZE + readBytes);
173 |                     }
174 |                 }
175 | 
176 |                 outputQueue.Offer(receiveBuffer);
177 |             }
178 |             catch (Java.Lang.Exception ex)
179 |             {
180 |                 System.Console.WriteLine(ex.Message);
181 |             }
182 |         }
183 |     }
184 | }
185 | 


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/VPNService/LocalVPNService.cs:
--------------------------------------------------------------------------------
  1 | using Android.App;
  2 | using Android.Content;
  3 | using Android.Net;
  4 | using Android.OS;
  5 | using Android.Runtime;
  6 | using Android.Support.V4.Content;
  7 | using Android.Util;
  8 | using Java.IO;
  9 | using Java.Lang;
 10 | using Java.Nio;
 11 | using Java.Nio.Channels;
 12 | using Java.Util.Concurrent;
 13 | 
 14 | namespace XamarinAndroidVPNExample.VPNService
 15 | {
 16 |     [Service(Label = "LocalVPNService", Name = "xamarinandroidvpnexample.vpnservice.LocalVPNService", Enabled = true, Permission = "android.permission.BIND_VPN_SERVICE")]
 17 |     public class LocalVPNService : VpnService
 18 |     {
 19 |         private const string TAG = "LocalVPNService";
 20 |         private const string VPN_ADDRESS = "10.0.0.2"; // Only IPv4 support for now
 21 |         private const string VPN_ROUTE = "0.0.0.0"; // Intercept everything
 22 |         private const string DNS_ADDRESS = "8.8.8.8"; // Google DNS
 23 | 
 24 |         public const string BROADCAST_VPN_STATE = "xamarinandroidvpnexample.vpnservice.VPN_STATE";
 25 | 
 26 |         private ParcelFileDescriptor vpnInterface = null;
 27 | 
 28 |         private PendingIntent pendingIntent;
 29 | 
 30 |         private ConcurrentLinkedQueue deviceToNetworkUDPQueue;
 31 |         private ConcurrentLinkedQueue deviceToNetworkTCPQueue;
 32 |         private ConcurrentLinkedQueue networkToDeviceQueue;
 33 |         private IExecutorService executorService;
 34 | 
 35 |         private Selector udpSelector;
 36 |         private Selector tcpSelector;
 37 | 
 38 |         public static bool isRunning;
 39 | 
 40 |         public override void OnCreate()
 41 |         {
 42 |             base.OnCreate();
 43 | 
 44 |             isRunning = true;
 45 |             SetupVPN();
 46 |             
 47 |             if (vpnInterface == null)
 48 |             {
 49 |                 Log.Error(TAG, "Vpn Interface is null. Something when wrong.");
 50 |                 StopSelf();
 51 |                 return;
 52 |             }
 53 | 
 54 |             try
 55 |             {
 56 |                 udpSelector = Selector.Open();
 57 |                 tcpSelector = Selector.Open();
 58 |                 deviceToNetworkUDPQueue = new ConcurrentLinkedQueue();
 59 |                 deviceToNetworkTCPQueue = new ConcurrentLinkedQueue();
 60 |                 networkToDeviceQueue = new ConcurrentLinkedQueue();
 61 | 
 62 |                 executorService = Executors.NewFixedThreadPool(5);
 63 |                 executorService.Submit(new UDPInput(networkToDeviceQueue, udpSelector));
 64 |                 executorService.Submit(new UDPOutput(deviceToNetworkUDPQueue, udpSelector, this));
 65 |                 executorService.Submit(new TCPInput(networkToDeviceQueue, tcpSelector));
 66 |                 executorService.Submit(new TCPOutput(deviceToNetworkTCPQueue, networkToDeviceQueue, tcpSelector, this));
 67 |                 executorService.Submit(new VPNRunnable(vpnInterface.FileDescriptor, deviceToNetworkUDPQueue, deviceToNetworkTCPQueue, networkToDeviceQueue));
 68 |                 LocalBroadcastManager.GetInstance(this).SendBroadcast(new Intent(BROADCAST_VPN_STATE).PutExtra("running", true));
 69 |                 Log.Info(TAG, "Started");
 70 |             }
 71 |             catch (IOException e)
 72 |             {
 73 |                 // TODO: Here and elsewhere, we should explicitly notify the user of any errors
 74 |                 // and suggest that they stop the service, since we can't do it ourselves
 75 |                 Log.Error(TAG, "Error starting service", e);
 76 |                 Cleanup();
 77 |             }
 78 |             
 79 |         }
 80 | 
 81 |         private void SetupVPN()
 82 |         {
 83 |             if (vpnInterface == null)
 84 |             {
 85 |                 Builder builder = new Builder(this);
 86 |                 builder.AddAddress(VPN_ADDRESS, 32);
 87 |                 builder.AddRoute(VPN_ROUTE, 0);
 88 |                 builder.AddDnsServer(DNS_ADDRESS);
 89 |                 builder.SetSession(GetString(Resource.String.app_name));
 90 |                 builder.SetConfigureIntent(pendingIntent);
 91 |                 vpnInterface = builder.Establish();
 92 |             }
 93 |         }
 94 | 
 95 |         public static bool IsRunning { get { return isRunning; } }
 96 | 
 97 |         [return: GeneratedEnum]
 98 |         public override StartCommandResult OnStartCommand(Intent intent, [GeneratedEnum] StartCommandFlags flags, int startId)
 99 |         {
100 |             return StartCommandResult.Sticky;
101 |         }
102 | 
103 |         public override void OnDestroy()
104 |         {
105 |             base.OnDestroy();
106 | 
107 |             isRunning = false;
108 |             if (executorService != null)
109 |             {
110 |                 executorService.ShutdownNow();
111 |             }
112 |             Cleanup();
113 |             Log.Info(TAG, "Stopped");
114 |         }
115 | 
116 |         private void Cleanup()
117 |         {
118 |             deviceToNetworkTCPQueue = null;
119 |             deviceToNetworkUDPQueue = null;
120 |             networkToDeviceQueue = null;
121 |             ByteBufferPool.Clear();
122 |             CloseResources(udpSelector, tcpSelector, vpnInterface);
123 |         }
124 | 
125 |         // TODO: Move this to a "utils" class for reuse
126 |         private static void CloseResources(params Java.IO.ICloseable[] resources)
127 |         {
128 |             foreach(var resource in resources)
129 |             {
130 |                 try
131 |                 {
132 |                     if (resource != null)
133 |                     {
134 |                         resource.Close();
135 |                     }
136 |                 }
137 |                 catch (IOException e)
138 |                 {
139 |                     // Ignore
140 |                 }
141 |             }
142 |         }
143 | 
144 |         private class VPNRunnable : Java.Lang.Object, IRunnable
145 |         {
146 |             private const string TAG = "VPNRunnable";
147 | 
148 |             private FileDescriptor vpnFileDescriptor;
149 | 
150 |             private ConcurrentLinkedQueue deviceToNetworkUDPQueue;
151 |             private ConcurrentLinkedQueue deviceToNetworkTCPQueue;
152 |             private ConcurrentLinkedQueue networkToDeviceQueue;
153 | 
154 |             public VPNRunnable(FileDescriptor vpnFileDescriptor,
155 |                                ConcurrentLinkedQueue deviceToNetworkUDPQueue,
156 |                                ConcurrentLinkedQueue deviceToNetworkTCPQueue,
157 |                                ConcurrentLinkedQueue networkToDeviceQueue)
158 |             {
159 |                 this.vpnFileDescriptor = vpnFileDescriptor;
160 |                 this.deviceToNetworkUDPQueue = deviceToNetworkUDPQueue;
161 |                 this.deviceToNetworkTCPQueue = deviceToNetworkTCPQueue;
162 |                 this.networkToDeviceQueue = networkToDeviceQueue;
163 |             }
164 | 
165 |             public void Run()
166 |             {
167 |                 Log.Info(TAG, "Started");
168 | 
169 |                 FileChannel vpnInput = new FileInputStream(vpnFileDescriptor).Channel;
170 |                 FileChannel vpnOutput = new FileOutputStream(vpnFileDescriptor).Channel;
171 | 
172 |                 try
173 |                 {
174 |                     ByteBuffer bufferToNetwork = null;
175 |                     bool dataSent = true;
176 |                     bool dataReceived;
177 |                     while (!Thread.Interrupted())
178 |                     {
179 |                         if (dataSent)
180 |                             bufferToNetwork = ByteBufferPool.acquire();
181 |                         else
182 |                             bufferToNetwork.Clear();
183 | 
184 |                         // TODO: Block when not connected
185 |                         int readBytes = vpnInput.Read(bufferToNetwork);
186 |                         if (readBytes > 0)
187 |                         {
188 |                             dataSent = true;
189 |                             bufferToNetwork.Flip();
190 |                             Packet packet = new Packet(bufferToNetwork);
191 |                             if (packet.IsUDP)
192 |                             {
193 |                                 deviceToNetworkUDPQueue.Offer(packet);
194 |                                 System.Console.WriteLine("-> Device (UDP) to network write");
195 |                             }
196 |                             else if (packet.IsTCP)
197 |                             {
198 |                                 deviceToNetworkTCPQueue.Offer(packet);
199 |                                 System.Console.WriteLine("-> Device (TCP) to network write");
200 |                             }
201 |                             else
202 |                             {
203 |                                 Log.Warn(TAG, "Unknown packet type");
204 |                                 Log.Warn(TAG, packet.ip4Header.ToString());
205 |                                 dataSent = false;
206 |                             }
207 |                         }
208 |                         else
209 |                         {
210 |                             dataSent = false;
211 |                         }
212 | 
213 |                         ByteBuffer bufferFromNetwork = (ByteBuffer)networkToDeviceQueue.Poll();
214 |                         if (bufferFromNetwork != null)
215 |                         {
216 |                             bufferFromNetwork.Flip();
217 |                             while (bufferFromNetwork.HasRemaining)
218 |                             {
219 |                                 try
220 |                                 {
221 |                                     vpnOutput.Write(bufferFromNetwork);
222 |                                 }
223 |                                 catch (Exception ex)
224 |                                 {
225 |                                     bufferFromNetwork.Clear();
226 |                                     System.Console.WriteLine(ex.Message);
227 |                                 }
228 |                             }
229 |                             dataReceived = true;
230 | 
231 |                             System.Console.WriteLine("<- Network to device write");
232 | 
233 |                             ByteBufferPool.Release(bufferFromNetwork);
234 |                         }
235 |                         else
236 |                         {
237 |                             dataReceived = false;
238 |                         }
239 | 
240 |                         // TODO: Sleep-looping is not very battery-friendly, consider blocking instead
241 |                         // Confirm if throughput with ConcurrentQueue is really higher compared to BlockingQueue
242 |                         if (!dataSent && !dataReceived)
243 |                             Thread.Sleep(10);
244 |                     }
245 |                 }
246 |                 catch (InterruptedException e)
247 |                 {
248 |                     Log.Info(TAG, "Stopping");
249 |                 }
250 |                 catch (IOException e)
251 |                 {
252 |                     Log.Warn(TAG, e.ToString(), e);
253 |                 }
254 |                 finally
255 |                 {
256 |                     CloseResources(vpnInput, vpnOutput);
257 |                 }
258 |             }
259 |         }
260 |     }
261 | }
262 | 


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/VPNService/TCPOutput.cs:
--------------------------------------------------------------------------------
  1 | using Android.Util;
  2 | using Java.IO;
  3 | using Java.Lang;
  4 | using Java.Net;
  5 | using Java.Nio;
  6 | using Java.Nio.Channels;
  7 | using Java.Util;
  8 | using Java.Util.Concurrent;
  9 | using static XamarinAndroidVPNExample.VPNService.Packet;
 10 | 
 11 | namespace XamarinAndroidVPNExample.VPNService
 12 | {
 13 |     public class TCPOutput : Java.Lang.Object, Java.Lang.IRunnable
 14 |     {
 15 |         private const string TAG = "TCPOutput";
 16 | 
 17 |         private LocalVPNService vpnService;
 18 |         private ConcurrentLinkedQueue inputQueue;
 19 |         private ConcurrentLinkedQueue outputQueue;
 20 |         private Selector selector;
 21 | 
 22 |         private Random random = new Random();
 23 | 
 24 |         public TCPOutput(ConcurrentLinkedQueue inputQueue, ConcurrentLinkedQueue outputQueue,
 25 |                          Selector selector, LocalVPNService vpnService)
 26 |         {
 27 |             this.inputQueue = inputQueue;
 28 |             this.outputQueue = outputQueue;
 29 |             this.selector = selector;
 30 |             this.vpnService = vpnService;
 31 |         }
 32 | 
 33 |         public void Run()
 34 |         {
 35 |             Log.Info(TAG, "Started");
 36 |             try
 37 |             {
 38 |                 Thread currentThread = Thread.CurrentThread();
 39 |                 while (true)
 40 |                 {
 41 |                     Packet currentPacket;
 42 |                     // TODO: Block when not connected
 43 |                     do
 44 |                     {
 45 |                         currentPacket = (Packet)inputQueue.Poll();
 46 |                         if (currentPacket != null)
 47 |                             break;
 48 |                         Thread.Sleep(10);
 49 |                     } while (!currentThread.IsInterrupted);
 50 | 
 51 |                     if (currentThread.IsInterrupted)
 52 |                         break;
 53 | 
 54 |                     ByteBuffer payloadBuffer = currentPacket.backingBuffer;
 55 |                     currentPacket.backingBuffer = null;
 56 |                     ByteBuffer responseBuffer = ByteBufferPool.acquire();
 57 | 
 58 |                     InetAddress destinationAddress = currentPacket.ip4Header.destinationAddress;
 59 | 
 60 |                     TCPHeader tcpHeader = currentPacket.tcpHeader;
 61 |                     int destinationPort = tcpHeader.destinationPort;
 62 |                     int sourcePort = tcpHeader.sourcePort;
 63 | 
 64 |                     Java.Lang.String ipAndPort = new Java.Lang.String(destinationAddress.HostAddress + ":" +
 65 |                              destinationPort + ":" + sourcePort);
 66 | 
 67 |                     System.Console.WriteLine("TCP Out: " + ipAndPort);
 68 | 
 69 |                     TCB tcb = TCB.GetTCB(ipAndPort);
 70 |                     if (tcb == null)
 71 |                         InitializeConnection(ipAndPort, destinationAddress, destinationPort,
 72 |                                 currentPacket, tcpHeader, responseBuffer);
 73 |                     else if (tcpHeader.isSYN())
 74 |                         processDuplicateSYN(tcb, tcpHeader, responseBuffer);
 75 |                     else if (tcpHeader.isRST())
 76 |                         CloseCleanly(tcb, responseBuffer);
 77 |                     else if (tcpHeader.isFIN())
 78 |                         processFIN(tcb, tcpHeader, responseBuffer);
 79 |                     else if (tcpHeader.isACK())
 80 |                         processACK(tcb, tcpHeader, payloadBuffer, responseBuffer);
 81 | 
 82 |                     // XXX: cleanup later
 83 |                     if (responseBuffer.Position() == 0)
 84 |                         ByteBufferPool.Release(responseBuffer);
 85 |                     ByteBufferPool.Release(payloadBuffer);
 86 |                 }
 87 |             }
 88 |             catch (InterruptedException e)
 89 |             {
 90 |                 Log.Info(TAG, "Stopping");
 91 |             }
 92 |             catch (IOException e)
 93 |             {
 94 |                 Log.Error(TAG, e.ToString(), e);
 95 |             }
 96 |             finally
 97 |             {
 98 |                 TCB.CloseAll();
 99 |             }
100 |         }
101 | 
102 |         private void InitializeConnection(Java.Lang.String ipAndPort, InetAddress destinationAddress, int destinationPort,
103 |                                       Packet currentPacket, TCPHeader tcpHeader, ByteBuffer responseBuffer)
104 | 
105 |         {
106 |             currentPacket.SwapSourceAndDestination();
107 |             if (tcpHeader.isSYN())
108 |             {
109 |                 SocketChannel outputChannel = SocketChannel.Open();
110 |                 outputChannel.ConfigureBlocking(false);
111 |                 vpnService.Protect(outputChannel.Socket());
112 | 
113 |                 TCB tcb = new TCB(ipAndPort, random.NextInt(Short.MaxValue + 1), tcpHeader.sequenceNumber, tcpHeader.sequenceNumber + 1,
114 |                         tcpHeader.acknowledgementNumber, outputChannel, currentPacket);
115 |                 TCB.PutTCB(ipAndPort, tcb);
116 | 
117 |                 try
118 |                 {
119 |                     outputChannel.Connect(new InetSocketAddress(destinationAddress, destinationPort));
120 |                     if (outputChannel.FinishConnect())
121 |                     {
122 |                         tcb.status = TCB.TCBStatus.SYN_RECEIVED;
123 |                         // TODO: Set MSS for receiving larger packets from the device
124 |                         currentPacket.updateTCPBuffer(responseBuffer, (byte)(TCPHeader.SYN | TCPHeader.ACK),
125 |                                 tcb.mySequenceNum, tcb.myAcknowledgementNum, 0);
126 |                         tcb.mySequenceNum++; // SYN counts as a byte
127 |                     }
128 |                     else
129 |                     {
130 |                         tcb.status = TCB.TCBStatus.SYN_SENT;
131 |                         selector.Wakeup();
132 |                         tcb.selectionKey = outputChannel.Register(selector, SelectionKey.OpConnect, tcb);
133 |                         return;
134 |                     }
135 |                 }
136 |                 catch (IOException e)
137 |                 {
138 |                     Log.Error(TAG, "Connection error: " + ipAndPort, e);
139 |                     currentPacket.updateTCPBuffer(responseBuffer, (byte)TCPHeader.RST, 0, tcb.myAcknowledgementNum, 0);
140 |                     TCB.CloseTCB(tcb);
141 |                 }
142 |             }
143 |             else
144 |             {
145 |                 currentPacket.updateTCPBuffer(responseBuffer, (byte)TCPHeader.RST,
146 |                         0, tcpHeader.sequenceNumber + 1, 0);
147 |             }
148 | 
149 |             outputQueue.Offer(responseBuffer);
150 |         }
151 | 
152 |         private void processDuplicateSYN(TCB tcb, TCPHeader tcpHeader, ByteBuffer responseBuffer)
153 |         {
154 |             lock (tcb)
155 |             {
156 |                 if (tcb.status == TCB.TCBStatus.SYN_SENT)
157 |                 {
158 |                     tcb.myAcknowledgementNum = tcpHeader.sequenceNumber + 1;
159 |                     return;
160 |                 }
161 |             }
162 | 
163 |             SendRST(tcb, 1, responseBuffer);
164 |         }
165 | 
166 |         private void processFIN(TCB tcb, TCPHeader tcpHeader, ByteBuffer responseBuffer)
167 |         {
168 |             lock (tcb)
169 |             {
170 |                 Packet referencePacket = tcb.referencePacket;
171 |                 tcb.myAcknowledgementNum = tcpHeader.sequenceNumber + 1;
172 |                 tcb.theirAcknowledgementNum = tcpHeader.acknowledgementNumber;
173 | 
174 |                 if (tcb.waitingForNetworkData)
175 |                 {
176 |                     tcb.status = TCB.TCBStatus.CLOSE_WAIT;
177 |                     referencePacket.updateTCPBuffer(responseBuffer, (byte)TCPHeader.ACK,
178 |                             tcb.mySequenceNum, tcb.myAcknowledgementNum, 0);
179 |                 }
180 |                 else
181 |                 {
182 |                     tcb.status = TCB.TCBStatus.LAST_ACK;
183 |                     referencePacket.updateTCPBuffer(responseBuffer, (byte)(TCPHeader.FIN | TCPHeader.ACK),
184 |                             tcb.mySequenceNum, tcb.myAcknowledgementNum, 0);
185 |                     tcb.mySequenceNum++; // FIN counts as a byte
186 |                 }
187 |             }
188 | 
189 |             outputQueue.Offer(responseBuffer);
190 |         }
191 | 
192 |         private void processACK(TCB tcb, TCPHeader tcpHeader, ByteBuffer payloadBuffer, ByteBuffer responseBuffer)
193 |         {
194 |             try
195 |             {
196 |                 int payloadSize = payloadBuffer.Limit() - payloadBuffer.Position();
197 | 
198 |                 lock (tcb)
199 |                 {
200 |                     SocketChannel outputChannel = tcb.channel;
201 |                     if (tcb.status == TCB.TCBStatus.SYN_RECEIVED)
202 |                     {
203 |                         tcb.status = TCB.TCBStatus.ESTABLISHED;
204 | 
205 |                         selector.Wakeup();
206 |                         tcb.selectionKey = outputChannel.Register(selector, SelectionKey.OpRead, tcb);
207 |                         tcb.waitingForNetworkData = true;
208 |                     }
209 |                     else if (tcb.status == TCB.TCBStatus.LAST_ACK)
210 |                     {
211 |                         CloseCleanly(tcb, responseBuffer);
212 |                         return;
213 |                     }
214 | 
215 |                     if (payloadSize == 0) return; // Empty ACK, ignore
216 | 
217 |                     if (!tcb.waitingForNetworkData)
218 |                     {
219 |                         selector.Wakeup();
220 |                         // tcb.selectionKey.InterestOps(SelectionKey.OpRead);
221 |                         tcb.selectionKey.InterestOps();
222 |                         tcb.waitingForNetworkData = true;
223 |                     }
224 | 
225 |                     // Forward to remote server
226 |                     try
227 |                     {
228 |                         while (payloadBuffer.HasRemaining)
229 |                             outputChannel.Write(payloadBuffer);
230 |                     }
231 |                     catch (IOException e)
232 |                     {
233 |                         Log.Error(TAG, "Network write error: " + tcb.ipAndPort, e);
234 |                         SendRST(tcb, payloadSize, responseBuffer);
235 |                         return;
236 |                     }
237 | 
238 |                     // TODO: We don't expect out-of-order packets, but verify
239 |                     tcb.myAcknowledgementNum = tcpHeader.sequenceNumber + payloadSize;
240 |                     tcb.theirAcknowledgementNum = tcpHeader.acknowledgementNumber;
241 |                     Packet referencePacket = tcb.referencePacket;
242 |                     referencePacket.updateTCPBuffer(responseBuffer, (byte)TCPHeader.ACK, tcb.mySequenceNum, tcb.myAcknowledgementNum, 0);
243 |                 }
244 | 
245 |                 outputQueue.Offer(responseBuffer);
246 |             }
247 |             catch(Exception ex)
248 |             {
249 |                 System.Console.WriteLine(ex.Message);
250 |             }
251 |         }
252 | 
253 |         private void SendRST(TCB tcb, int prevPayloadSize, ByteBuffer buffer)
254 |         {
255 |             tcb.referencePacket.updateTCPBuffer(buffer, (byte)TCPHeader.RST, 0, tcb.myAcknowledgementNum + prevPayloadSize, 0);
256 |             outputQueue.Offer(buffer);
257 |             TCB.CloseTCB(tcb);
258 |         }
259 | 
260 |         private void CloseCleanly(TCB tcb, ByteBuffer buffer)
261 |         {
262 |             ByteBufferPool.Release(buffer);
263 |             TCB.CloseTCB(tcb);
264 |         }
265 |     }
266 | }
267 | 


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/VPNService/Packet.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Text;
  3 | using Java.Net;
  4 | using Java.Nio;
  5 | 
  6 | namespace XamarinAndroidVPNExample.VPNService
  7 | {
  8 |     public class Packet : Java.Lang.Object
  9 |     {
 10 |         public const int IP4_HEADER_SIZE = 20;
 11 |         public const int TCP_HEADER_SIZE = 20;
 12 |         public const int UDP_HEADER_SIZE = 8;
 13 | 
 14 |         public IP4Header ip4Header;
 15 |         public TCPHeader tcpHeader;
 16 |         public UDPHeader udpHeader;
 17 |         public ByteBuffer backingBuffer;
 18 | 
 19 |         public Packet(ByteBuffer buffer)
 20 |         {
 21 |             try
 22 |             {
 23 |                 this.ip4Header = new IP4Header(buffer);
 24 |                 if (this.ip4Header.protocol == IP4Header.TransportProtocol.TCP)
 25 |                 {
 26 |                     this.tcpHeader = new TCPHeader(buffer);
 27 |                     this.IsTCP = true;
 28 |                 }
 29 |                 else if (ip4Header.protocol == IP4Header.TransportProtocol.UDP)
 30 |                 {
 31 |                     this.udpHeader = new UDPHeader(buffer);
 32 |                     this.IsUDP = true;
 33 |                 }
 34 |                 this.backingBuffer = buffer;
 35 |             }
 36 |             catch (Exception ex)
 37 |             {
 38 |                 throw new UnknownHostException();
 39 |             }
 40 |         }
 41 | 
 42 |         public override string ToString()
 43 |         {
 44 |             StringBuilder sb = new StringBuilder("Packet{");
 45 |             sb.Append("ip4Header=").Append(ip4Header);
 46 |             if (IsTCP) sb.Append(", tcpHeader=").Append(tcpHeader);
 47 |             else if (IsUDP) sb.Append(", udpHeader=").Append(udpHeader);
 48 |             sb.Append(", payloadSize=").Append(backingBuffer.Limit() - backingBuffer.Position());
 49 |             sb.Append('}');
 50 |             return sb.ToString();
 51 |         }
 52 | 
 53 |         public bool IsTCP { get; set; }
 54 | 
 55 |         public bool IsUDP { get; set; }
 56 | 
 57 |         public void SwapSourceAndDestination()
 58 |         {
 59 |             InetAddress newSourceAddress = ip4Header.destinationAddress;
 60 |             ip4Header.destinationAddress = ip4Header.sourceAddress;
 61 |             ip4Header.sourceAddress = newSourceAddress;
 62 | 
 63 |             if (IsUDP)
 64 |             {
 65 |                 int newSourcePort = udpHeader.destinationPort;
 66 |                 udpHeader.destinationPort = udpHeader.sourcePort;
 67 |                 udpHeader.sourcePort = newSourcePort;
 68 |             }
 69 |             else if (IsTCP)
 70 |             {
 71 |                 int newSourcePort = tcpHeader.destinationPort;
 72 |                 tcpHeader.destinationPort = tcpHeader.sourcePort;
 73 |                 tcpHeader.sourcePort = newSourcePort;
 74 |             }
 75 |         }
 76 | 
 77 |         public void updateTCPBuffer(ByteBuffer buffer, byte flags, long sequenceNum, long ackNum, int payloadSize)
 78 |         {
 79 |             buffer.Position(0);
 80 |             FillHeader(buffer);
 81 |             backingBuffer = buffer;
 82 | 
 83 |             tcpHeader.flags = flags;
 84 |             backingBuffer.Put(IP4_HEADER_SIZE + 13, (sbyte)flags);
 85 | 
 86 |             tcpHeader.sequenceNumber = sequenceNum;
 87 |             backingBuffer.PutInt(IP4_HEADER_SIZE + 4, (int)sequenceNum);
 88 | 
 89 |             tcpHeader.acknowledgementNumber = ackNum;
 90 |             backingBuffer.PutInt(IP4_HEADER_SIZE + 8, (int)ackNum);
 91 | 
 92 |             // Reset header size, since we don't need options
 93 |             byte dataOffset = (byte)(TCP_HEADER_SIZE << 2);
 94 |             tcpHeader.dataOffsetAndReserved = dataOffset;
 95 |             backingBuffer.Put(IP4_HEADER_SIZE + 12, (sbyte)dataOffset);
 96 | 
 97 |             updateTCPChecksum(payloadSize);
 98 | 
 99 |             int ip4TotalLength = IP4_HEADER_SIZE + TCP_HEADER_SIZE + payloadSize;
100 |             backingBuffer.PutShort(2, (short)ip4TotalLength);
101 |             ip4Header.totalLength = ip4TotalLength;
102 | 
103 |             updateIP4Checksum();
104 |         }
105 | 
106 |         public void updateUDPBuffer(ByteBuffer buffer, int payloadSize)
107 |         {
108 |             buffer.Position(0);
109 |             FillHeader(buffer);
110 |             backingBuffer = buffer;
111 | 
112 |             int udpTotalLength = UDP_HEADER_SIZE + payloadSize;
113 |             backingBuffer.PutShort(IP4_HEADER_SIZE + 4, (short)udpTotalLength);
114 |             udpHeader.length = udpTotalLength;
115 | 
116 |             // Disable UDP checksum validation
117 |             backingBuffer.PutShort(IP4_HEADER_SIZE + 6, (short)0);
118 |             udpHeader.checksum = 0;
119 | 
120 |             int ip4TotalLength = IP4_HEADER_SIZE + udpTotalLength;
121 |             backingBuffer.PutShort(2, (short)ip4TotalLength);
122 |             ip4Header.totalLength = ip4TotalLength;
123 | 
124 |             updateIP4Checksum();
125 |         }
126 | 
127 |         private void updateIP4Checksum()
128 |         {
129 |             ByteBuffer buffer = backingBuffer.Duplicate();
130 |             buffer.Position(0);
131 | 
132 |             // Clear previous checksum
133 |             buffer.PutShort(10, (short)0);
134 | 
135 |             int ipLength = ip4Header.headerLength;
136 |             int sum = 0;
137 |             while (ipLength > 0)
138 |             {
139 |                 sum += BitUtils.GetUnsignedShort(buffer.Short);
140 |                 ipLength -= 2;
141 |             }
142 |             while (sum >> 16 > 0)
143 |                 sum = (sum & 0xFFFF) + (sum >> 16);
144 | 
145 |             sum = ~sum;
146 |             ip4Header.headerChecksum = sum;
147 |             backingBuffer.PutShort(10, (short)sum);
148 |         }
149 | 
150 |         private void updateTCPChecksum(int payloadSize)
151 |         {
152 |             int sum = 0;
153 |             int tcpLength = TCP_HEADER_SIZE + payloadSize;
154 | 
155 |             // Calculate pseudo-header checksum
156 |             ByteBuffer buffer = ByteBuffer.Wrap(ip4Header.sourceAddress.GetAddress());
157 |             sum = BitUtils.GetUnsignedShort(buffer.Short) + BitUtils.GetUnsignedShort(buffer.Short);
158 | 
159 |             buffer = ByteBuffer.Wrap(ip4Header.destinationAddress.GetAddress());
160 |             sum += BitUtils.GetUnsignedShort(buffer.Short) + BitUtils.GetUnsignedShort(buffer.Short);
161 | 
162 |             sum += ((int)IP4Header.TransportProtocol.TCP) + tcpLength;
163 | 
164 |             buffer = backingBuffer.Duplicate();
165 |             // Clear previous checksum
166 |             buffer.PutShort(IP4_HEADER_SIZE + 16, (short)0);
167 | 
168 |             // Calculate TCP segment checksum
169 |             buffer.Position(IP4_HEADER_SIZE);
170 |             while (tcpLength > 1)
171 |             {
172 |                 sum += BitUtils.GetUnsignedShort(buffer.Short);
173 |                 tcpLength -= 2;
174 |             }
175 |             if (tcpLength > 0)
176 |                 sum += BitUtils.GetUnsignedByte((byte)buffer.Get()) << 8;
177 | 
178 |             while (sum >> 16 > 0)
179 |                 sum = (sum & 0xFFFF) + (sum >> 16);
180 | 
181 |             sum = ~sum;
182 |             tcpHeader.checksum = sum;
183 |             backingBuffer.PutShort(IP4_HEADER_SIZE + 16, (short)sum);
184 |         }
185 | 
186 |         private void FillHeader(ByteBuffer buffer)
187 |         {
188 |             ip4Header.FillHeader(buffer);
189 |             if (IsUDP)
190 |                 udpHeader.FillHeader(buffer);
191 |             else if (IsTCP)
192 |                 tcpHeader.FillHeader(buffer);
193 |         }
194 | 
195 |         public class IP4Header
196 |         {
197 |             public byte version;
198 |             public byte IHL;
199 |             public int headerLength;
200 |             public short typeOfService;
201 |             public int totalLength;
202 | 
203 |             public int identificationAndFlagsAndFragmentOffset;
204 | 
205 |             public short TTL;
206 |             private short protocolNum;
207 |             public TransportProtocol protocol;
208 |             public int headerChecksum;
209 | 
210 |             public InetAddress sourceAddress;
211 |             public InetAddress destinationAddress;
212 | 
213 |             public int optionsAndPadding;
214 | 
215 |             public enum TransportProtocol
216 |             {
217 |                 TCP = 6,
218 |                 UDP = 17,
219 |                 Other = 0xFF
220 |             }
221 | 
222 |             public IP4Header(ByteBuffer buffer)
223 |             {
224 |                 try
225 |                 {
226 |                     byte versionAndIHL = (byte)buffer.Get();
227 |                     this.version = (byte)(versionAndIHL >> 4);
228 |                     this.IHL = (byte)(versionAndIHL & 0x0F);
229 |                     this.headerLength = this.IHL << 2;
230 | 
231 |                     this.typeOfService = BitUtils.GetUnsignedByte((byte)buffer.Get());
232 |                     this.totalLength = BitUtils.GetUnsignedShort(buffer.Short);
233 | 
234 |                     this.identificationAndFlagsAndFragmentOffset = buffer.Int;
235 | 
236 |                     this.TTL = BitUtils.GetUnsignedByte((byte)buffer.Get());
237 |                     this.protocolNum = BitUtils.GetUnsignedByte((byte)buffer.Get());
238 |                     this.protocol = (TransportProtocol)protocolNum;
239 |                     this.headerChecksum = BitUtils.GetUnsignedShort(buffer.Short);
240 | 
241 |                     byte[] addressBytes = new byte[4];
242 |                     buffer.Get(addressBytes, 0, 4);
243 |                     this.sourceAddress = InetAddress.GetByAddress(addressBytes);
244 | 
245 |                     buffer.Get(addressBytes, 0, 4);
246 |                     this.destinationAddress = InetAddress.GetByAddress(addressBytes);
247 | 
248 |                     //this.optionsAndPadding = buffer.getInt();
249 |                 }
250 |                 catch
251 |                 {
252 |                     throw new UnknownHostException();
253 |                 }
254 |             }
255 | 
256 |             public int GetNumber()
257 |             {
258 |                 return this.protocolNum;
259 |             }
260 | 
261 |             public void FillHeader(ByteBuffer buffer)
262 |             {
263 |                 buffer.Put((sbyte)(this.version << 4 | this.IHL));
264 |                 buffer.Put((sbyte)this.typeOfService);
265 |                 buffer.PutShort((short)this.totalLength);
266 | 
267 |                 buffer.PutInt(this.identificationAndFlagsAndFragmentOffset);
268 | 
269 |                 buffer.Put((sbyte)this.TTL);
270 |                 buffer.Put((sbyte)this.protocol);
271 |                 buffer.PutShort((short)this.headerChecksum);
272 | 
273 |                 buffer.Put(this.sourceAddress.GetAddress());
274 |                 buffer.Put(this.destinationAddress.GetAddress());
275 |             }
276 | 
277 |             public override string ToString()
278 |             {
279 |                 StringBuilder sb = new StringBuilder("IP4Header{");
280 |                 sb.Append("version=").Append(version);
281 |                 sb.Append(", IHL=").Append(IHL);
282 |                 sb.Append(", typeOfService=").Append(typeOfService);
283 |                 sb.Append(", totalLength=").Append(totalLength);
284 |                 sb.Append(", identificationAndFlagsAndFragmentOffset=").Append(identificationAndFlagsAndFragmentOffset);
285 |                 sb.Append(", TTL=").Append(TTL);
286 |                 sb.Append(", protocol=").Append(protocolNum).Append(":").Append(protocol);
287 |                 sb.Append(", headerChecksum=").Append(headerChecksum);
288 |                 sb.Append(", sourceAddress=").Append(sourceAddress.HostAddress);
289 |                 sb.Append(", destinationAddress=").Append(destinationAddress.HostAddress);
290 |                 sb.Append('}');
291 |                 return sb.ToString();
292 |             }
293 |         }
294 | 
295 |         public class TCPHeader
296 |         {
297 |             public const int FIN = 0x01;
298 |             public const int SYN = 0x02;
299 |             public const int RST = 0x04;
300 |             public const int PSH = 0x08;
301 |             public const int ACK = 0x10;
302 |             public const int URG = 0x20;
303 | 
304 |             public int sourcePort;
305 |             public int destinationPort;
306 | 
307 |             public long sequenceNumber;
308 |             public long acknowledgementNumber;
309 | 
310 |             public byte dataOffsetAndReserved;
311 |             public int headerLength;
312 |             public byte flags;
313 |             public int window;
314 | 
315 |             public int checksum;
316 |             public int urgentPointer;
317 | 
318 |             public byte[] optionsAndPadding;
319 | 
320 |             public TCPHeader(ByteBuffer buffer)
321 |             {
322 |                 this.sourcePort = BitUtils.GetUnsignedShort(buffer.Short);
323 |                 this.destinationPort = BitUtils.GetUnsignedShort(buffer.Short);
324 | 
325 |                 this.sequenceNumber = BitUtils.GetUnsignedInt(buffer.Int);
326 |                 this.acknowledgementNumber = BitUtils.GetUnsignedInt(buffer.Int);
327 | 
328 |                 this.dataOffsetAndReserved = (byte)buffer.Get();
329 |                 this.headerLength = (this.dataOffsetAndReserved & 0xF0) >> 2;
330 |                 this.flags = (byte)buffer.Get();
331 |                 this.window = BitUtils.GetUnsignedShort(buffer.Short);
332 | 
333 |                 this.checksum = BitUtils.GetUnsignedShort(buffer.Short);
334 |                 this.urgentPointer = BitUtils.GetUnsignedShort(buffer.Short);
335 | 
336 |                 int optionsLength = this.headerLength - TCP_HEADER_SIZE;
337 |                 if (optionsLength > 0)
338 |                 {
339 |                     optionsAndPadding = new byte[optionsLength];
340 |                     buffer.Get(optionsAndPadding, 0, optionsLength);
341 |                 }
342 |             }
343 | 
344 |             public bool isFIN()
345 |             {
346 |                 return (flags & FIN) == FIN;
347 |             }
348 | 
349 |             public bool isSYN()
350 |             {
351 |                 return (flags & SYN) == SYN;
352 |             }
353 | 
354 |             public bool isRST()
355 |             {
356 |                 return (flags & RST) == RST;
357 |             }
358 | 
359 |             public bool isPSH()
360 |             {
361 |                 return (flags & PSH) == PSH;
362 |             }
363 | 
364 |             public bool isACK()
365 |             {
366 |                 return (flags & ACK) == ACK;
367 |             }
368 | 
369 |             public bool isURG()
370 |             {
371 |                 return (flags & URG) == URG;
372 |             }
373 | 
374 |             public void FillHeader(ByteBuffer buffer)
375 |             {
376 |                 buffer.PutShort((short)sourcePort);
377 |                 buffer.PutShort((short)destinationPort);
378 | 
379 |                 buffer.PutInt((int)sequenceNumber);
380 |                 buffer.PutInt((int)acknowledgementNumber);
381 | 
382 |                 buffer.Put((sbyte)dataOffsetAndReserved);
383 |                 buffer.Put((sbyte)flags);
384 |                 buffer.PutShort((short)window);
385 | 
386 |                 buffer.PutShort((short)checksum);
387 |                 buffer.PutShort((short)urgentPointer);
388 |             }
389 | 
390 |             public override string ToString()
391 |             {
392 |                 StringBuilder sb = new StringBuilder("TCPHeader{");
393 |                 sb.Append("sourcePort=").Append(sourcePort);
394 |                 sb.Append(", destinationPort=").Append(destinationPort);
395 |                 sb.Append(", sequenceNumber=").Append(sequenceNumber);
396 |                 sb.Append(", acknowledgementNumber=").Append(acknowledgementNumber);
397 |                 sb.Append(", headerLength=").Append(headerLength);
398 |                 sb.Append(", window=").Append(window);
399 |                 sb.Append(", checksum=").Append(checksum);
400 |                 sb.Append(", flags=");
401 |                 if (isFIN()) sb.Append(" FIN");
402 |                 if (isSYN()) sb.Append(" SYN");
403 |                 if (isRST()) sb.Append(" RST");
404 |                 if (isPSH()) sb.Append(" PSH");
405 |                 if (isACK()) sb.Append(" ACK");
406 |                 if (isURG()) sb.Append(" URG");
407 |                 sb.Append('}');
408 |                 return sb.ToString();
409 |             }
410 |         }
411 | 
412 |         public class UDPHeader
413 |         {
414 |             public int sourcePort;
415 |             public int destinationPort;
416 | 
417 |             public int length;
418 |             public int checksum;
419 | 
420 |             public UDPHeader(ByteBuffer buffer)
421 |             {
422 |                 this.sourcePort = BitUtils.GetUnsignedShort(buffer.Short);
423 |                 this.destinationPort = BitUtils.GetUnsignedShort(buffer.Short);
424 | 
425 |                 this.length = BitUtils.GetUnsignedShort(buffer.Short);
426 |                 this.checksum = BitUtils.GetUnsignedShort(buffer.Short);
427 |             }
428 | 
429 |             public void FillHeader(ByteBuffer buffer)
430 |             {
431 |                 buffer.PutShort((short)this.sourcePort);
432 |                 buffer.PutShort((short)this.destinationPort);
433 | 
434 |                 buffer.PutShort((short)this.length);
435 |                 buffer.PutShort((short)this.checksum);
436 |             }
437 | 
438 |             public override string ToString()
439 |             {
440 |                 StringBuilder sb = new StringBuilder("UDPHeader{");
441 |                 sb.Append("sourcePort=").Append(sourcePort);
442 |                 sb.Append(", destinationPort=").Append(destinationPort);
443 |                 sb.Append(", length=").Append(length);
444 |                 sb.Append(", checksum=").Append(checksum);
445 |                 sb.Append('}');
446 |                 return sb.ToString();
447 |             }
448 |         }
449 | 
450 |         public static class BitUtils
451 |         {
452 |             public static short GetUnsignedByte(byte value)
453 |             {
454 |                 return (short)(value & 0xFF);
455 |             }
456 | 
457 |             public static int GetUnsignedShort(short value)
458 |             {
459 |                 return value & 0xFFFF;
460 |             }
461 | 
462 |             public static long GetUnsignedInt(int value)
463 |             {
464 |                 return value & 0xFFFFFFFFL;
465 |             }
466 |         }
467 |     }
468 | }
469 | 


--------------------------------------------------------------------------------
/XamarinAndroidVPNExample/XamarinAndroidVPNExample.csproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <PropertyGroup>
  4 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
  5 |     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
  6 |     <ProductVersion>8.0.30703</ProductVersion>
  7 |     <SchemaVersion>2.0</SchemaVersion>
  8 |     <ProjectGuid>{3BC0AC7E-3B3B-4D3F-9CC0-B2BDECC460A6}</ProjectGuid>
  9 |     <ProjectTypeGuids>{EFBA0AD7-5A72-4C68-AF49-83D382785DCF};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
 10 |     <TemplateGuid>{84dd83c5-0fe3-4294-9419-09e7c8ba324f}</TemplateGuid>
 11 |     <OutputType>Library</OutputType>
 12 |     <AppDesignerFolder>Properties</AppDesignerFolder>
 13 |     <RootNamespace>XamarinAndroidVPNExample</RootNamespace>
 14 |     <AssemblyName>XamarinAndroidVPNExample</AssemblyName>
 15 |     <FileAlignment>512</FileAlignment>
 16 |     <AndroidApplication>True</AndroidApplication>
 17 |     <AndroidResgenFile>Resources\Resource.designer.cs</AndroidResgenFile>
 18 |     <AndroidResgenClass>Resource</AndroidResgenClass>
 19 |     <GenerateSerializationAssemblies>Off</GenerateSerializationAssemblies>
 20 |     <AndroidUseLatestPlatformSdk>false</AndroidUseLatestPlatformSdk>
 21 |     <TargetFrameworkVersion>v8.0</TargetFrameworkVersion>
 22 |     <AndroidManifest>Properties\AndroidManifest.xml</AndroidManifest>
 23 |     <MonoAndroidResourcePrefix>Resources</MonoAndroidResourcePrefix>
 24 |     <MonoAndroidAssetsPrefix>Assets</MonoAndroidAssetsPrefix>
 25 |     <AndroidHttpClientHandlerType>Xamarin.Android.Net.AndroidClientHandler</AndroidHttpClientHandlerType>
 26 |     <NuGetPackageImportStamp>
 27 |     </NuGetPackageImportStamp>
 28 |   </PropertyGroup>
 29 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
 30 |     <DebugSymbols>true</DebugSymbols>
 31 |     <DebugType>portable</DebugType>
 32 |     <Optimize>False</Optimize>
 33 |     <OutputPath>bin\Debug\</OutputPath>
 34 |     <DefineConstants>DEBUG;TRACE</DefineConstants>
 35 |     <ErrorReport>prompt</ErrorReport>
 36 |     <WarningLevel>4</WarningLevel>
 37 |     <AndroidUseSharedRuntime>true</AndroidUseSharedRuntime>
 38 |     <AndroidLinkMode>None</AndroidLinkMode>
 39 |     <EmbedAssembliesIntoApk>false</EmbedAssembliesIntoApk>
 40 |     <AotAssemblies>false</AotAssemblies>
 41 |     <EnableLLVM>false</EnableLLVM>
 42 |     <BundleAssemblies>false</BundleAssemblies>
 43 |   </PropertyGroup>
 44 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
 45 |     <DebugType>PdbOnly</DebugType>
 46 |     <DebugSymbols>True</DebugSymbols>
 47 |     <Optimize>True</Optimize>
 48 |     <OutputPath>bin\Release\</OutputPath>
 49 |     <DefineConstants>TRACE</DefineConstants>
 50 |     <ErrorReport>prompt</ErrorReport>
 51 |     <WarningLevel>4</WarningLevel>
 52 |     <AndroidManagedSymbols>true</AndroidManagedSymbols>
 53 |     <AndroidUseSharedRuntime>False</AndroidUseSharedRuntime>
 54 |     <AndroidLinkMode>SdkOnly</AndroidLinkMode>
 55 |     <EmbedAssembliesIntoApk>True</EmbedAssembliesIntoApk>
 56 |   </PropertyGroup>
 57 |   <ItemGroup>
 58 |     <Reference Include="System" />
 59 |     <Reference Include="System.Xml" />
 60 |     <Reference Include="System.Core" />
 61 |     <Reference Include="Mono.Android" />
 62 |     <Reference Include="Xamarin.Android.Arch.Core.Common, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
 63 |       <HintPath>..\packages\Xamarin.Android.Arch.Core.Common.1.1.1.1\lib\monoandroid80\Xamarin.Android.Arch.Core.Common.dll</HintPath>
 64 |       <Private>True</Private>
 65 |     </Reference>
 66 |     <Reference Include="Xamarin.Android.Arch.Lifecycle.Common, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
 67 |       <HintPath>..\packages\Xamarin.Android.Arch.Lifecycle.Common.1.1.1.1\lib\monoandroid80\Xamarin.Android.Arch.Lifecycle.Common.dll</HintPath>
 68 |       <Private>True</Private>
 69 |     </Reference>
 70 |     <Reference Include="Xamarin.Android.Arch.Lifecycle.Runtime, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
 71 |       <HintPath>..\packages\Xamarin.Android.Arch.Lifecycle.Runtime.1.1.1.1\lib\monoandroid80\Xamarin.Android.Arch.Lifecycle.Runtime.dll</HintPath>
 72 |       <Private>True</Private>
 73 |     </Reference>
 74 |     <Reference Include="Xamarin.Android.Support.Animated.Vector.Drawable, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
 75 |       <HintPath>..\packages\Xamarin.Android.Support.Animated.Vector.Drawable.28.0.0.1\lib\monoandroid80\Xamarin.Android.Support.Animated.Vector.Drawable.dll</HintPath>
 76 |       <Private>True</Private>
 77 |     </Reference>
 78 |     <Reference Include="Xamarin.Android.Support.Annotations, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
 79 |       <HintPath>..\packages\Xamarin.Android.Support.Annotations.28.0.0.1\lib\monoandroid80\Xamarin.Android.Support.Annotations.dll</HintPath>
 80 |       <Private>True</Private>
 81 |     </Reference>
 82 |     <Reference Include="Xamarin.Android.Support.Compat, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
 83 |       <HintPath>..\packages\Xamarin.Android.Support.Compat.28.0.0.1\lib\monoandroid80\Xamarin.Android.Support.Compat.dll</HintPath>
 84 |       <Private>True</Private>
 85 |     </Reference>
 86 |     <Reference Include="Xamarin.Android.Support.Core.UI, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
 87 |       <HintPath>..\packages\Xamarin.Android.Support.Core.UI.28.0.0.1\lib\monoandroid80\Xamarin.Android.Support.Core.UI.dll</HintPath>
 88 |       <Private>True</Private>
 89 |     </Reference>
 90 |     <Reference Include="Xamarin.Android.Support.Core.Utils, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
 91 |       <HintPath>..\packages\Xamarin.Android.Support.Core.Utils.28.0.0.1\lib\monoandroid80\Xamarin.Android.Support.Core.Utils.dll</HintPath>
 92 |       <Private>True</Private>
 93 |     </Reference>
 94 |     <Reference Include="Xamarin.Android.Support.Design, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
 95 |       <HintPath>..\packages\Xamarin.Android.Support.Design.28.0.0.1\lib\monoandroid80\Xamarin.Android.Support.Design.dll</HintPath>
 96 |       <Private>True</Private>
 97 |     </Reference>
 98 |     <Reference Include="Xamarin.Android.Support.Fragment, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
 99 |       <HintPath>..\packages\Xamarin.Android.Support.Fragment.28.0.0.1\lib\monoandroid80\Xamarin.Android.Support.Fragment.dll</HintPath>
100 |       <Private>True</Private>
101 |     </Reference>
102 |     <Reference Include="Xamarin.Android.Support.Media.Compat, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
103 |       <HintPath>..\packages\Xamarin.Android.Support.Media.Compat.28.0.0.1\lib\monoandroid80\Xamarin.Android.Support.Media.Compat.dll</HintPath>
104 |       <Private>True</Private>
105 |     </Reference>
106 |     <Reference Include="Xamarin.Android.Support.Transition, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
107 |       <HintPath>..\packages\Xamarin.Android.Support.Transition.28.0.0.1\lib\monoandroid80\Xamarin.Android.Support.Transition.dll</HintPath>
108 |       <Private>True</Private>
109 |     </Reference>
110 |     <Reference Include="Xamarin.Android.Support.v7.AppCompat, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
111 |       <HintPath>..\packages\Xamarin.Android.Support.v7.AppCompat.28.0.0.1\lib\monoandroid80\Xamarin.Android.Support.v7.AppCompat.dll</HintPath>
112 |       <Private>True</Private>
113 |     </Reference>
114 |     <Reference Include="Xamarin.Android.Support.v7.RecyclerView, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
115 |       <HintPath>..\packages\Xamarin.Android.Support.v7.RecyclerView.28.0.0.1\lib\monoandroid80\Xamarin.Android.Support.v7.RecyclerView.dll</HintPath>
116 |       <Private>True</Private>
117 |     </Reference>
118 |     <Reference Include="Xamarin.Android.Support.Vector.Drawable, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
119 |       <HintPath>..\packages\Xamarin.Android.Support.Vector.Drawable.28.0.0.1\lib\monoandroid80\Xamarin.Android.Support.Vector.Drawable.dll</HintPath>
120 |       <Private>True</Private>
121 |     </Reference>
122 |   </ItemGroup>
123 |   <ItemGroup>
124 |     <Compile Include="MainActivity.cs" />
125 |     <Compile Include="Resources\Resource.designer.cs" />
126 |     <Compile Include="Properties\AssemblyInfo.cs" />
127 |     <Compile Include="VPNService\ByteBufferPool.cs" />
128 |     <Compile Include="VPNService\LocalVPNService.cs" />
129 |     <Compile Include="VPNService\LRUCache.cs" />
130 |     <Compile Include="VPNService\Packet.cs" />
131 |     <Compile Include="VPNService\TCB.cs" />
132 |     <Compile Include="VPNService\TCPInput.cs" />
133 |     <Compile Include="VPNService\TCPOutput.cs" />
134 |     <Compile Include="VPNService\UDPInput.cs" />
135 |     <Compile Include="VPNService\UDPOutput.cs" />
136 |   </ItemGroup>
137 |   <ItemGroup>
138 |     <None Include="packages.config" />
139 |     <None Include="Resources\AboutResources.txt" />
140 |     <None Include="Properties\AndroidManifest.xml">
141 |       <SubType>Designer</SubType>
142 |     </None>
143 |     <None Include="Assets\AboutAssets.txt" />
144 |   </ItemGroup>
145 |   <ItemGroup>
146 |     <AndroidResource Include="Resources\layout\activity_main.axml">
147 |       <SubType>Designer</SubType>
148 |     </AndroidResource>
149 |     <AndroidResource Include="Resources\values\colors.xml" />
150 |     <AndroidResource Include="Resources\values\dimens.xml" />
151 |     <AndroidResource Include="Resources\values\ic_launcher_background.xml" />
152 |     <AndroidResource Include="Resources\values\strings.xml" />
153 |     <AndroidResource Include="Resources\values\styles.xml" />
154 |     <AndroidResource Include="Resources\mipmap-anydpi-v26\ic_launcher.xml" />
155 |     <AndroidResource Include="Resources\mipmap-anydpi-v26\ic_launcher_round.xml" />
156 |     <AndroidResource Include="Resources\mipmap-hdpi\ic_launcher.png" />
157 |     <AndroidResource Include="Resources\mipmap-hdpi\ic_launcher_foreground.png" />
158 |     <AndroidResource Include="Resources\mipmap-hdpi\ic_launcher_round.png" />
159 |     <AndroidResource Include="Resources\mipmap-mdpi\ic_launcher.png" />
160 |     <AndroidResource Include="Resources\mipmap-mdpi\ic_launcher_foreground.png" />
161 |     <AndroidResource Include="Resources\mipmap-mdpi\ic_launcher_round.png" />
162 |     <AndroidResource Include="Resources\mipmap-xhdpi\ic_launcher.png" />
163 |     <AndroidResource Include="Resources\mipmap-xhdpi\ic_launcher_foreground.png" />
164 |     <AndroidResource Include="Resources\mipmap-xhdpi\ic_launcher_round.png" />
165 |     <AndroidResource Include="Resources\mipmap-xxhdpi\ic_launcher.png" />
166 |     <AndroidResource Include="Resources\mipmap-xxhdpi\ic_launcher_foreground.png" />
167 |     <AndroidResource Include="Resources\mipmap-xxhdpi\ic_launcher_round.png" />
168 |     <AndroidResource Include="Resources\mipmap-xxxhdpi\ic_launcher.png" />
169 |     <AndroidResource Include="Resources\mipmap-xxxhdpi\ic_launcher_foreground.png" />
170 |     <AndroidResource Include="Resources\mipmap-xxxhdpi\ic_launcher_round.png" />
171 |   </ItemGroup>
172 |   <Import Project="$(MSBuildExtensionsPath)\Xamarin\Android\Xamarin.Android.CSharp.targets" />
173 |   <Import Project="..\packages\Xamarin.Android.Support.Annotations.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Annotations.targets" Condition="Exists('..\packages\Xamarin.Android.Support.Annotations.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Annotations.targets')" />
174 |   <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
175 |     <PropertyGroup>
176 |       <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
177 |     </PropertyGroup>
178 |     <Error Condition="!Exists('..\packages\Xamarin.Android.Support.Annotations.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Annotations.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Xamarin.Android.Support.Annotations.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Annotations.targets'))" />
179 |     <Error Condition="!Exists('..\packages\Xamarin.Android.Arch.Core.Common.1.1.1.1\build\monoandroid80\Xamarin.Android.Arch.Core.Common.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Xamarin.Android.Arch.Core.Common.1.1.1.1\build\monoandroid80\Xamarin.Android.Arch.Core.Common.targets'))" />
180 |     <Error Condition="!Exists('..\packages\Xamarin.Android.Arch.Lifecycle.Common.1.1.1.1\build\monoandroid80\Xamarin.Android.Arch.Lifecycle.Common.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Xamarin.Android.Arch.Lifecycle.Common.1.1.1.1\build\monoandroid80\Xamarin.Android.Arch.Lifecycle.Common.targets'))" />
181 |     <Error Condition="!Exists('..\packages\Xamarin.Android.Arch.Lifecycle.Runtime.1.1.1.1\build\monoandroid80\Xamarin.Android.Arch.Lifecycle.Runtime.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Xamarin.Android.Arch.Lifecycle.Runtime.1.1.1.1\build\monoandroid80\Xamarin.Android.Arch.Lifecycle.Runtime.targets'))" />
182 |     <Error Condition="!Exists('..\packages\Xamarin.Android.Support.Compat.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Compat.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Xamarin.Android.Support.Compat.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Compat.targets'))" />
183 |     <Error Condition="!Exists('..\packages\Xamarin.Android.Support.Core.UI.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Core.UI.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Xamarin.Android.Support.Core.UI.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Core.UI.targets'))" />
184 |     <Error Condition="!Exists('..\packages\Xamarin.Android.Support.Core.Utils.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Core.Utils.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Xamarin.Android.Support.Core.Utils.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Core.Utils.targets'))" />
185 |     <Error Condition="!Exists('..\packages\Xamarin.Android.Support.Fragment.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Fragment.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Xamarin.Android.Support.Fragment.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Fragment.targets'))" />
186 |     <Error Condition="!Exists('..\packages\Xamarin.Android.Support.Media.Compat.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Media.Compat.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Xamarin.Android.Support.Media.Compat.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Media.Compat.targets'))" />
187 |     <Error Condition="!Exists('..\packages\Xamarin.Android.Support.Transition.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Transition.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Xamarin.Android.Support.Transition.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Transition.targets'))" />
188 |     <Error Condition="!Exists('..\packages\Xamarin.Android.Support.v7.RecyclerView.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.v7.RecyclerView.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Xamarin.Android.Support.v7.RecyclerView.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.v7.RecyclerView.targets'))" />
189 |     <Error Condition="!Exists('..\packages\Xamarin.Android.Support.Vector.Drawable.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Vector.Drawable.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Xamarin.Android.Support.Vector.Drawable.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Vector.Drawable.targets'))" />
190 |     <Error Condition="!Exists('..\packages\Xamarin.Android.Support.Animated.Vector.Drawable.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Animated.Vector.Drawable.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Xamarin.Android.Support.Animated.Vector.Drawable.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Animated.Vector.Drawable.targets'))" />
191 |     <Error Condition="!Exists('..\packages\Xamarin.Android.Support.v7.AppCompat.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.v7.AppCompat.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Xamarin.Android.Support.v7.AppCompat.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.v7.AppCompat.targets'))" />
192 |     <Error Condition="!Exists('..\packages\Xamarin.Android.Support.Design.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Design.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Xamarin.Android.Support.Design.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Design.targets'))" />
193 |   </Target>
194 |   <Import Project="..\packages\Xamarin.Android.Arch.Core.Common.1.1.1.1\build\monoandroid80\Xamarin.Android.Arch.Core.Common.targets" Condition="Exists('..\packages\Xamarin.Android.Arch.Core.Common.1.1.1.1\build\monoandroid80\Xamarin.Android.Arch.Core.Common.targets')" />
195 |   <Import Project="..\packages\Xamarin.Android.Arch.Lifecycle.Common.1.1.1.1\build\monoandroid80\Xamarin.Android.Arch.Lifecycle.Common.targets" Condition="Exists('..\packages\Xamarin.Android.Arch.Lifecycle.Common.1.1.1.1\build\monoandroid80\Xamarin.Android.Arch.Lifecycle.Common.targets')" />
196 |   <Import Project="..\packages\Xamarin.Android.Arch.Lifecycle.Runtime.1.1.1.1\build\monoandroid80\Xamarin.Android.Arch.Lifecycle.Runtime.targets" Condition="Exists('..\packages\Xamarin.Android.Arch.Lifecycle.Runtime.1.1.1.1\build\monoandroid80\Xamarin.Android.Arch.Lifecycle.Runtime.targets')" />
197 |   <Import Project="..\packages\Xamarin.Android.Support.Compat.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Compat.targets" Condition="Exists('..\packages\Xamarin.Android.Support.Compat.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Compat.targets')" />
198 |   <Import Project="..\packages\Xamarin.Android.Support.Core.UI.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Core.UI.targets" Condition="Exists('..\packages\Xamarin.Android.Support.Core.UI.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Core.UI.targets')" />
199 |   <Import Project="..\packages\Xamarin.Android.Support.Core.Utils.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Core.Utils.targets" Condition="Exists('..\packages\Xamarin.Android.Support.Core.Utils.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Core.Utils.targets')" />
200 |   <Import Project="..\packages\Xamarin.Android.Support.Fragment.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Fragment.targets" Condition="Exists('..\packages\Xamarin.Android.Support.Fragment.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Fragment.targets')" />
201 |   <Import Project="..\packages\Xamarin.Android.Support.Media.Compat.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Media.Compat.targets" Condition="Exists('..\packages\Xamarin.Android.Support.Media.Compat.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Media.Compat.targets')" />
202 |   <Import Project="..\packages\Xamarin.Android.Support.Transition.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Transition.targets" Condition="Exists('..\packages\Xamarin.Android.Support.Transition.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Transition.targets')" />
203 |   <Import Project="..\packages\Xamarin.Android.Support.v7.RecyclerView.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.v7.RecyclerView.targets" Condition="Exists('..\packages\Xamarin.Android.Support.v7.RecyclerView.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.v7.RecyclerView.targets')" />
204 |   <Import Project="..\packages\Xamarin.Android.Support.Vector.Drawable.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Vector.Drawable.targets" Condition="Exists('..\packages\Xamarin.Android.Support.Vector.Drawable.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Vector.Drawable.targets')" />
205 |   <Import Project="..\packages\Xamarin.Android.Support.Animated.Vector.Drawable.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Animated.Vector.Drawable.targets" Condition="Exists('..\packages\Xamarin.Android.Support.Animated.Vector.Drawable.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Animated.Vector.Drawable.targets')" />
206 |   <Import Project="..\packages\Xamarin.Android.Support.v7.AppCompat.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.v7.AppCompat.targets" Condition="Exists('..\packages\Xamarin.Android.Support.v7.AppCompat.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.v7.AppCompat.targets')" />
207 |   <Import Project="..\packages\Xamarin.Android.Support.Design.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Design.targets" Condition="Exists('..\packages\Xamarin.Android.Support.Design.28.0.0.1\build\monoandroid80\Xamarin.Android.Support.Design.targets')" />
208 |   <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
209 |     Other similar extension points exist, see Microsoft.Common.targets.
210 |     <Target Name="BeforeBuild">
211 |     </Target>
212 |     <Target Name="AfterBuild">
213 |     </Target>
214 |   -->
215 | </Project>


--------------------------------------------------------------------------------