helpy4/Minecraft-Console-Client
1
0
Fork 0
mirror of https://github.com/MCCTeam/Minecraft-Console-Client synced 2025-11-07 17:36:07 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

.NET 5+ Support (#1674)

Browse source 
Implement changes to support .NET 5 onwards.
Co-authored-by: ReinforceZwei <39955851+ReinforceZwei@users.noreply.github.com>
Co-authored-by: ORelio <ORelio@users.noreply.github.com>
This commit is contained in:
breadbyte 2022-07-03 22:34:07 +08:00 • committed by GitHub
parent b3cc2351ee
commit d9f1a77ac2
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
117 changed files with 1028 additions and 9058 deletions
Download patch file Download diff file Expand all files Collapse all files

4
MinecraftClient/.gitignore vendored
View file

@ -1,4 +0,0 @@
/bin/
/obj/
MinecraftClient.sln
MinecraftClient.v11.suo

9
MinecraftClient/AutoTimeout.cs
View file

@ -1,5 +1,7 @@
using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;
namespace MinecraftClient
{
@ -28,13 +30,14 @@ namespace MinecraftClient
/// <param name="action">Action to run</param>
/// <param name="timeout">Maximum timeout</param>
/// <returns>True if the action finished whithout timing out</returns>
public static bool Perform(Action action, TimeSpan timeout)
{
public static bool Perform(Action action, TimeSpan timeout) {
Thread thread = new Thread(new ThreadStart(action));
thread.Start();
bool success = thread.Join(timeout);
if (!success)
thread.Abort();
thread.Interrupt();
thread = null;
return success;
}
}

33
MinecraftClient/ChatBots/Alerts.cs
View file

@ -41,38 +41,7 @@ namespace MinecraftClient.ChatBots
if (Settings.Alerts_Beep_Enabled)
Console.Beep(); //Text found !
if (ConsoleIO.BasicIO) //Using a GUI? Pass text as is.
ConsoleIO.WriteLine(text.Replace(alert, "§c" + alert + "§r"));
else //Using Console Prompt : Print text with alert highlighted
{
string[] splitted = text.Split(new string[] { alert }, StringSplitOptions.None);
ConsoleColor fore = Console.ForegroundColor;
ConsoleColor back = Console.BackgroundColor;
if (splitted.Length > 0)
{
Console.BackgroundColor = ConsoleColor.DarkGray;
Console.ForegroundColor = ConsoleColor.White;
ConsoleIO.Write(splitted[0]);
for (int i = 1; i < splitted.Length; i++)
{
Console.BackgroundColor = ConsoleColor.Yellow;
Console.ForegroundColor = ConsoleColor.Red;
ConsoleIO.Write(alert);
Console.BackgroundColor = ConsoleColor.DarkGray;
Console.ForegroundColor = ConsoleColor.White;
ConsoleIO.Write(splitted[i]);
}
}
Console.BackgroundColor = back;
Console.ForegroundColor = fore;
ConsoleIO.Write('\n');
}
ConsoleIO.WriteLine(text.Replace(alert, "§c" + alert + "§r"));
}
}
}

3
MinecraftClient/ChatBots/Script.cs
View file

@ -7,6 +7,7 @@ using Microsoft.CSharp;
using System.CodeDom.Compiler;
using System.Reflection;
using System.Diagnostics;
using System.IO;
namespace MinecraftClient.ChatBots
{
@ -86,7 +87,7 @@ namespace MinecraftClient.ChatBots
public static bool LookForScript(ref string filename)
{
//Automatically look in subfolders and try to add ".txt" file extension
char dir_slash = Program.isUsingMono ? '/' : '\\';
char dir_slash = Path.DirectorySeparatorChar;
string[] files = new string[]
{
filename,

426
MinecraftClient/ConsoleIO.cs
View file

@ -2,7 +2,6 @@
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Threading;
namespace MinecraftClient
@ -16,27 +15,13 @@ namespace MinecraftClient
public static class ConsoleIO
{
private static IAutoComplete autocomplete_engine;
private static LinkedList<string> autocomplete_words = new LinkedList<string>();
private static LinkedList<string> previous = new LinkedList<string>();
private static readonly object io_lock = new object();
private static bool reading = false;
private static string buffer = "";
private static string buffer2 = "";
/// <summary>
/// Reset the IO mechanism and clear all buffers
/// </summary>
public static void Reset()
{
lock (io_lock)
{
if (reading)
{
ClearLineAndBuffer();
reading = false;
Console.Write("\b \b");
}
}
ClearLineAndBuffer();
}
/// <summary>
@ -75,44 +60,15 @@ namespace MinecraftClient
/// </summary>
public static string ReadPassword()
{
StringBuilder password = new StringBuilder();
ConsoleKeyInfo k;
while ((k = Console.ReadKey(true)).Key != ConsoleKey.Enter)
if (BasicIO)
return Console.ReadLine();
else
{
switch (k.Key)
{
case ConsoleKey.Backspace:
if (password.Length > 0)
{
Console.Write("\b \b");
password.Remove(password.Length - 1, 1);
}
break;
case ConsoleKey.Escape:
case ConsoleKey.LeftArrow:
case ConsoleKey.RightArrow:
case ConsoleKey.Home:
case ConsoleKey.End:
case ConsoleKey.Delete:
case ConsoleKey.DownArrow:
case ConsoleKey.UpArrow:
case ConsoleKey.Tab:
break;
default:
if (k.KeyChar != 0)
{
Console.Write('*');
password.Append(k.KeyChar);
}
break;
}
ConsoleInteractive.ConsoleReader.SetInputVisible(false);
var input = ConsoleInteractive.ConsoleReader.RequestImmediateInput();
ConsoleInteractive.ConsoleReader.SetInputVisible(true);
return input;
}
Console.WriteLine();
return password.ToString();
}
/// <summary>
@ -121,117 +77,9 @@ namespace MinecraftClient
public static string ReadLine()
{
if (BasicIO)
{
return Console.ReadLine();
}
ConsoleKeyInfo k = new ConsoleKeyInfo();
lock (io_lock)
{
Console.Write('>');
reading = true;
buffer = "";
buffer2 = "";
}
while (k.Key != ConsoleKey.Enter)
{
k = Console.ReadKey(true);
lock (io_lock)
{
if (k.Key == ConsoleKey.V && k.Modifiers == ConsoleModifiers.Control)
{
string clip = ReadClipboard();
foreach (char c in clip)
AddChar(c);
}
else
{
switch (k.Key)
{
case ConsoleKey.Escape:
ClearLineAndBuffer();
break;
case ConsoleKey.Backspace:
RemoveOneChar();
break;
case ConsoleKey.Enter:
Console.Write('\n');
break;
case ConsoleKey.LeftArrow:
GoLeft();
break;
case ConsoleKey.RightArrow:
GoRight();
break;
case ConsoleKey.Home:
while (buffer.Length > 0) { GoLeft(); }
break;
case ConsoleKey.End:
while (buffer2.Length > 0) { GoRight(); }
break;
case ConsoleKey.Delete:
if (buffer2.Length > 0)
{
GoRight();
RemoveOneChar();
}
break;
case ConsoleKey.DownArrow:
if (previous.Count > 0)
{
ClearLineAndBuffer();
buffer = previous.First.Value;
previous.AddLast(buffer);
previous.RemoveFirst();
Console.Write(buffer);
}
break;
case ConsoleKey.UpArrow:
if (previous.Count > 0)
{
ClearLineAndBuffer();
buffer = previous.Last.Value;
previous.AddFirst(buffer);
previous.RemoveLast();
Console.Write(buffer);
}
break;
case ConsoleKey.Tab:
if (autocomplete_words.Count == 0 && autocomplete_engine != null && buffer.Length > 0)
foreach (string result in autocomplete_engine.AutoComplete(buffer))
autocomplete_words.AddLast(result);
string word_autocomplete = null;
if (autocomplete_words.Count > 0)
{
word_autocomplete = autocomplete_words.First.Value;
autocomplete_words.RemoveFirst();
autocomplete_words.AddLast(word_autocomplete);
}
if (!String.IsNullOrEmpty(word_autocomplete) && word_autocomplete != buffer)
{
while (buffer.Length > 0 && buffer[buffer.Length - 1] != ' ') { RemoveOneChar(); }
foreach (char c in word_autocomplete) { AddChar(c); }
}
break;
default:
if (k.KeyChar != 0)
AddChar(k.KeyChar);
break;
}
}
if (k.Key != ConsoleKey.Tab)
autocomplete_words.Clear();
}
}
lock (io_lock)
{
reading = false;
previous.AddLast(buffer + buffer2);
return buffer + buffer2;
}
else
return ConsoleInteractive.ConsoleReader.RequestImmediateInput();
}
/// <summary>
@ -247,68 +95,15 @@ namespace MinecraftClient
}
}
/// <summary>
/// Write a string to the standard output, without newline character
/// </summary>
public static void Write(string text)
{
if (!BasicIO)
{
lock (io_lock)
{
if (reading)
{
try
{
string buf = buffer;
string buf2 = buffer2;
ClearLineAndBuffer();
if (Console.CursorLeft == 0)
{
Console.CursorLeft = Console.BufferWidth - 1;
Console.CursorTop--;
Console.Write(' ');
Console.CursorLeft = Console.BufferWidth - 1;
Console.CursorTop--;
}
else Console.Write("\b \b");
Console.Write(text);
buffer = buf;
buffer2 = buf2;
Console.Write(">" + buffer);
if (buffer2.Length > 0)
{
Console.Write(buffer2 + " \b");
for (int i = 0; i < buffer2.Length; i++) { GoBack(); }
}
}
catch (ArgumentOutOfRangeException)
{
//Console resized: Try again
Console.Write('\n');
Write(text);
}
}
else Console.Write(text);
}
}
else Console.Write(text);
}
/// <summary>
/// Write a string to the standard output with a trailing newline
/// </summary>
public static void WriteLine(string line)
{
Write(line + '\n');
}
/// <summary>
/// Write a single character to the standard output
/// </summary>
public static void Write(char c)
{
Write("" + c);
if (BasicIO)
Console.WriteLine(line);
else
ConsoleInteractive.ConsoleWriter.WriteLine(line);
}
/// <summary>
@ -322,71 +117,40 @@ namespace MinecraftClient
/// If true, "hh-mm-ss" timestamp will be prepended.
/// If unspecified, value is retrieved from EnableTimestamps.
/// </param>
public static void WriteLineFormatted(string str, bool acceptnewlines = true, bool? displayTimestamp = null)
public static void WriteLineFormatted(string str, bool acceptnewlines = false, bool? displayTimestamp = null)
{
StringBuilder output = new StringBuilder();
if (!String.IsNullOrEmpty(str))
{
if (!acceptnewlines)
if (!acceptnewlines)
{
str = str.Replace('\n', ' ');
output.Append(str.Replace('\n', ' '));
}
if (displayTimestamp == null)
else
{
output.Append(str);
}
if (displayTimestamp == null)
{
displayTimestamp = EnableTimestamps;
}
if (displayTimestamp.Value)
if (displayTimestamp.Value)
{
int hour = DateTime.Now.Hour, minute = DateTime.Now.Minute, second = DateTime.Now.Second;
ConsoleIO.Write(String.Format("{0}:{1}:{2} ", hour.ToString("00"), minute.ToString("00"), second.ToString("00")));
output.Append(String.Format("{0}:{1}:{2} ", hour.ToString("00"), minute.ToString("00"), second.ToString("00")));
}
if (BasicIO)
{
if (BasicIO_NoColor)
{
str = ChatBot.GetVerbatim(str);
output.Append(ChatBot.GetVerbatim(str));
}
Console.WriteLine(str);
Console.WriteLine(output.ToString());
return;
}
string[] parts = str.Split(new char[] { '§' });
if (parts[0].Length > 0)
{
ConsoleIO.Write(parts[0]);
}
for (int i = 1; i < parts.Length; i++)
{
if (parts[i].Length > 0)
{
switch (parts[i][0])
{
case '0': Console.ForegroundColor = ConsoleColor.Gray; break; //Should be Black but Black is non-readable on a black background
case '1': Console.ForegroundColor = ConsoleColor.DarkBlue; break;
case '2': Console.ForegroundColor = ConsoleColor.DarkGreen; break;
case '3': Console.ForegroundColor = ConsoleColor.DarkCyan; break;
case '4': Console.ForegroundColor = ConsoleColor.DarkRed; break;
case '5': Console.ForegroundColor = ConsoleColor.DarkMagenta; break;
case '6': Console.ForegroundColor = ConsoleColor.DarkYellow; break;
case '7': Console.ForegroundColor = ConsoleColor.Gray; break;
case '8': Console.ForegroundColor = ConsoleColor.DarkGray; break;
case '9': Console.ForegroundColor = ConsoleColor.Blue; break;
case 'a': Console.ForegroundColor = ConsoleColor.Green; break;
case 'b': Console.ForegroundColor = ConsoleColor.Cyan; break;
case 'c': Console.ForegroundColor = ConsoleColor.Red; break;
case 'd': Console.ForegroundColor = ConsoleColor.Magenta; break;
case 'e': Console.ForegroundColor = ConsoleColor.Yellow; break;
case 'f': Console.ForegroundColor = ConsoleColor.White; break;
case 'r': Console.ForegroundColor = ConsoleColor.Gray; break;
}
if (parts[i].Length > 1)
{
ConsoleIO.Write(parts[i].Substring(1, parts[i].Length - 1));
}
}
}
Console.ForegroundColor = ConsoleColor.Gray;
ConsoleInteractive.ConsoleWriter.WriteLineFormatted(output.ToString());
}
ConsoleIO.Write('\n');
}
/// <summary>
@ -408,135 +172,23 @@ namespace MinecraftClient
/// </summary>
private static void ClearLineAndBuffer()
{
while (buffer2.Length > 0)
{
GoRight();
}
while (buffer.Length > 0)
{
RemoveOneChar();
}
if (BasicIO) return;
ConsoleInteractive.ConsoleReader.ClearBuffer();
}
/// <summary>
/// Remove one character on the left of the cursor in input prompt
/// </summary>
private static void RemoveOneChar()
{
if (buffer.Length > 0)
{
try
{
GoBack();
Console.Write(' ');
GoBack();
}
catch (ArgumentOutOfRangeException) { /* Console was resized!? */ }
buffer = buffer.Substring(0, buffer.Length - 1);
if (buffer2.Length > 0)
{
Console.Write(buffer2);
Console.Write(' ');
GoBack();
for (int i = 0; i < buffer2.Length; i++)
{
GoBack();
}
}
}
}
/// <summary>
/// Move the cursor one character to the left inside the console, regardless of input prompt state
/// </summary>
private static void GoBack()
{
try
{
if (Console.CursorLeft == 0)
{
Console.CursorLeft = Console.BufferWidth - 1;
if (Console.CursorTop > 0)
Console.CursorTop--;
}
else
{
Console.CursorLeft = Console.CursorLeft - 1;
}
}
catch (ArgumentOutOfRangeException) { /* Console was resized!? */ }
}
/// <summary>
/// Move the cursor one character to the left in input prompt, adjusting buffers accordingly
/// </summary>
private static void GoLeft()
{
if (buffer.Length > 0)
{
buffer2 = "" + buffer[buffer.Length - 1] + buffer2;
buffer = buffer.Substring(0, buffer.Length - 1);
GoBack();
}
}
/// <summary>
/// Move the cursor one character to the right in input prompt, adjusting buffers accordingly
/// </summary>
private static void GoRight()
{
if (buffer2.Length > 0)
{
buffer = buffer + buffer2[0];
Console.Write(buffer2[0]);
buffer2 = buffer2.Substring(1);
}
}
/// <summary>
/// Insert a new character in the input prompt
/// </summary>
/// <param name="c">New character</param>
private static void AddChar(char c)
{
Console.Write(c);
buffer += c;
Console.Write(buffer2);
for (int i = 0; i < buffer2.Length; i++)
{
GoBack();
}
}
#endregion
#region Clipboard management
/// <summary>
/// Read a string from the Windows clipboard
/// </summary>
/// <returns>String from the Windows clipboard</returns>
private static string ReadClipboard()
public static void AutocompleteHandler(object? sender, ConsoleKey e)
{
string clipdata = "";
Thread staThread = new Thread(new ThreadStart(
delegate
{
try
{
clipdata = Clipboard.GetText();
}
catch { }
}
));
staThread.SetApartmentState(ApartmentState.STA);
staThread.Start();
staThread.Join();
return clipdata;
if (e != ConsoleKey.Tab) return;
if (autocomplete_engine == null)
return;
var buffer = ConsoleInteractive.ConsoleReader.GetBufferContent();
autocomplete_engine.AutoComplete(buffer.Text[..buffer.CursorPosition]);
}
#endregion
}
/// <summary>

6
MinecraftClient/Crypto/CryptoHandler.cs
View file

@ -201,11 +201,7 @@ namespace MinecraftClient.Crypto
public static IAesStream getAesStream(Stream underlyingStream, byte[] AesKey)
{
if (Program.isUsingMono)
{
return new Streams.MonoAesStream(underlyingStream, AesKey);
}
else return new Streams.RegularAesStream(underlyingStream, AesKey);
return new Streams.RegularAesStream(underlyingStream, AesKey);
}
}
}

855
MinecraftClient/Crypto/Streams/BouncyAes/AesFastEngine.cs
View file

@ -1,855 +0,0 @@
using System;
using System.Diagnostics;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Crypto.Utilities;
namespace Org.BouncyCastle.Crypto.Engines
{
/**
* an implementation of the AES (Rijndael)), from FIPS-197.
* <p>
* For further details see: <a href="http://csrc.nist.gov/encryption/aes/">http://csrc.nist.gov/encryption/aes/</a>.
*
* This implementation is based on optimizations from Dr. Brian Gladman's paper and C code at
* <a href="http://fp.gladman.plus.com/cryptography_technology/rijndael/">http://fp.gladman.plus.com/cryptography_technology/rijndael/</a>
*
* There are three levels of tradeoff of speed vs memory
* Because java has no preprocessor), they are written as three separate classes from which to choose
*
* The fastest uses 8Kbytes of static tables to precompute round calculations), 4 256 word tables for encryption
* and 4 for decryption.
*
* The middle performance version uses only one 256 word table for each), for a total of 2Kbytes),
* adding 12 rotate operations per round to compute the values contained in the other tables from
* the contents of the first
*
* The slowest version uses no static tables at all and computes the values in each round
* </p>
* <p>
* This file contains the fast version with 8Kbytes of static tables for round precomputation
* </p>
*/
public class AesFastEngine
: IBlockCipher
{
// The S box
private static readonly byte[] S =
{
99, 124, 119, 123, 242, 107, 111, 197,
48, 1, 103, 43, 254, 215, 171, 118,
202, 130, 201, 125, 250, 89, 71, 240,
173, 212, 162, 175, 156, 164, 114, 192,
183, 253, 147, 38, 54, 63, 247, 204,
52, 165, 229, 241, 113, 216, 49, 21,
4, 199, 35, 195, 24, 150, 5, 154,
7, 18, 128, 226, 235, 39, 178, 117,
9, 131, 44, 26, 27, 110, 90, 160,
82, 59, 214, 179, 41, 227, 47, 132,
83, 209, 0, 237, 32, 252, 177, 91,
106, 203, 190, 57, 74, 76, 88, 207,
208, 239, 170, 251, 67, 77, 51, 133,
69, 249, 2, 127, 80, 60, 159, 168,
81, 163, 64, 143, 146, 157, 56, 245,
188, 182, 218, 33, 16, 255, 243, 210,
205, 12, 19, 236, 95, 151, 68, 23,
196, 167, 126, 61, 100, 93, 25, 115,
96, 129, 79, 220, 34, 42, 144, 136,
70, 238, 184, 20, 222, 94, 11, 219,
224, 50, 58, 10, 73, 6, 36, 92,
194, 211, 172, 98, 145, 149, 228, 121,
231, 200, 55, 109, 141, 213, 78, 169,
108, 86, 244, 234, 101, 122, 174, 8,
186, 120, 37, 46, 28, 166, 180, 198,
232, 221, 116, 31, 75, 189, 139, 138,
112, 62, 181, 102, 72, 3, 246, 14,
97, 53, 87, 185, 134, 193, 29, 158,
225, 248, 152, 17, 105, 217, 142, 148,
155, 30, 135, 233, 206, 85, 40, 223,
140, 161, 137, 13, 191, 230, 66, 104,
65, 153, 45, 15, 176, 84, 187, 22,
};
// The inverse S-box
private static readonly byte[] Si =
{
82, 9, 106, 213, 48, 54, 165, 56,
191, 64, 163, 158, 129, 243, 215, 251,
124, 227, 57, 130, 155, 47, 255, 135,
52, 142, 67, 68, 196, 222, 233, 203,
84, 123, 148, 50, 166, 194, 35, 61,
238, 76, 149, 11, 66, 250, 195, 78,
8, 46, 161, 102, 40, 217, 36, 178,
118, 91, 162, 73, 109, 139, 209, 37,
114, 248, 246, 100, 134, 104, 152, 22,
212, 164, 92, 204, 93, 101, 182, 146,
108, 112, 72, 80, 253, 237, 185, 218,
94, 21, 70, 87, 167, 141, 157, 132,
144, 216, 171, 0, 140, 188, 211, 10,
247, 228, 88, 5, 184, 179, 69, 6,
208, 44, 30, 143, 202, 63, 15, 2,
193, 175, 189, 3, 1, 19, 138, 107,
58, 145, 17, 65, 79, 103, 220, 234,
151, 242, 207, 206, 240, 180, 230, 115,
150, 172, 116, 34, 231, 173, 53, 133,
226, 249, 55, 232, 28, 117, 223, 110,
71, 241, 26, 113, 29, 41, 197, 137,
111, 183, 98, 14, 170, 24, 190, 27,
252, 86, 62, 75, 198, 210, 121, 32,
154, 219, 192, 254, 120, 205, 90, 244,
31, 221, 168, 51, 136, 7, 199, 49,
177, 18, 16, 89, 39, 128, 236, 95,
96, 81, 127, 169, 25, 181, 74, 13,
45, 229, 122, 159, 147, 201, 156, 239,
160, 224, 59, 77, 174, 42, 245, 176,
200, 235, 187, 60, 131, 83, 153, 97,
23, 43, 4, 126, 186, 119, 214, 38,
225, 105, 20, 99, 85, 33, 12, 125,
};
// vector used in calculating key schedule (powers of x in GF(256))
private static readonly byte[] rcon =
{
0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a,
0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91
};
// precomputation tables of calculations for rounds
private static readonly uint[] T0 =
{
0xa56363c6, 0x847c7cf8, 0x997777ee, 0x8d7b7bf6, 0x0df2f2ff,
0xbd6b6bd6, 0xb16f6fde, 0x54c5c591, 0x50303060, 0x03010102,
0xa96767ce, 0x7d2b2b56, 0x19fefee7, 0x62d7d7b5, 0xe6abab4d,
0x9a7676ec, 0x45caca8f, 0x9d82821f, 0x40c9c989, 0x877d7dfa,
0x15fafaef, 0xeb5959b2, 0xc947478e, 0x0bf0f0fb, 0xecadad41,
0x67d4d4b3, 0xfda2a25f, 0xeaafaf45, 0xbf9c9c23, 0xf7a4a453,
0x967272e4, 0x5bc0c09b, 0xc2b7b775, 0x1cfdfde1, 0xae93933d,
0x6a26264c, 0x5a36366c, 0x413f3f7e, 0x02f7f7f5, 0x4fcccc83,
0x5c343468, 0xf4a5a551, 0x34e5e5d1, 0x08f1f1f9, 0x937171e2,
0x73d8d8ab, 0x53313162, 0x3f15152a, 0x0c040408, 0x52c7c795,
0x65232346, 0x5ec3c39d, 0x28181830, 0xa1969637, 0x0f05050a,
0xb59a9a2f, 0x0907070e, 0x36121224, 0x9b80801b, 0x3de2e2df,
0x26ebebcd, 0x6927274e, 0xcdb2b27f, 0x9f7575ea, 0x1b090912,
0x9e83831d, 0x742c2c58, 0x2e1a1a34, 0x2d1b1b36, 0xb26e6edc,
0xee5a5ab4, 0xfba0a05b, 0xf65252a4, 0x4d3b3b76, 0x61d6d6b7,
0xceb3b37d, 0x7b292952, 0x3ee3e3dd, 0x712f2f5e, 0x97848413,
0xf55353a6, 0x68d1d1b9, 0x00000000, 0x2cededc1, 0x60202040,
0x1ffcfce3, 0xc8b1b179, 0xed5b5bb6, 0xbe6a6ad4, 0x46cbcb8d,
0xd9bebe67, 0x4b393972, 0xde4a4a94, 0xd44c4c98, 0xe85858b0,
0x4acfcf85, 0x6bd0d0bb, 0x2aefefc5, 0xe5aaaa4f, 0x16fbfbed,
0xc5434386, 0xd74d4d9a, 0x55333366, 0x94858511, 0xcf45458a,
0x10f9f9e9, 0x06020204, 0x817f7ffe, 0xf05050a0, 0x443c3c78,
0xba9f9f25, 0xe3a8a84b, 0xf35151a2, 0xfea3a35d, 0xc0404080,
0x8a8f8f05, 0xad92923f, 0xbc9d9d21, 0x48383870, 0x04f5f5f1,
0xdfbcbc63, 0xc1b6b677, 0x75dadaaf, 0x63212142, 0x30101020,
0x1affffe5, 0x0ef3f3fd, 0x6dd2d2bf, 0x4ccdcd81, 0x140c0c18,
0x35131326, 0x2fececc3, 0xe15f5fbe, 0xa2979735, 0xcc444488,
0x3917172e, 0x57c4c493, 0xf2a7a755, 0x827e7efc, 0x473d3d7a,
0xac6464c8, 0xe75d5dba, 0x2b191932, 0x957373e6, 0xa06060c0,
0x98818119, 0xd14f4f9e, 0x7fdcdca3, 0x66222244, 0x7e2a2a54,
0xab90903b, 0x8388880b, 0xca46468c, 0x29eeeec7, 0xd3b8b86b,
0x3c141428, 0x79dedea7, 0xe25e5ebc, 0x1d0b0b16, 0x76dbdbad,
0x3be0e0db, 0x56323264, 0x4e3a3a74, 0x1e0a0a14, 0xdb494992,
0x0a06060c, 0x6c242448, 0xe45c5cb8, 0x5dc2c29f, 0x6ed3d3bd,
0xefacac43, 0xa66262c4, 0xa8919139, 0xa4959531, 0x37e4e4d3,
0x8b7979f2, 0x32e7e7d5, 0x43c8c88b, 0x5937376e, 0xb76d6dda,
0x8c8d8d01, 0x64d5d5b1, 0xd24e4e9c, 0xe0a9a949, 0xb46c6cd8,
0xfa5656ac, 0x07f4f4f3, 0x25eaeacf, 0xaf6565ca, 0x8e7a7af4,
0xe9aeae47, 0x18080810, 0xd5baba6f, 0x887878f0, 0x6f25254a,
0x722e2e5c, 0x241c1c38, 0xf1a6a657, 0xc7b4b473, 0x51c6c697,
0x23e8e8cb, 0x7cdddda1, 0x9c7474e8, 0x211f1f3e, 0xdd4b4b96,
0xdcbdbd61, 0x868b8b0d, 0x858a8a0f, 0x907070e0, 0x423e3e7c,
0xc4b5b571, 0xaa6666cc, 0xd8484890, 0x05030306, 0x01f6f6f7,
0x120e0e1c, 0xa36161c2, 0x5f35356a, 0xf95757ae, 0xd0b9b969,
0x91868617, 0x58c1c199, 0x271d1d3a, 0xb99e9e27, 0x38e1e1d9,
0x13f8f8eb, 0xb398982b, 0x33111122, 0xbb6969d2, 0x70d9d9a9,
0x898e8e07, 0xa7949433, 0xb69b9b2d, 0x221e1e3c, 0x92878715,
0x20e9e9c9, 0x49cece87, 0xff5555aa, 0x78282850, 0x7adfdfa5,
0x8f8c8c03, 0xf8a1a159, 0x80898909, 0x170d0d1a, 0xdabfbf65,
0x31e6e6d7, 0xc6424284, 0xb86868d0, 0xc3414182, 0xb0999929,
0x772d2d5a, 0x110f0f1e, 0xcbb0b07b, 0xfc5454a8, 0xd6bbbb6d,
0x3a16162c
};
private static readonly uint[] T1 =
{
0x6363c6a5, 0x7c7cf884, 0x7777ee99, 0x7b7bf68d, 0xf2f2ff0d,
0x6b6bd6bd, 0x6f6fdeb1, 0xc5c59154, 0x30306050, 0x01010203,
0x6767cea9, 0x2b2b567d, 0xfefee719, 0xd7d7b562, 0xabab4de6,
0x7676ec9a, 0xcaca8f45, 0x82821f9d, 0xc9c98940, 0x7d7dfa87,
0xfafaef15, 0x5959b2eb, 0x47478ec9, 0xf0f0fb0b, 0xadad41ec,
0xd4d4b367, 0xa2a25ffd, 0xafaf45ea, 0x9c9c23bf, 0xa4a453f7,
0x7272e496, 0xc0c09b5b, 0xb7b775c2, 0xfdfde11c, 0x93933dae,
0x26264c6a, 0x36366c5a, 0x3f3f7e41, 0xf7f7f502, 0xcccc834f,
0x3434685c, 0xa5a551f4, 0xe5e5d134, 0xf1f1f908, 0x7171e293,
0xd8d8ab73, 0x31316253, 0x15152a3f, 0x0404080c, 0xc7c79552,
0x23234665, 0xc3c39d5e, 0x18183028, 0x969637a1, 0x05050a0f,
0x9a9a2fb5, 0x07070e09, 0x12122436, 0x80801b9b, 0xe2e2df3d,
0xebebcd26, 0x27274e69, 0xb2b27fcd, 0x7575ea9f, 0x0909121b,
0x83831d9e, 0x2c2c5874, 0x1a1a342e, 0x1b1b362d, 0x6e6edcb2,
0x5a5ab4ee, 0xa0a05bfb, 0x5252a4f6, 0x3b3b764d, 0xd6d6b761,
0xb3b37dce, 0x2929527b, 0xe3e3dd3e, 0x2f2f5e71, 0x84841397,
0x5353a6f5, 0xd1d1b968, 0x00000000, 0xededc12c, 0x20204060,
0xfcfce31f, 0xb1b179c8, 0x5b5bb6ed, 0x6a6ad4be, 0xcbcb8d46,
0xbebe67d9, 0x3939724b, 0x4a4a94de, 0x4c4c98d4, 0x5858b0e8,
0xcfcf854a, 0xd0d0bb6b, 0xefefc52a, 0xaaaa4fe5, 0xfbfbed16,
0x434386c5, 0x4d4d9ad7, 0x33336655, 0x85851194, 0x45458acf,
0xf9f9e910, 0x02020406, 0x7f7ffe81, 0x5050a0f0, 0x3c3c7844,
0x9f9f25ba, 0xa8a84be3, 0x5151a2f3, 0xa3a35dfe, 0x404080c0,
0x8f8f058a, 0x92923fad, 0x9d9d21bc, 0x38387048, 0xf5f5f104,
0xbcbc63df, 0xb6b677c1, 0xdadaaf75, 0x21214263, 0x10102030,
0xffffe51a, 0xf3f3fd0e, 0xd2d2bf6d, 0xcdcd814c, 0x0c0c1814,
0x13132635, 0xececc32f, 0x5f5fbee1, 0x979735a2, 0x444488cc,
0x17172e39, 0xc4c49357, 0xa7a755f2, 0x7e7efc82, 0x3d3d7a47,
0x6464c8ac, 0x5d5dbae7, 0x1919322b, 0x7373e695, 0x6060c0a0,
0x81811998, 0x4f4f9ed1, 0xdcdca37f, 0x22224466, 0x2a2a547e,
0x90903bab, 0x88880b83, 0x46468cca, 0xeeeec729, 0xb8b86bd3,
0x1414283c, 0xdedea779, 0x5e5ebce2, 0x0b0b161d, 0xdbdbad76,
0xe0e0db3b, 0x32326456, 0x3a3a744e, 0x0a0a141e, 0x494992db,
0x06060c0a, 0x2424486c, 0x5c5cb8e4, 0xc2c29f5d, 0xd3d3bd6e,
0xacac43ef, 0x6262c4a6, 0x919139a8, 0x959531a4, 0xe4e4d337,
0x7979f28b, 0xe7e7d532, 0xc8c88b43, 0x37376e59, 0x6d6ddab7,
0x8d8d018c, 0xd5d5b164, 0x4e4e9cd2, 0xa9a949e0, 0x6c6cd8b4,
0x5656acfa, 0xf4f4f307, 0xeaeacf25, 0x6565caaf, 0x7a7af48e,
0xaeae47e9, 0x08081018, 0xbaba6fd5, 0x7878f088, 0x25254a6f,
0x2e2e5c72, 0x1c1c3824, 0xa6a657f1, 0xb4b473c7, 0xc6c69751,
0xe8e8cb23, 0xdddda17c, 0x7474e89c, 0x1f1f3e21, 0x4b4b96dd,
0xbdbd61dc, 0x8b8b0d86, 0x8a8a0f85, 0x7070e090, 0x3e3e7c42,
0xb5b571c4, 0x6666ccaa, 0x484890d8, 0x03030605, 0xf6f6f701,
0x0e0e1c12, 0x6161c2a3, 0x35356a5f, 0x5757aef9, 0xb9b969d0,
0x86861791, 0xc1c19958, 0x1d1d3a27, 0x9e9e27b9, 0xe1e1d938,
0xf8f8eb13, 0x98982bb3, 0x11112233, 0x6969d2bb, 0xd9d9a970,
0x8e8e0789, 0x949433a7, 0x9b9b2db6, 0x1e1e3c22, 0x87871592,
0xe9e9c920, 0xcece8749, 0x5555aaff, 0x28285078, 0xdfdfa57a,
0x8c8c038f, 0xa1a159f8, 0x89890980, 0x0d0d1a17, 0xbfbf65da,
0xe6e6d731, 0x424284c6, 0x6868d0b8, 0x414182c3, 0x999929b0,
0x2d2d5a77, 0x0f0f1e11, 0xb0b07bcb, 0x5454a8fc, 0xbbbb6dd6,
0x16162c3a
};
private static readonly uint[] T2 =
{
0x63c6a563, 0x7cf8847c, 0x77ee9977, 0x7bf68d7b, 0xf2ff0df2,
0x6bd6bd6b, 0x6fdeb16f, 0xc59154c5, 0x30605030, 0x01020301,
0x67cea967, 0x2b567d2b, 0xfee719fe, 0xd7b562d7, 0xab4de6ab,
0x76ec9a76, 0xca8f45ca, 0x821f9d82, 0xc98940c9, 0x7dfa877d,
0xfaef15fa, 0x59b2eb59, 0x478ec947, 0xf0fb0bf0, 0xad41ecad,
0xd4b367d4, 0xa25ffda2, 0xaf45eaaf, 0x9c23bf9c, 0xa453f7a4,
0x72e49672, 0xc09b5bc0, 0xb775c2b7, 0xfde11cfd, 0x933dae93,
0x264c6a26, 0x366c5a36, 0x3f7e413f, 0xf7f502f7, 0xcc834fcc,
0x34685c34, 0xa551f4a5, 0xe5d134e5, 0xf1f908f1, 0x71e29371,
0xd8ab73d8, 0x31625331, 0x152a3f15, 0x04080c04, 0xc79552c7,
0x23466523, 0xc39d5ec3, 0x18302818, 0x9637a196, 0x050a0f05,
0x9a2fb59a, 0x070e0907, 0x12243612, 0x801b9b80, 0xe2df3de2,
0xebcd26eb, 0x274e6927, 0xb27fcdb2, 0x75ea9f75, 0x09121b09,
0x831d9e83, 0x2c58742c, 0x1a342e1a, 0x1b362d1b, 0x6edcb26e,
0x5ab4ee5a, 0xa05bfba0, 0x52a4f652, 0x3b764d3b, 0xd6b761d6,
0xb37dceb3, 0x29527b29, 0xe3dd3ee3, 0x2f5e712f, 0x84139784,
0x53a6f553, 0xd1b968d1, 0x00000000, 0xedc12ced, 0x20406020,
0xfce31ffc, 0xb179c8b1, 0x5bb6ed5b, 0x6ad4be6a, 0xcb8d46cb,
0xbe67d9be, 0x39724b39, 0x4a94de4a, 0x4c98d44c, 0x58b0e858,
0xcf854acf, 0xd0bb6bd0, 0xefc52aef, 0xaa4fe5aa, 0xfbed16fb,
0x4386c543, 0x4d9ad74d, 0x33665533, 0x85119485, 0x458acf45,
0xf9e910f9, 0x02040602, 0x7ffe817f, 0x50a0f050, 0x3c78443c,
0x9f25ba9f, 0xa84be3a8, 0x51a2f351, 0xa35dfea3, 0x4080c040,
0x8f058a8f, 0x923fad92, 0x9d21bc9d, 0x38704838, 0xf5f104f5,
0xbc63dfbc, 0xb677c1b6, 0xdaaf75da, 0x21426321, 0x10203010,
0xffe51aff, 0xf3fd0ef3, 0xd2bf6dd2, 0xcd814ccd, 0x0c18140c,
0x13263513, 0xecc32fec, 0x5fbee15f, 0x9735a297, 0x4488cc44,
0x172e3917, 0xc49357c4, 0xa755f2a7, 0x7efc827e, 0x3d7a473d,
0x64c8ac64, 0x5dbae75d, 0x19322b19, 0x73e69573, 0x60c0a060,
0x81199881, 0x4f9ed14f, 0xdca37fdc, 0x22446622, 0x2a547e2a,
0x903bab90, 0x880b8388, 0x468cca46, 0xeec729ee, 0xb86bd3b8,
0x14283c14, 0xdea779de, 0x5ebce25e, 0x0b161d0b, 0xdbad76db,
0xe0db3be0, 0x32645632, 0x3a744e3a, 0x0a141e0a, 0x4992db49,
0x060c0a06, 0x24486c24, 0x5cb8e45c, 0xc29f5dc2, 0xd3bd6ed3,
0xac43efac, 0x62c4a662, 0x9139a891, 0x9531a495, 0xe4d337e4,
0x79f28b79, 0xe7d532e7, 0xc88b43c8, 0x376e5937, 0x6ddab76d,
0x8d018c8d, 0xd5b164d5, 0x4e9cd24e, 0xa949e0a9, 0x6cd8b46c,
0x56acfa56, 0xf4f307f4, 0xeacf25ea, 0x65caaf65, 0x7af48e7a,
0xae47e9ae, 0x08101808, 0xba6fd5ba, 0x78f08878, 0x254a6f25,
0x2e5c722e, 0x1c38241c, 0xa657f1a6, 0xb473c7b4, 0xc69751c6,
0xe8cb23e8, 0xdda17cdd, 0x74e89c74, 0x1f3e211f, 0x4b96dd4b,
0xbd61dcbd, 0x8b0d868b, 0x8a0f858a, 0x70e09070, 0x3e7c423e,
0xb571c4b5, 0x66ccaa66, 0x4890d848, 0x03060503, 0xf6f701f6,
0x0e1c120e, 0x61c2a361, 0x356a5f35, 0x57aef957, 0xb969d0b9,
0x86179186, 0xc19958c1, 0x1d3a271d, 0x9e27b99e, 0xe1d938e1,
0xf8eb13f8, 0x982bb398, 0x11223311, 0x69d2bb69, 0xd9a970d9,
0x8e07898e, 0x9433a794, 0x9b2db69b, 0x1e3c221e, 0x87159287,
0xe9c920e9, 0xce8749ce, 0x55aaff55, 0x28507828, 0xdfa57adf,
0x8c038f8c, 0xa159f8a1, 0x89098089, 0x0d1a170d, 0xbf65dabf,
0xe6d731e6, 0x4284c642, 0x68d0b868, 0x4182c341, 0x9929b099,
0x2d5a772d, 0x0f1e110f, 0xb07bcbb0, 0x54a8fc54, 0xbb6dd6bb,
0x162c3a16
};
private static readonly uint[] T3 =
{
0xc6a56363, 0xf8847c7c, 0xee997777, 0xf68d7b7b, 0xff0df2f2,
0xd6bd6b6b, 0xdeb16f6f, 0x9154c5c5, 0x60503030, 0x02030101,
0xcea96767, 0x567d2b2b, 0xe719fefe, 0xb562d7d7, 0x4de6abab,
0xec9a7676, 0x8f45caca, 0x1f9d8282, 0x8940c9c9, 0xfa877d7d,
0xef15fafa, 0xb2eb5959, 0x8ec94747, 0xfb0bf0f0, 0x41ecadad,
0xb367d4d4, 0x5ffda2a2, 0x45eaafaf, 0x23bf9c9c, 0x53f7a4a4,
0xe4967272, 0x9b5bc0c0, 0x75c2b7b7, 0xe11cfdfd, 0x3dae9393,
0x4c6a2626, 0x6c5a3636, 0x7e413f3f, 0xf502f7f7, 0x834fcccc,
0x685c3434, 0x51f4a5a5, 0xd134e5e5, 0xf908f1f1, 0xe2937171,
0xab73d8d8, 0x62533131, 0x2a3f1515, 0x080c0404, 0x9552c7c7,
0x46652323, 0x9d5ec3c3, 0x30281818, 0x37a19696, 0x0a0f0505,
0x2fb59a9a, 0x0e090707, 0x24361212, 0x1b9b8080, 0xdf3de2e2,
0xcd26ebeb, 0x4e692727, 0x7fcdb2b2, 0xea9f7575, 0x121b0909,
0x1d9e8383, 0x58742c2c, 0x342e1a1a, 0x362d1b1b, 0xdcb26e6e,
0xb4ee5a5a, 0x5bfba0a0, 0xa4f65252, 0x764d3b3b, 0xb761d6d6,
0x7dceb3b3, 0x527b2929, 0xdd3ee3e3, 0x5e712f2f, 0x13978484,
0xa6f55353, 0xb968d1d1, 0x00000000, 0xc12ceded, 0x40602020,
0xe31ffcfc, 0x79c8b1b1, 0xb6ed5b5b, 0xd4be6a6a, 0x8d46cbcb,
0x67d9bebe, 0x724b3939, 0x94de4a4a, 0x98d44c4c, 0xb0e85858,
0x854acfcf, 0xbb6bd0d0, 0xc52aefef, 0x4fe5aaaa, 0xed16fbfb,
0x86c54343, 0x9ad74d4d, 0x66553333, 0x11948585, 0x8acf4545,
0xe910f9f9, 0x04060202, 0xfe817f7f, 0xa0f05050, 0x78443c3c,
0x25ba9f9f, 0x4be3a8a8, 0xa2f35151, 0x5dfea3a3, 0x80c04040,
0x058a8f8f, 0x3fad9292, 0x21bc9d9d, 0x70483838, 0xf104f5f5,
0x63dfbcbc, 0x77c1b6b6, 0xaf75dada, 0x42632121, 0x20301010,
0xe51affff, 0xfd0ef3f3, 0xbf6dd2d2, 0x814ccdcd, 0x18140c0c,
0x26351313, 0xc32fecec, 0xbee15f5f, 0x35a29797, 0x88cc4444,
0x2e391717, 0x9357c4c4, 0x55f2a7a7, 0xfc827e7e, 0x7a473d3d,
0xc8ac6464, 0xbae75d5d, 0x322b1919, 0xe6957373, 0xc0a06060,
0x19988181, 0x9ed14f4f, 0xa37fdcdc, 0x44662222, 0x547e2a2a,
0x3bab9090, 0x0b838888, 0x8cca4646, 0xc729eeee, 0x6bd3b8b8,
0x283c1414, 0xa779dede, 0xbce25e5e, 0x161d0b0b, 0xad76dbdb,
0xdb3be0e0, 0x64563232, 0x744e3a3a, 0x141e0a0a, 0x92db4949,
0x0c0a0606, 0x486c2424, 0xb8e45c5c, 0x9f5dc2c2, 0xbd6ed3d3,
0x43efacac, 0xc4a66262, 0x39a89191, 0x31a49595, 0xd337e4e4,
0xf28b7979, 0xd532e7e7, 0x8b43c8c8, 0x6e593737, 0xdab76d6d,
0x018c8d8d, 0xb164d5d5, 0x9cd24e4e, 0x49e0a9a9, 0xd8b46c6c,
0xacfa5656, 0xf307f4f4, 0xcf25eaea, 0xcaaf6565, 0xf48e7a7a,
0x47e9aeae, 0x10180808, 0x6fd5baba, 0xf0887878, 0x4a6f2525,
0x5c722e2e, 0x38241c1c, 0x57f1a6a6, 0x73c7b4b4, 0x9751c6c6,
0xcb23e8e8, 0xa17cdddd, 0xe89c7474, 0x3e211f1f, 0x96dd4b4b,
0x61dcbdbd, 0x0d868b8b, 0x0f858a8a, 0xe0907070, 0x7c423e3e,
0x71c4b5b5, 0xccaa6666, 0x90d84848, 0x06050303, 0xf701f6f6,
0x1c120e0e, 0xc2a36161, 0x6a5f3535, 0xaef95757, 0x69d0b9b9,
0x17918686, 0x9958c1c1, 0x3a271d1d, 0x27b99e9e, 0xd938e1e1,
0xeb13f8f8, 0x2bb39898, 0x22331111, 0xd2bb6969, 0xa970d9d9,
0x07898e8e, 0x33a79494, 0x2db69b9b, 0x3c221e1e, 0x15928787,
0xc920e9e9, 0x8749cece, 0xaaff5555, 0x50782828, 0xa57adfdf,
0x038f8c8c, 0x59f8a1a1, 0x09808989, 0x1a170d0d, 0x65dabfbf,
0xd731e6e6, 0x84c64242, 0xd0b86868, 0x82c34141, 0x29b09999,
0x5a772d2d, 0x1e110f0f, 0x7bcbb0b0, 0xa8fc5454, 0x6dd6bbbb,
0x2c3a1616
};
private static readonly uint[] Tinv0 =
{
0x50a7f451, 0x5365417e, 0xc3a4171a, 0x965e273a, 0xcb6bab3b,
0xf1459d1f, 0xab58faac, 0x9303e34b, 0x55fa3020, 0xf66d76ad,
0x9176cc88, 0x254c02f5, 0xfcd7e54f, 0xd7cb2ac5, 0x80443526,
0x8fa362b5, 0x495ab1de, 0x671bba25, 0x980eea45, 0xe1c0fe5d,
0x02752fc3, 0x12f04c81, 0xa397468d, 0xc6f9d36b, 0xe75f8f03,
0x959c9215, 0xeb7a6dbf, 0xda595295, 0x2d83bed4, 0xd3217458,
0x2969e049, 0x44c8c98e, 0x6a89c275, 0x78798ef4, 0x6b3e5899,
0xdd71b927, 0xb64fe1be, 0x17ad88f0, 0x66ac20c9, 0xb43ace7d,
0x184adf63, 0x82311ae5, 0x60335197, 0x457f5362, 0xe07764b1,
0x84ae6bbb, 0x1ca081fe, 0x942b08f9, 0x58684870, 0x19fd458f,
0x876cde94, 0xb7f87b52, 0x23d373ab, 0xe2024b72, 0x578f1fe3,
0x2aab5566, 0x0728ebb2, 0x03c2b52f, 0x9a7bc586, 0xa50837d3,
0xf2872830, 0xb2a5bf23, 0xba6a0302, 0x5c8216ed, 0x2b1ccf8a,
0x92b479a7, 0xf0f207f3, 0xa1e2694e, 0xcdf4da65, 0xd5be0506,
0x1f6234d1, 0x8afea6c4, 0x9d532e34, 0xa055f3a2, 0x32e18a05,
0x75ebf6a4, 0x39ec830b, 0xaaef6040, 0x069f715e, 0x51106ebd,
0xf98a213e, 0x3d06dd96, 0xae053edd, 0x46bde64d, 0xb58d5491,
0x055dc471, 0x6fd40604, 0xff155060, 0x24fb9819, 0x97e9bdd6,
0xcc434089, 0x779ed967, 0xbd42e8b0, 0x888b8907, 0x385b19e7,
0xdbeec879, 0x470a7ca1, 0xe90f427c, 0xc91e84f8, 0x00000000,
0x83868009, 0x48ed2b32, 0xac70111e, 0x4e725a6c, 0xfbff0efd,
0x5638850f, 0x1ed5ae3d, 0x27392d36, 0x64d90f0a, 0x21a65c68,
0xd1545b9b, 0x3a2e3624, 0xb1670a0c, 0x0fe75793, 0xd296eeb4,
0x9e919b1b, 0x4fc5c080, 0xa220dc61, 0x694b775a, 0x161a121c,
0x0aba93e2, 0xe52aa0c0, 0x43e0223c, 0x1d171b12, 0x0b0d090e,
0xadc78bf2, 0xb9a8b62d, 0xc8a91e14, 0x8519f157, 0x4c0775af,
0xbbdd99ee, 0xfd607fa3, 0x9f2601f7, 0xbcf5725c, 0xc53b6644,
0x347efb5b, 0x7629438b, 0xdcc623cb, 0x68fcedb6, 0x63f1e4b8,
0xcadc31d7, 0x10856342, 0x40229713, 0x2011c684, 0x7d244a85,
0xf83dbbd2, 0x1132f9ae, 0x6da129c7, 0x4b2f9e1d, 0xf330b2dc,
0xec52860d, 0xd0e3c177, 0x6c16b32b, 0x99b970a9, 0xfa489411,
0x2264e947, 0xc48cfca8, 0x1a3ff0a0, 0xd82c7d56, 0xef903322,
0xc74e4987, 0xc1d138d9, 0xfea2ca8c, 0x360bd498, 0xcf81f5a6,
0x28de7aa5, 0x268eb7da, 0xa4bfad3f, 0xe49d3a2c, 0x0d927850,
0x9bcc5f6a, 0x62467e54, 0xc2138df6, 0xe8b8d890, 0x5ef7392e,
0xf5afc382, 0xbe805d9f, 0x7c93d069, 0xa92dd56f, 0xb31225cf,
0x3b99acc8, 0xa77d1810, 0x6e639ce8, 0x7bbb3bdb, 0x097826cd,
0xf418596e, 0x01b79aec, 0xa89a4f83, 0x656e95e6, 0x7ee6ffaa,
0x08cfbc21, 0xe6e815ef, 0xd99be7ba, 0xce366f4a, 0xd4099fea,
0xd67cb029, 0xafb2a431, 0x31233f2a, 0x3094a5c6, 0xc066a235,
0x37bc4e74, 0xa6ca82fc, 0xb0d090e0, 0x15d8a733, 0x4a9804f1,
0xf7daec41, 0x0e50cd7f, 0x2ff69117, 0x8dd64d76, 0x4db0ef43,
0x544daacc, 0xdf0496e4, 0xe3b5d19e, 0x1b886a4c, 0xb81f2cc1,
0x7f516546, 0x04ea5e9d, 0x5d358c01, 0x737487fa, 0x2e410bfb,
0x5a1d67b3, 0x52d2db92, 0x335610e9, 0x1347d66d, 0x8c61d79a,
0x7a0ca137, 0x8e14f859, 0x893c13eb, 0xee27a9ce, 0x35c961b7,
0xede51ce1, 0x3cb1477a, 0x59dfd29c, 0x3f73f255, 0x79ce1418,
0xbf37c773, 0xeacdf753, 0x5baafd5f, 0x146f3ddf, 0x86db4478,
0x81f3afca, 0x3ec468b9, 0x2c342438, 0x5f40a3c2, 0x72c31d16,
0x0c25e2bc, 0x8b493c28, 0x41950dff, 0x7101a839, 0xdeb30c08,
0x9ce4b4d8, 0x90c15664, 0x6184cb7b, 0x70b632d5, 0x745c6c48,
0x4257b8d0
};
private static readonly uint[] Tinv1 =
{
0xa7f45150, 0x65417e53, 0xa4171ac3, 0x5e273a96, 0x6bab3bcb,
0x459d1ff1, 0x58faacab, 0x03e34b93, 0xfa302055, 0x6d76adf6,
0x76cc8891, 0x4c02f525, 0xd7e54ffc, 0xcb2ac5d7, 0x44352680,
0xa362b58f, 0x5ab1de49, 0x1bba2567, 0x0eea4598, 0xc0fe5de1,
0x752fc302, 0xf04c8112, 0x97468da3, 0xf9d36bc6, 0x5f8f03e7,
0x9c921595, 0x7a6dbfeb, 0x595295da, 0x83bed42d, 0x217458d3,
0x69e04929, 0xc8c98e44, 0x89c2756a, 0x798ef478, 0x3e58996b,
0x71b927dd, 0x4fe1beb6, 0xad88f017, 0xac20c966, 0x3ace7db4,
0x4adf6318, 0x311ae582, 0x33519760, 0x7f536245, 0x7764b1e0,
0xae6bbb84, 0xa081fe1c, 0x2b08f994, 0x68487058, 0xfd458f19,
0x6cde9487, 0xf87b52b7, 0xd373ab23, 0x024b72e2, 0x8f1fe357,
0xab55662a, 0x28ebb207, 0xc2b52f03, 0x7bc5869a, 0x0837d3a5,
0x872830f2, 0xa5bf23b2, 0x6a0302ba, 0x8216ed5c, 0x1ccf8a2b,
0xb479a792, 0xf207f3f0, 0xe2694ea1, 0xf4da65cd, 0xbe0506d5,
0x6234d11f, 0xfea6c48a, 0x532e349d, 0x55f3a2a0, 0xe18a0532,
0xebf6a475, 0xec830b39, 0xef6040aa, 0x9f715e06, 0x106ebd51,
0x8a213ef9, 0x06dd963d, 0x053eddae, 0xbde64d46, 0x8d5491b5,
0x5dc47105, 0xd406046f, 0x155060ff, 0xfb981924, 0xe9bdd697,
0x434089cc, 0x9ed96777, 0x42e8b0bd, 0x8b890788, 0x5b19e738,
0xeec879db, 0x0a7ca147, 0x0f427ce9, 0x1e84f8c9, 0x00000000,
0x86800983, 0xed2b3248, 0x70111eac, 0x725a6c4e, 0xff0efdfb,
0x38850f56, 0xd5ae3d1e, 0x392d3627, 0xd90f0a64, 0xa65c6821,
0x545b9bd1, 0x2e36243a, 0x670a0cb1, 0xe757930f, 0x96eeb4d2,
0x919b1b9e, 0xc5c0804f, 0x20dc61a2, 0x4b775a69, 0x1a121c16,
0xba93e20a, 0x2aa0c0e5, 0xe0223c43, 0x171b121d, 0x0d090e0b,
0xc78bf2ad, 0xa8b62db9, 0xa91e14c8, 0x19f15785, 0x0775af4c,
0xdd99eebb, 0x607fa3fd, 0x2601f79f, 0xf5725cbc, 0x3b6644c5,
0x7efb5b34, 0x29438b76, 0xc623cbdc, 0xfcedb668, 0xf1e4b863,
0xdc31d7ca, 0x85634210, 0x22971340, 0x11c68420, 0x244a857d,
0x3dbbd2f8, 0x32f9ae11, 0xa129c76d, 0x2f9e1d4b, 0x30b2dcf3,
0x52860dec, 0xe3c177d0, 0x16b32b6c, 0xb970a999, 0x489411fa,
0x64e94722, 0x8cfca8c4, 0x3ff0a01a, 0x2c7d56d8, 0x903322ef,
0x4e4987c7, 0xd138d9c1, 0xa2ca8cfe, 0x0bd49836, 0x81f5a6cf,
0xde7aa528, 0x8eb7da26, 0xbfad3fa4, 0x9d3a2ce4, 0x9278500d,
0xcc5f6a9b, 0x467e5462, 0x138df6c2, 0xb8d890e8, 0xf7392e5e,
0xafc382f5, 0x805d9fbe, 0x93d0697c, 0x2dd56fa9, 0x1225cfb3,
0x99acc83b, 0x7d1810a7, 0x639ce86e, 0xbb3bdb7b, 0x7826cd09,
0x18596ef4, 0xb79aec01, 0x9a4f83a8, 0x6e95e665, 0xe6ffaa7e,
0xcfbc2108, 0xe815efe6, 0x9be7bad9, 0x366f4ace, 0x099fead4,
0x7cb029d6, 0xb2a431af, 0x233f2a31, 0x94a5c630, 0x66a235c0,
0xbc4e7437, 0xca82fca6, 0xd090e0b0, 0xd8a73315, 0x9804f14a,
0xdaec41f7, 0x50cd7f0e, 0xf691172f, 0xd64d768d, 0xb0ef434d,
0x4daacc54, 0x0496e4df, 0xb5d19ee3, 0x886a4c1b, 0x1f2cc1b8,
0x5165467f, 0xea5e9d04, 0x358c015d, 0x7487fa73, 0x410bfb2e,
0x1d67b35a, 0xd2db9252, 0x5610e933, 0x47d66d13, 0x61d79a8c,
0x0ca1377a, 0x14f8598e, 0x3c13eb89, 0x27a9ceee, 0xc961b735,
0xe51ce1ed, 0xb1477a3c, 0xdfd29c59, 0x73f2553f, 0xce141879,
0x37c773bf, 0xcdf753ea, 0xaafd5f5b, 0x6f3ddf14, 0xdb447886,
0xf3afca81, 0xc468b93e, 0x3424382c, 0x40a3c25f, 0xc31d1672,
0x25e2bc0c, 0x493c288b, 0x950dff41, 0x01a83971, 0xb30c08de,
0xe4b4d89c, 0xc1566490, 0x84cb7b61, 0xb632d570, 0x5c6c4874,
0x57b8d042
};
private static readonly uint[] Tinv2 =
{
0xf45150a7, 0x417e5365, 0x171ac3a4, 0x273a965e, 0xab3bcb6b,
0x9d1ff145, 0xfaacab58, 0xe34b9303, 0x302055fa, 0x76adf66d,
0xcc889176, 0x02f5254c, 0xe54ffcd7, 0x2ac5d7cb, 0x35268044,
0x62b58fa3, 0xb1de495a, 0xba25671b, 0xea45980e, 0xfe5de1c0,
0x2fc30275, 0x4c8112f0, 0x468da397, 0xd36bc6f9, 0x8f03e75f,
0x9215959c, 0x6dbfeb7a, 0x5295da59, 0xbed42d83, 0x7458d321,
0xe0492969, 0xc98e44c8, 0xc2756a89, 0x8ef47879, 0x58996b3e,
0xb927dd71, 0xe1beb64f, 0x88f017ad, 0x20c966ac, 0xce7db43a,
0xdf63184a, 0x1ae58231, 0x51976033, 0x5362457f, 0x64b1e077,
0x6bbb84ae, 0x81fe1ca0, 0x08f9942b, 0x48705868, 0x458f19fd,
0xde94876c, 0x7b52b7f8, 0x73ab23d3, 0x4b72e202, 0x1fe3578f,
0x55662aab, 0xebb20728, 0xb52f03c2, 0xc5869a7b, 0x37d3a508,
0x2830f287, 0xbf23b2a5, 0x0302ba6a, 0x16ed5c82, 0xcf8a2b1c,
0x79a792b4, 0x07f3f0f2, 0x694ea1e2, 0xda65cdf4, 0x0506d5be,
0x34d11f62, 0xa6c48afe, 0x2e349d53, 0xf3a2a055, 0x8a0532e1,
0xf6a475eb, 0x830b39ec, 0x6040aaef, 0x715e069f, 0x6ebd5110,
0x213ef98a, 0xdd963d06, 0x3eddae05, 0xe64d46bd, 0x5491b58d,
0xc471055d, 0x06046fd4, 0x5060ff15, 0x981924fb, 0xbdd697e9,
0x4089cc43, 0xd967779e, 0xe8b0bd42, 0x8907888b, 0x19e7385b,
0xc879dbee, 0x7ca1470a, 0x427ce90f, 0x84f8c91e, 0x00000000,
0x80098386, 0x2b3248ed, 0x111eac70, 0x5a6c4e72, 0x0efdfbff,
0x850f5638, 0xae3d1ed5, 0x2d362739, 0x0f0a64d9, 0x5c6821a6,
0x5b9bd154, 0x36243a2e, 0x0a0cb167, 0x57930fe7, 0xeeb4d296,
0x9b1b9e91, 0xc0804fc5, 0xdc61a220, 0x775a694b, 0x121c161a,
0x93e20aba, 0xa0c0e52a, 0x223c43e0, 0x1b121d17, 0x090e0b0d,
0x8bf2adc7, 0xb62db9a8, 0x1e14c8a9, 0xf1578519, 0x75af4c07,
0x99eebbdd, 0x7fa3fd60, 0x01f79f26, 0x725cbcf5, 0x6644c53b,
0xfb5b347e, 0x438b7629, 0x23cbdcc6, 0xedb668fc, 0xe4b863f1,
0x31d7cadc, 0x63421085, 0x97134022, 0xc6842011, 0x4a857d24,
0xbbd2f83d, 0xf9ae1132, 0x29c76da1, 0x9e1d4b2f, 0xb2dcf330,
0x860dec52, 0xc177d0e3, 0xb32b6c16, 0x70a999b9, 0x9411fa48,
0xe9472264, 0xfca8c48c, 0xf0a01a3f, 0x7d56d82c, 0x3322ef90,
0x4987c74e, 0x38d9c1d1, 0xca8cfea2, 0xd498360b, 0xf5a6cf81,
0x7aa528de, 0xb7da268e, 0xad3fa4bf, 0x3a2ce49d, 0x78500d92,
0x5f6a9bcc, 0x7e546246, 0x8df6c213, 0xd890e8b8, 0x392e5ef7,
0xc382f5af, 0x5d9fbe80, 0xd0697c93, 0xd56fa92d, 0x25cfb312,
0xacc83b99, 0x1810a77d, 0x9ce86e63, 0x3bdb7bbb, 0x26cd0978,
0x596ef418, 0x9aec01b7, 0x4f83a89a, 0x95e6656e, 0xffaa7ee6,
0xbc2108cf, 0x15efe6e8, 0xe7bad99b, 0x6f4ace36, 0x9fead409,
0xb029d67c, 0xa431afb2, 0x3f2a3123, 0xa5c63094, 0xa235c066,
0x4e7437bc, 0x82fca6ca, 0x90e0b0d0, 0xa73315d8, 0x04f14a98,
0xec41f7da, 0xcd7f0e50, 0x91172ff6, 0x4d768dd6, 0xef434db0,
0xaacc544d, 0x96e4df04, 0xd19ee3b5, 0x6a4c1b88, 0x2cc1b81f,
0x65467f51, 0x5e9d04ea, 0x8c015d35, 0x87fa7374, 0x0bfb2e41,
0x67b35a1d, 0xdb9252d2, 0x10e93356, 0xd66d1347, 0xd79a8c61,
0xa1377a0c, 0xf8598e14, 0x13eb893c, 0xa9ceee27, 0x61b735c9,
0x1ce1ede5, 0x477a3cb1, 0xd29c59df, 0xf2553f73, 0x141879ce,
0xc773bf37, 0xf753eacd, 0xfd5f5baa, 0x3ddf146f, 0x447886db,
0xafca81f3, 0x68b93ec4, 0x24382c34, 0xa3c25f40, 0x1d1672c3,
0xe2bc0c25, 0x3c288b49, 0x0dff4195, 0xa8397101, 0x0c08deb3,
0xb4d89ce4, 0x566490c1, 0xcb7b6184, 0x32d570b6, 0x6c48745c,
0xb8d04257
};
private static readonly uint[] Tinv3 =
{
0x5150a7f4, 0x7e536541, 0x1ac3a417, 0x3a965e27, 0x3bcb6bab,
0x1ff1459d, 0xacab58fa, 0x4b9303e3, 0x2055fa30, 0xadf66d76,
0x889176cc, 0xf5254c02, 0x4ffcd7e5, 0xc5d7cb2a, 0x26804435,
0xb58fa362, 0xde495ab1, 0x25671bba, 0x45980eea, 0x5de1c0fe,
0xc302752f, 0x8112f04c, 0x8da39746, 0x6bc6f9d3, 0x03e75f8f,
0x15959c92, 0xbfeb7a6d, 0x95da5952, 0xd42d83be, 0x58d32174,
0x492969e0, 0x8e44c8c9, 0x756a89c2, 0xf478798e, 0x996b3e58,
0x27dd71b9, 0xbeb64fe1, 0xf017ad88, 0xc966ac20, 0x7db43ace,
0x63184adf, 0xe582311a, 0x97603351, 0x62457f53, 0xb1e07764,
0xbb84ae6b, 0xfe1ca081, 0xf9942b08, 0x70586848, 0x8f19fd45,
0x94876cde, 0x52b7f87b, 0xab23d373, 0x72e2024b, 0xe3578f1f,
0x662aab55, 0xb20728eb, 0x2f03c2b5, 0x869a7bc5, 0xd3a50837,
0x30f28728, 0x23b2a5bf, 0x02ba6a03, 0xed5c8216, 0x8a2b1ccf,
0xa792b479, 0xf3f0f207, 0x4ea1e269, 0x65cdf4da, 0x06d5be05,
0xd11f6234, 0xc48afea6, 0x349d532e, 0xa2a055f3, 0x0532e18a,
0xa475ebf6, 0x0b39ec83, 0x40aaef60, 0x5e069f71, 0xbd51106e,
0x3ef98a21, 0x963d06dd, 0xddae053e, 0x4d46bde6, 0x91b58d54,
0x71055dc4, 0x046fd406, 0x60ff1550, 0x1924fb98, 0xd697e9bd,
0x89cc4340, 0x67779ed9, 0xb0bd42e8, 0x07888b89, 0xe7385b19,
0x79dbeec8, 0xa1470a7c, 0x7ce90f42, 0xf8c91e84, 0x00000000,
0x09838680, 0x3248ed2b, 0x1eac7011, 0x6c4e725a, 0xfdfbff0e,
0x0f563885, 0x3d1ed5ae, 0x3627392d, 0x0a64d90f, 0x6821a65c,
0x9bd1545b, 0x243a2e36, 0x0cb1670a, 0x930fe757, 0xb4d296ee,
0x1b9e919b, 0x804fc5c0, 0x61a220dc, 0x5a694b77, 0x1c161a12,
0xe20aba93, 0xc0e52aa0, 0x3c43e022, 0x121d171b, 0x0e0b0d09,
0xf2adc78b, 0x2db9a8b6, 0x14c8a91e, 0x578519f1, 0xaf4c0775,
0xeebbdd99, 0xa3fd607f, 0xf79f2601, 0x5cbcf572, 0x44c53b66,
0x5b347efb, 0x8b762943, 0xcbdcc623, 0xb668fced, 0xb863f1e4,
0xd7cadc31, 0x42108563, 0x13402297, 0x842011c6, 0x857d244a,
0xd2f83dbb, 0xae1132f9, 0xc76da129, 0x1d4b2f9e, 0xdcf330b2,
0x0dec5286, 0x77d0e3c1, 0x2b6c16b3, 0xa999b970, 0x11fa4894,
0x472264e9, 0xa8c48cfc, 0xa01a3ff0, 0x56d82c7d, 0x22ef9033,
0x87c74e49, 0xd9c1d138, 0x8cfea2ca, 0x98360bd4, 0xa6cf81f5,
0xa528de7a, 0xda268eb7, 0x3fa4bfad, 0x2ce49d3a, 0x500d9278,
0x6a9bcc5f, 0x5462467e, 0xf6c2138d, 0x90e8b8d8, 0x2e5ef739,
0x82f5afc3, 0x9fbe805d, 0x697c93d0, 0x6fa92dd5, 0xcfb31225,
0xc83b99ac, 0x10a77d18, 0xe86e639c, 0xdb7bbb3b, 0xcd097826,
0x6ef41859, 0xec01b79a, 0x83a89a4f, 0xe6656e95, 0xaa7ee6ff,
0x2108cfbc, 0xefe6e815, 0xbad99be7, 0x4ace366f, 0xead4099f,
0x29d67cb0, 0x31afb2a4, 0x2a31233f, 0xc63094a5, 0x35c066a2,
0x7437bc4e, 0xfca6ca82, 0xe0b0d090, 0x3315d8a7, 0xf14a9804,
0x41f7daec, 0x7f0e50cd, 0x172ff691, 0x768dd64d, 0x434db0ef,
0xcc544daa, 0xe4df0496, 0x9ee3b5d1, 0x4c1b886a, 0xc1b81f2c,
0x467f5165, 0x9d04ea5e, 0x015d358c, 0xfa737487, 0xfb2e410b,
0xb35a1d67, 0x9252d2db, 0xe9335610, 0x6d1347d6, 0x9a8c61d7,
0x377a0ca1, 0x598e14f8, 0xeb893c13, 0xceee27a9, 0xb735c961,
0xe1ede51c, 0x7a3cb147, 0x9c59dfd2, 0x553f73f2, 0x1879ce14,
0x73bf37c7, 0x53eacdf7, 0x5f5baafd, 0xdf146f3d, 0x7886db44,
0xca81f3af, 0xb93ec468, 0x382c3424, 0xc25f40a3, 0x1672c31d,
0xbc0c25e2, 0x288b493c, 0xff41950d, 0x397101a8, 0x08deb30c,
0xd89ce4b4, 0x6490c156, 0x7b6184cb, 0xd570b632, 0x48745c6c,
0xd04257b8
};
private static uint Shift(uint r, int shift)
{
return (r >> shift) | (r << (32 - shift));
}
/* multiply four bytes in GF(2^8) by 'x' {02} in parallel */
private const uint m1 = 0x80808080;
private const uint m2 = 0x7f7f7f7f;
private const uint m3 = 0x0000001b;
private static uint FFmulX(uint x)
{
return ((x & m2) << 1) ^ (((x & m1) >> 7) * m3);
}
/*
The following defines provide alternative definitions of FFmulX that might
give improved performance if a fast 32-bit multiply is not available.
private int FFmulX(int x) { int u = x & m1; u |= (u >> 1); return ((x & m2) << 1) ^ ((u >>> 3) | (u >>> 6)); }
private static final int m4 = 0x1b1b1b1b;
private int FFmulX(int x) { int u = x & m1; return ((x & m2) << 1) ^ ((u - (u >>> 7)) & m4); }
*/
private static uint Inv_Mcol(uint x)
{
uint f2 = FFmulX(x);
uint f4 = FFmulX(f2);
uint f8 = FFmulX(f4);
uint f9 = x ^ f8;
return f2 ^ f4 ^ f8 ^ Shift(f2 ^ f9, 8) ^ Shift(f4 ^ f9, 16) ^ Shift(f9, 24);
}
private static uint SubWord(uint x)
{
return (uint)S[x&255]
| (((uint)S[(x>>8)&255]) << 8)
| (((uint)S[(x>>16)&255]) << 16)
| (((uint)S[(x>>24)&255]) << 24);
}
/**
* Calculate the necessary round keys
* The number of calculations depends on key size and block size
* AES specified a fixed block size of 128 bits and key sizes 128/192/256 bits
* This code is written assuming those are the only possible values
*/
private uint[][] GenerateWorkingKey(
byte[] key,
bool forEncryption)
{
int KC = key.Length / 4; // key length in words
if (((KC != 4) && (KC != 6) && (KC != 8)) || ((KC * 4) != key.Length))
throw new ArgumentException("Key length not 128/192/256 bits.");
ROUNDS = KC + 6; // This is not always true for the generalized Rijndael that allows larger block sizes
uint[][] W = new uint[ROUNDS + 1][]; // 4 words in a block
for (int i = 0; i <= ROUNDS; ++i)
{
W[i] = new uint[4];
}
//
// copy the key into the round key array
//
int t = 0;
for (int i = 0; i < key.Length; t++)
{
W[t >> 2][t & 3] = Pack.LE_To_UInt32(key, i);
i+=4;
}
//
// while not enough round key material calculated
// calculate new values
//
int k = (ROUNDS + 1) << 2;
for (int i = KC; (i < k); i++)
{
uint temp = W[(i-1)>>2][(i-1)&3];
if ((i % KC) == 0) {
temp = SubWord(Shift(temp, 8)) ^ rcon[(i / KC)-1];
} else if ((KC > 6) && ((i % KC) == 4)) {
temp = SubWord(temp);
}
W[i>>2][i&3] = W[(i - KC)>>2][(i-KC)&3] ^ temp;
}
if (!forEncryption)
{
for (int j = 1; j < ROUNDS; j++)
{
uint[] w = W[j];
for (int i = 0; i < 4; i++)
{
w[i] = Inv_Mcol(w[i]);
}
}
}
return W;
}
private int ROUNDS;
private uint[][] WorkingKey;
private uint C0, C1, C2, C3;
private bool forEncryption;
private const int BLOCK_SIZE = 16;
/**
* default constructor - 128 bit block size.
*/
public AesFastEngine()
{
}
/**
* initialise an AES cipher.
*
* @param forEncryption whether or not we are for encryption.
* @param parameters the parameters required to set up the cipher.
* @exception ArgumentException if the parameters argument is
* inappropriate.
*/
public virtual void Init(
bool forEncryption,
ICipherParameters parameters)
{
KeyParameter keyParameter = parameters as KeyParameter;
if (keyParameter == null)
throw new ArgumentException("invalid parameter passed to AES init - " + parameters.GetType().Name);
WorkingKey = GenerateWorkingKey(keyParameter.GetKey(), forEncryption);
this.forEncryption = forEncryption;
}
public virtual string AlgorithmName
{
get { return "AES"; }
}
public virtual bool IsPartialBlockOkay
{
get { return false; }
}
public virtual int GetBlockSize()
{
return BLOCK_SIZE;
}
public virtual int ProcessBlock(
byte[] input,
int inOff,
byte[] output,
int outOff)
{
if (WorkingKey == null)
throw new InvalidOperationException("AES engine not initialised");
Check.DataLength(input, inOff, 16, "input buffer too short");
Check.OutputLength(output, outOff, 16, "output buffer too short");
UnPackBlock(input, inOff);
if (forEncryption)
{
EncryptBlock(WorkingKey);
}
else
{
DecryptBlock(WorkingKey);
}
PackBlock(output, outOff);
return BLOCK_SIZE;
}
public virtual void Reset()
{
}
private void UnPackBlock(
byte[] bytes,
int off)
{
C0 = Pack.LE_To_UInt32(bytes, off);
C1 = Pack.LE_To_UInt32(bytes, off + 4);
C2 = Pack.LE_To_UInt32(bytes, off + 8);
C3 = Pack.LE_To_UInt32(bytes, off + 12);
}
private void PackBlock(
byte[] bytes,
int off)
{
Pack.UInt32_To_LE(C0, bytes, off);
Pack.UInt32_To_LE(C1, bytes, off + 4);
Pack.UInt32_To_LE(C2, bytes, off + 8);
Pack.UInt32_To_LE(C3, bytes, off + 12);
}
private void EncryptBlock(uint[][] KW)
{
uint[] kw = KW[0];
uint t0 = this.C0 ^ kw[0];
uint t1 = this.C1 ^ kw[1];
uint t2 = this.C2 ^ kw[2];
uint r0, r1, r2, r3 = this.C3 ^ kw[3];
int r = 1;
while (r < ROUNDS - 1)
{
kw = KW[r++];
r0 = T0[t0 & 255] ^ T1[(t1 >> 8) & 255] ^ T2[(t2 >> 16) & 255] ^ T3[r3 >> 24] ^ kw[0];
r1 = T0[t1 & 255] ^ T1[(t2 >> 8) & 255] ^ T2[(r3 >> 16) & 255] ^ T3[t0 >> 24] ^ kw[1];
r2 = T0[t2 & 255] ^ T1[(r3 >> 8) & 255] ^ T2[(t0 >> 16) & 255] ^ T3[t1 >> 24] ^ kw[2];
r3 = T0[r3 & 255] ^ T1[(t0 >> 8) & 255] ^ T2[(t1 >> 16) & 255] ^ T3[t2 >> 24] ^ kw[3];
kw = KW[r++];
t0 = T0[r0 & 255] ^ T1[(r1 >> 8) & 255] ^ T2[(r2 >> 16) & 255] ^ T3[r3 >> 24] ^ kw[0];
t1 = T0[r1 & 255] ^ T1[(r2 >> 8) & 255] ^ T2[(r3 >> 16) & 255] ^ T3[r0 >> 24] ^ kw[1];
t2 = T0[r2 & 255] ^ T1[(r3 >> 8) & 255] ^ T2[(r0 >> 16) & 255] ^ T3[r1 >> 24] ^ kw[2];
r3 = T0[r3 & 255] ^ T1[(r0 >> 8) & 255] ^ T2[(r1 >> 16) & 255] ^ T3[r2 >> 24] ^ kw[3];
}
kw = KW[r++];
r0 = T0[t0 & 255] ^ T1[(t1 >> 8) & 255] ^ T2[(t2 >> 16) & 255] ^ T3[r3 >> 24] ^ kw[0];
r1 = T0[t1 & 255] ^ T1[(t2 >> 8) & 255] ^ T2[(r3 >> 16) & 255] ^ T3[t0 >> 24] ^ kw[1];
r2 = T0[t2 & 255] ^ T1[(r3 >> 8) & 255] ^ T2[(t0 >> 16) & 255] ^ T3[t1 >> 24] ^ kw[2];
r3 = T0[r3 & 255] ^ T1[(t0 >> 8) & 255] ^ T2[(t1 >> 16) & 255] ^ T3[t2 >> 24] ^ kw[3];
// the final round's table is a simple function of S so we don't use a whole other four tables for it
kw = KW[r];
this.C0 = (uint)S[r0 & 255] ^ (((uint)S[(r1 >> 8) & 255]) << 8) ^ (((uint)S[(r2 >> 16) & 255]) << 16) ^ (((uint)S[r3 >> 24]) << 24) ^ kw[0];
this.C1 = (uint)S[r1 & 255] ^ (((uint)S[(r2 >> 8) & 255]) << 8) ^ (((uint)S[(r3 >> 16) & 255]) << 16) ^ (((uint)S[r0 >> 24]) << 24) ^ kw[1];
this.C2 = (uint)S[r2 & 255] ^ (((uint)S[(r3 >> 8) & 255]) << 8) ^ (((uint)S[(r0 >> 16) & 255]) << 16) ^ (((uint)S[r1 >> 24]) << 24) ^ kw[2];
this.C3 = (uint)S[r3 & 255] ^ (((uint)S[(r0 >> 8) & 255]) << 8) ^ (((uint)S[(r1 >> 16) & 255]) << 16) ^ (((uint)S[r2 >> 24]) << 24) ^ kw[3];
}
private void DecryptBlock(uint[][] KW)
{
uint[] kw = KW[ROUNDS];
uint t0 = this.C0 ^ kw[0];
uint t1 = this.C1 ^ kw[1];
uint t2 = this.C2 ^ kw[2];
uint r0, r1, r2, r3 = this.C3 ^ kw[3];
int r = ROUNDS - 1;
while (r > 1)
{
kw = KW[r--];
r0 = Tinv0[t0 & 255] ^ Tinv1[(r3 >> 8) & 255] ^ Tinv2[(t2 >> 16) & 255] ^ Tinv3[t1 >> 24] ^ kw[0];
r1 = Tinv0[t1 & 255] ^ Tinv1[(t0 >> 8) & 255] ^ Tinv2[(r3 >> 16) & 255] ^ Tinv3[t2 >> 24] ^ kw[1];
r2 = Tinv0[t2 & 255] ^ Tinv1[(t1 >> 8) & 255] ^ Tinv2[(t0 >> 16) & 255] ^ Tinv3[r3 >> 24] ^ kw[2];
r3 = Tinv0[r3 & 255] ^ Tinv1[(t2 >> 8) & 255] ^ Tinv2[(t1 >> 16) & 255] ^ Tinv3[t0 >> 24] ^ kw[3];
kw = KW[r--];
t0 = Tinv0[r0 & 255] ^ Tinv1[(r3 >> 8) & 255] ^ Tinv2[(r2 >> 16) & 255] ^ Tinv3[r1 >> 24] ^ kw[0];
t1 = Tinv0[r1 & 255] ^ Tinv1[(r0 >> 8) & 255] ^ Tinv2[(r3 >> 16) & 255] ^ Tinv3[r2 >> 24] ^ kw[1];
t2 = Tinv0[r2 & 255] ^ Tinv1[(r1 >> 8) & 255] ^ Tinv2[(r0 >> 16) & 255] ^ Tinv3[r3 >> 24] ^ kw[2];
r3 = Tinv0[r3 & 255] ^ Tinv1[(r2 >> 8) & 255] ^ Tinv2[(r1 >> 16) & 255] ^ Tinv3[r0 >> 24] ^ kw[3];
}
kw = KW[1];
r0 = Tinv0[t0 & 255] ^ Tinv1[(r3 >> 8) & 255] ^ Tinv2[(t2 >> 16) & 255] ^ Tinv3[t1 >> 24] ^ kw[0];
r1 = Tinv0[t1 & 255] ^ Tinv1[(t0 >> 8) & 255] ^ Tinv2[(r3 >> 16) & 255] ^ Tinv3[t2 >> 24] ^ kw[1];
r2 = Tinv0[t2 & 255] ^ Tinv1[(t1 >> 8) & 255] ^ Tinv2[(t0 >> 16) & 255] ^ Tinv3[r3 >> 24] ^ kw[2];
r3 = Tinv0[r3 & 255] ^ Tinv1[(t2 >> 8) & 255] ^ Tinv2[(t1 >> 16) & 255] ^ Tinv3[t0 >> 24] ^ kw[3];
// the final round's table is a simple function of Si so we don't use a whole other four tables for it
kw = KW[0];
this.C0 = (uint)Si[r0 & 255] ^ (((uint)Si[(r3 >> 8) & 255]) << 8) ^ (((uint)Si[(r2 >> 16) & 255]) << 16) ^ (((uint)Si[r1 >> 24]) << 24) ^ kw[0];
this.C1 = (uint)Si[r1 & 255] ^ (((uint)Si[(r0 >> 8) & 255]) << 8) ^ (((uint)Si[(r3 >> 16) & 255]) << 16) ^ (((uint)Si[r2 >> 24]) << 24) ^ kw[1];
this.C2 = (uint)Si[r2 & 255] ^ (((uint)Si[(r1 >> 8) & 255]) << 8) ^ (((uint)Si[(r0 >> 16) & 255]) << 16) ^ (((uint)Si[r3 >> 24]) << 24) ^ kw[2];
this.C3 = (uint)Si[r3 & 255] ^ (((uint)Si[(r2 >> 8) & 255]) << 8) ^ (((uint)Si[(r1 >> 16) & 255]) << 16) ^ (((uint)Si[r0 >> 24]) << 24) ^ kw[3];
}
}
}

367
MinecraftClient/Crypto/Streams/BouncyAes/BufferedBlockCipher.cs
View file

@ -1,367 +0,0 @@
using System;
using System.Diagnostics;
using Org.BouncyCastle.Crypto.Parameters;
namespace Org.BouncyCastle.Crypto
{
/**
* A wrapper class that allows block ciphers to be used to process data in
* a piecemeal fashion. The BufferedBlockCipher outputs a block only when the
* buffer is full and more data is being added, or on a doFinal.
* <p>
* Note: in the case where the underlying cipher is either a CFB cipher or an
* OFB one the last block may not be a multiple of the block size.
* </p>
*/
public class BufferedBlockCipher
: BufferedCipherBase
{
internal byte[] buf;
internal int bufOff;
internal bool forEncryption;
internal IBlockCipher cipher;
/**
* constructor for subclasses
*/
protected BufferedBlockCipher()
{
}
/**
* Create a buffered block cipher without padding.
*
* @param cipher the underlying block cipher this buffering object wraps.
* false otherwise.
*/
public BufferedBlockCipher(
IBlockCipher cipher)
{
if (cipher == null)
throw new ArgumentNullException("cipher");
this.cipher = cipher;
buf = new byte[cipher.GetBlockSize()];
bufOff = 0;
}
public override string AlgorithmName
{
get { return cipher.AlgorithmName; }
}
/**
* initialise the cipher.
*
* @param forEncryption if true the cipher is initialised for
* encryption, if false for decryption.
* @param param the key and other data required by the cipher.
* @exception ArgumentException if the parameters argument is
* inappropriate.
*/
// Note: This doubles as the Init in the event that this cipher is being used as an IWrapper
public override void Init(
bool forEncryption,
ICipherParameters parameters)
{
this.forEncryption = forEncryption;
//ParametersWithRandom pwr = parameters as ParametersWithRandom;
//if (pwr != null)
// parameters = pwr.Parameters;
Reset();
cipher.Init(forEncryption, parameters);
}
/**
* return the blocksize for the underlying cipher.
*
* @return the blocksize for the underlying cipher.
*/
public override int GetBlockSize()
{
return cipher.GetBlockSize();
}
/**
* return the size of the output buffer required for an update
* an input of len bytes.
*
* @param len the length of the input.
* @return the space required to accommodate a call to update
* with len bytes of input.
*/
public override int GetUpdateOutputSize(
int length)
{
int total = length + bufOff;
int leftOver = total % buf.Length;
return total - leftOver;
}
/**
* return the size of the output buffer required for an update plus a
* doFinal with an input of len bytes.
*
* @param len the length of the input.
* @return the space required to accommodate a call to update and doFinal
* with len bytes of input.
*/
public override int GetOutputSize(
int length)
{
// Note: Can assume IsPartialBlockOkay is true for purposes of this calculation
return length + bufOff;
}
/**
* process a single byte, producing an output block if necessary.
*
* @param in the input byte.
* @param out the space for any output that might be produced.
* @param outOff the offset from which the output will be copied.
* @return the number of output bytes copied to out.
* @exception DataLengthException if there isn't enough space in out.
* @exception InvalidOperationException if the cipher isn't initialised.
*/
public override int ProcessByte(
byte input,
byte[] output,
int outOff)
{
buf[bufOff++] = input;
if (bufOff == buf.Length)
{
if ((outOff + buf.Length) > output.Length)
throw new DataLengthException("output buffer too short");
bufOff = 0;
return cipher.ProcessBlock(buf, 0, output, outOff);
}
return 0;
}
public override byte[] ProcessByte(
byte input)
{
int outLength = GetUpdateOutputSize(1);
byte[] outBytes = outLength > 0 ? new byte[outLength] : null;
int pos = ProcessByte(input, outBytes, 0);
if (outLength > 0 && pos < outLength)
{
byte[] tmp = new byte[pos];
Array.Copy(outBytes, 0, tmp, 0, pos);
outBytes = tmp;
}
return outBytes;
}
public override byte[] ProcessBytes(
byte[] input,
int inOff,
int length)
{
if (input == null)
throw new ArgumentNullException("input");
if (length < 1)
return null;
int outLength = GetUpdateOutputSize(length);
byte[] outBytes = outLength > 0 ? new byte[outLength] : null;
int pos = ProcessBytes(input, inOff, length, outBytes, 0);
if (outLength > 0 && pos < outLength)
{
byte[] tmp = new byte[pos];
Array.Copy(outBytes, 0, tmp, 0, pos);
outBytes = tmp;
}
return outBytes;
}
/**
* process an array of bytes, producing output if necessary.
*
* @param in the input byte array.
* @param inOff the offset at which the input data starts.
* @param len the number of bytes to be copied out of the input array.
* @param out the space for any output that might be produced.
* @param outOff the offset from which the output will be copied.
* @return the number of output bytes copied to out.
* @exception DataLengthException if there isn't enough space in out.
* @exception InvalidOperationException if the cipher isn't initialised.
*/
public override int ProcessBytes(
byte[] input,
int inOff,
int length,
byte[] output,
int outOff)
{
if (length < 1)
{
if (length < 0)
throw new ArgumentException("Can't have a negative input length!");
return 0;
}
int blockSize = GetBlockSize();
int outLength = GetUpdateOutputSize(length);
if (outLength > 0)
{
Check.OutputLength(output, outOff, outLength, "output buffer too short");
}
int resultLen = 0;
int gapLen = buf.Length - bufOff;
if (length > gapLen)
{
Array.Copy(input, inOff, buf, bufOff, gapLen);
resultLen += cipher.ProcessBlock(buf, 0, output, outOff);
bufOff = 0;
length -= gapLen;
inOff += gapLen;
while (length > buf.Length)
{
resultLen += cipher.ProcessBlock(input, inOff, output, outOff + resultLen);
length -= blockSize;
inOff += blockSize;
}
}
Array.Copy(input, inOff, buf, bufOff, length);
bufOff += length;
if (bufOff == buf.Length)
{
resultLen += cipher.ProcessBlock(buf, 0, output, outOff + resultLen);
bufOff = 0;
}
return resultLen;
}
public override byte[] DoFinal()
{
byte[] outBytes = EmptyBuffer;
int length = GetOutputSize(0);
if (length > 0)
{
outBytes = new byte[length];
int pos = DoFinal(outBytes, 0);
if (pos < outBytes.Length)
{
byte[] tmp = new byte[pos];
Array.Copy(outBytes, 0, tmp, 0, pos);
outBytes = tmp;
}
}
else
{
Reset();
}
return outBytes;
}
public override byte[] DoFinal(
byte[] input,
int inOff,
int inLen)
{
if (input == null)
throw new ArgumentNullException("input");
int length = GetOutputSize(inLen);
byte[] outBytes = EmptyBuffer;
if (length > 0)
{
outBytes = new byte[length];
int pos = (inLen > 0)
? ProcessBytes(input, inOff, inLen, outBytes, 0)
: 0;
pos += DoFinal(outBytes, pos);
if (pos < outBytes.Length)
{
byte[] tmp = new byte[pos];
Array.Copy(outBytes, 0, tmp, 0, pos);
outBytes = tmp;
}
}
else
{
Reset();
}
return outBytes;
}
/**
* Process the last block in the buffer.
*
* @param out the array the block currently being held is copied into.
* @param outOff the offset at which the copying starts.
* @return the number of output bytes copied to out.
* @exception DataLengthException if there is insufficient space in out for
* the output, or the input is not block size aligned and should be.
* @exception InvalidOperationException if the underlying cipher is not
* initialised.
* @exception InvalidCipherTextException if padding is expected and not found.
* @exception DataLengthException if the input is not block size
* aligned.
*/
public override int DoFinal(
byte[] output,
int outOff)
{
try
{
if (bufOff != 0)
{
Check.DataLength(!cipher.IsPartialBlockOkay, "data not block size aligned");
Check.OutputLength(output, outOff, bufOff, "output buffer too short for DoFinal()");
// NB: Can't copy directly, or we may write too much output
cipher.ProcessBlock(buf, 0, buf, 0);
Array.Copy(buf, 0, output, outOff, bufOff);
}
return bufOff;
}
finally
{
Reset();
}
}
/**
* Reset the buffer and cipher. After resetting the object is in the same
* state as it was after the last init (if there was one).
*/
public override void Reset()
{
Array.Clear(buf, 0, buf.Length);
bufOff = 0;
cipher.Reset();
}
}
}

113
MinecraftClient/Crypto/Streams/BouncyAes/BufferedCipherBase.cs
View file

@ -1,113 +0,0 @@
using System;
namespace Org.BouncyCastle.Crypto
{
public abstract class BufferedCipherBase
: IBufferedCipher
{
protected static readonly byte[] EmptyBuffer = new byte[0];
public abstract string AlgorithmName { get; }
public abstract void Init(bool forEncryption, ICipherParameters parameters);
public abstract int GetBlockSize();
public abstract int GetOutputSize(int inputLen);
public abstract int GetUpdateOutputSize(int inputLen);
public abstract byte[] ProcessByte(byte input);
public virtual int ProcessByte(
byte input,
byte[] output,
int outOff)
{
byte[] outBytes = ProcessByte(input);
if (outBytes == null)
return 0;
if (outOff + outBytes.Length > output.Length)
throw new DataLengthException("output buffer too short");
outBytes.CopyTo(output, outOff);
return outBytes.Length;
}
public virtual byte[] ProcessBytes(
byte[] input)
{
return ProcessBytes(input, 0, input.Length);
}
public abstract byte[] ProcessBytes(byte[] input, int inOff, int length);
public virtual int ProcessBytes(
byte[] input,
byte[] output,
int outOff)
{
return ProcessBytes(input, 0, input.Length, output, outOff);
}
public virtual int ProcessBytes(
byte[] input,
int inOff,
int length,
byte[] output,
int outOff)
{
byte[] outBytes = ProcessBytes(input, inOff, length);
if (outBytes == null)
return 0;
if (outOff + outBytes.Length > output.Length)
throw new DataLengthException("output buffer too short");
outBytes.CopyTo(output, outOff);
return outBytes.Length;
}
public abstract byte[] DoFinal();
public virtual byte[] DoFinal(
byte[] input)
{
return DoFinal(input, 0, input.Length);
}
public abstract byte[] DoFinal(
byte[] input,
int inOff,
int length);
public virtual int DoFinal(
byte[] output,
int outOff)
{
byte[] outBytes = DoFinal();
if (outOff + outBytes.Length > output.Length)
throw new DataLengthException("output buffer too short");
outBytes.CopyTo(output, outOff);
return outBytes.Length;
}
public virtual int DoFinal(
byte[] input,
byte[] output,
int outOff)
{
return DoFinal(input, 0, input.Length, output, outOff);
}
public virtual int DoFinal(
byte[] input,
int inOff,
int length,
byte[] output,
int outOff)
{
int len = ProcessBytes(input, inOff, length, output, outOff);
len += DoFinal(output, outOff + len);
return len;
}
public abstract void Reset();
}
}

224
MinecraftClient/Crypto/Streams/BouncyAes/CfbBlockCipher.cs
View file

@ -1,224 +0,0 @@
using System;
using Org.BouncyCastle.Crypto.Parameters;
namespace Org.BouncyCastle.Crypto.Modes
{
/**
* implements a Cipher-FeedBack (CFB) mode on top of a simple cipher.
*/
public class CfbBlockCipher
: IBlockCipher
{
private byte[] IV;
private byte[] cfbV;
private byte[] cfbOutV;
private bool encrypting;
private readonly int blockSize;
private readonly IBlockCipher cipher;
/**
* Basic constructor.
*
* @param cipher the block cipher to be used as the basis of the
* feedback mode.
* @param blockSize the block size in bits (note: a multiple of 8)
*/
public CfbBlockCipher(
IBlockCipher cipher,
int bitBlockSize)
{
this.cipher = cipher;
this.blockSize = bitBlockSize / 8;
this.IV = new byte[cipher.GetBlockSize()];
this.cfbV = new byte[cipher.GetBlockSize()];
this.cfbOutV = new byte[cipher.GetBlockSize()];
}
/**
* return the underlying block cipher that we are wrapping.
*
* @return the underlying block cipher that we are wrapping.
*/
public IBlockCipher GetUnderlyingCipher()
{
return cipher;
}
/**
* Initialise the cipher and, possibly, the initialisation vector (IV).
* If an IV isn't passed as part of the parameter, the IV will be all zeros.
* An IV which is too short is handled in FIPS compliant fashion.
*
* @param forEncryption if true the cipher is initialised for
* encryption, if false for decryption.
* @param param the key and other data required by the cipher.
* @exception ArgumentException if the parameters argument is
* inappropriate.
*/
public void Init(
bool forEncryption,
ICipherParameters parameters)
{
this.encrypting = forEncryption;
if (parameters is ParametersWithIV)
{
ParametersWithIV ivParam = (ParametersWithIV) parameters;
byte[] iv = ivParam.GetIV();
int diff = IV.Length - iv.Length;
Array.Copy(iv, 0, IV, diff, iv.Length);
Array.Clear(IV, 0, diff);
parameters = ivParam.Parameters;
}
Reset();
// if it's null, key is to be reused.
if (parameters != null)
{
cipher.Init(true, parameters);
}
}
/**
* return the algorithm name and mode.
*
* @return the name of the underlying algorithm followed by "/CFB"
* and the block size in bits.
*/
public string AlgorithmName
{
get { return cipher.AlgorithmName + "/CFB" + (blockSize * 8); }
}
public bool IsPartialBlockOkay
{
get { return true; }
}
/**
* return the block size we are operating at.
*
* @return the block size we are operating at (in bytes).
*/
public int GetBlockSize()
{
return blockSize;
}
/**
* Process one block of input from the array in and write it to
* the out array.
*
* @param in the array containing the input data.
* @param inOff offset into the in array the data starts at.
* @param out the array the output data will be copied into.
* @param outOff the offset into the out array the output will start at.
* @exception DataLengthException if there isn't enough data in in, or
* space in out.
* @exception InvalidOperationException if the cipher isn't initialised.
* @return the number of bytes processed and produced.
*/
public int ProcessBlock(
byte[] input,
int inOff,
byte[] output,
int outOff)
{
return (encrypting)
? EncryptBlock(input, inOff, output, outOff)
: DecryptBlock(input, inOff, output, outOff);
}
/**
* Do the appropriate processing for CFB mode encryption.
*
* @param in the array containing the data to be encrypted.
* @param inOff offset into the in array the data starts at.
* @param out the array the encrypted data will be copied into.
* @param outOff the offset into the out array the output will start at.
* @exception DataLengthException if there isn't enough data in in, or
* space in out.
* @exception InvalidOperationException if the cipher isn't initialised.
* @return the number of bytes processed and produced.
*/
public int EncryptBlock(
byte[] input,
int inOff,
byte[] outBytes,
int outOff)
{
if ((inOff + blockSize) > input.Length)
{
throw new DataLengthException("input buffer too short");
}
if ((outOff + blockSize) > outBytes.Length)
{
throw new DataLengthException("output buffer too short");
}
cipher.ProcessBlock(cfbV, 0, cfbOutV, 0);
//
// XOR the cfbV with the plaintext producing the ciphertext
//
for (int i = 0; i < blockSize; i++)
{
outBytes[outOff + i] = (byte)(cfbOutV[i] ^ input[inOff + i]);
}
//
// change over the input block.
//
Array.Copy(cfbV, blockSize, cfbV, 0, cfbV.Length - blockSize);
Array.Copy(outBytes, outOff, cfbV, cfbV.Length - blockSize, blockSize);
return blockSize;
}
/**
* Do the appropriate processing for CFB mode decryption.
*
* @param in the array containing the data to be decrypted.
* @param inOff offset into the in array the data starts at.
* @param out the array the encrypted data will be copied into.
* @param outOff the offset into the out array the output will start at.
* @exception DataLengthException if there isn't enough data in in, or
* space in out.
* @exception InvalidOperationException if the cipher isn't initialised.
* @return the number of bytes processed and produced.
*/
public int DecryptBlock(
byte[] input,
int inOff,
byte[] outBytes,
int outOff)
{
if ((inOff + blockSize) > input.Length)
{
throw new DataLengthException("input buffer too short");
}
if ((outOff + blockSize) > outBytes.Length)
{
throw new DataLengthException("output buffer too short");
}
cipher.ProcessBlock(cfbV, 0, cfbOutV, 0);
//
// change over the input block.
//
Array.Copy(cfbV, blockSize, cfbV, 0, cfbV.Length - blockSize);
Array.Copy(input, inOff, cfbV, cfbV.Length - blockSize, blockSize);
//
// XOR the cfbV with the ciphertext producing the plaintext
//
for (int i = 0; i < blockSize; i++)
{
outBytes[outOff + i] = (byte)(cfbOutV[i] ^ input[inOff + i]);
}
return blockSize;
}
/**
* reset the chaining vector back to the IV and reset the underlying
* cipher.
*/
public void Reset()
{
Array.Copy(IV, 0, cfbV, 0, IV.Length);
cipher.Reset();
}
}
}

25
MinecraftClient/Crypto/Streams/BouncyAes/Check.cs
View file

@ -1,25 +0,0 @@
using System;
namespace Org.BouncyCastle.Crypto
{
internal class Check
{
internal static void DataLength(bool condition, string msg)
{
if (condition)
throw new DataLengthException(msg);
}
internal static void DataLength(byte[] buf, int off, int len, string msg)
{
if (off + len > buf.Length)
throw new DataLengthException(msg);
}
internal static void OutputLength(byte[] buf, int off, int len, string msg)
{
if (off + len > buf.Length)
throw new OutputLengthException(msg);
}
}
}

234
MinecraftClient/Crypto/Streams/BouncyAes/CipherStream.cs
View file

@ -1,234 +0,0 @@
using System;
using System.Diagnostics;
using System.IO;
using Org.BouncyCastle.Crypto;
namespace Org.BouncyCastle.Crypto.IO
{
public class CipherStream
: Stream
{
internal Stream stream;
internal IBufferedCipher inCipher, outCipher;
private byte[] mInBuf;
private int mInPos;
private bool inStreamEnded;
public CipherStream(
Stream stream,
IBufferedCipher readCipher,
IBufferedCipher writeCipher)
{
this.stream = stream;
if (readCipher != null)
{
this.inCipher = readCipher;
mInBuf = null;
}
if (writeCipher != null)
{
this.outCipher = writeCipher;
}
}
public IBufferedCipher ReadCipher
{
get { return inCipher; }
}
public IBufferedCipher WriteCipher
{
get { return outCipher; }
}
public override int ReadByte()
{
if (inCipher == null)
return stream.ReadByte();
if (mInBuf == null || mInPos >= mInBuf.Length)
{
if (!FillInBuf())
return -1;
}
return mInBuf[mInPos++];
}
public override int Read(
byte[] buffer,
int offset,
int count)
{
if (inCipher == null)
return stream.Read(buffer, offset, count);
int num = 0;
while (num < count)
{
if (mInBuf == null || mInPos >= mInBuf.Length)
{
if (!FillInBuf())
break;
}
int numToCopy = System.Math.Min(count - num, mInBuf.Length - mInPos);
Array.Copy(mInBuf, mInPos, buffer, offset + num, numToCopy);
mInPos += numToCopy;
num += numToCopy;
}
return num;
}
private bool FillInBuf()
{
if (inStreamEnded)
return false;
mInPos = 0;
do
{
mInBuf = ReadAndProcessBlock();
}
while (!inStreamEnded && mInBuf == null);
return mInBuf != null;
}
private byte[] ReadAndProcessBlock()
{
int blockSize = inCipher.GetBlockSize();
int readSize = (blockSize == 0) ? 256 : blockSize;
byte[] block = new byte[readSize];
int numRead = 0;
do
{
int count = stream.Read(block, numRead, block.Length - numRead);
if (count < 1)
{
inStreamEnded = true;
break;
}
numRead += count;
}
while (numRead < block.Length);
Debug.Assert(inStreamEnded || numRead == block.Length);
byte[] bytes = inStreamEnded
? inCipher.DoFinal(block, 0, numRead)
: inCipher.ProcessBytes(block);
if (bytes != null && bytes.Length == 0)
{
bytes = null;
}
return bytes;
}
public override void Write(
byte[] buffer,
int offset,
int count)
{
Debug.Assert(buffer != null);
Debug.Assert(0 <= offset && offset <= buffer.Length);
Debug.Assert(count >= 0);
int end = offset + count;
Debug.Assert(0 <= end && end <= buffer.Length);
if (outCipher == null)
{
stream.Write(buffer, offset, count);
return;
}
byte[] data = outCipher.ProcessBytes(buffer, offset, count);
if (data != null)
{
stream.Write(data, 0, data.Length);
}
}
public override void WriteByte(
byte b)
{
if (outCipher == null)
{
stream.WriteByte(b);
return;
}
byte[] data = outCipher.ProcessByte(b);
if (data != null)
{
stream.Write(data, 0, data.Length);
}
}
public override bool CanRead
{
get { return stream.CanRead && (inCipher != null); }
}
public override bool CanWrite
{
get { return stream.CanWrite && (outCipher != null); }
}
public override bool CanSeek
{
get { return false; }
}
public sealed override long Length
{
get { throw new NotSupportedException(); }
}
public sealed override long Position
{
get { throw new NotSupportedException(); }
set { throw new NotSupportedException(); }
}
public override void Close()
{
if (outCipher != null)
{
byte[] data = outCipher.DoFinal();
stream.Write(data, 0, data.Length);
stream.Flush();
}
stream.Close();
}
public override void Flush()
{
// Note: outCipher.DoFinal is only called during Close()
stream.Flush();
}
public sealed override long Seek(
long offset,
SeekOrigin origin)
{
throw new NotSupportedException();
}
public sealed override void SetLength(
long length)
{
throw new NotSupportedException();
}
}
}

28
MinecraftClient/Crypto/Streams/BouncyAes/CryptoException.cs
View file

@ -1,28 +0,0 @@
using System;
namespace Org.BouncyCastle.Crypto
{
#if !(NETCF_1_0 || NETCF_2_0 || SILVERLIGHT)
[Serializable]
#endif
public class CryptoException
: Exception
{
public CryptoException()
{
}
public CryptoException(
string message)
: base(message)
{
}
public CryptoException(
string message,
Exception exception)
: base(message, exception)
{
}
}
}

42
MinecraftClient/Crypto/Streams/BouncyAes/DataLengthException.cs
View file

@ -1,42 +0,0 @@
using System;
namespace Org.BouncyCastle.Crypto
{
/**
* this exception is thrown if a buffer that is meant to have output
* copied into it turns out to be too short, or if we've been given
* insufficient input. In general this exception will Get thrown rather
* than an ArrayOutOfBounds exception.
*/
#if !(NETCF_1_0 || NETCF_2_0 || SILVERLIGHT)
[Serializable]
#endif
public class DataLengthException
: CryptoException
{
/**
* base constructor.
*/
public DataLengthException()
{
}
/**
* create a DataLengthException with the given message.
*
* @param message the message to be carried with the exception.
*/
public DataLengthException(
string message)
: base(message)
{
}
public DataLengthException(
string message,
Exception exception)
: base(message, exception)
{
}
}
}

36
MinecraftClient/Crypto/Streams/BouncyAes/IBlockCipher.cs
View file

@ -1,36 +0,0 @@
using System;
namespace Org.BouncyCastle.Crypto
{
/// <remarks>Base interface for a symmetric key block cipher.</remarks>
public interface IBlockCipher
{
/// <summary>The name of the algorithm this cipher implements.</summary>
string AlgorithmName { get; }
/// <summary>Initialise the cipher.</summary>
/// <param name="forEncryption">Initialise for encryption if true, for decryption if false.</param>
/// <param name="parameters">The key or other data required by the cipher.</param>
void Init(bool forEncryption, ICipherParameters parameters);
/// <returns>The block size for this cipher, in bytes.</returns>
int GetBlockSize();
/// <summary>Indicates whether this cipher can handle partial blocks.</summary>
bool IsPartialBlockOkay { get; }
/// <summary>Process a block.</summary>
/// <param name="inBuf">The input buffer.</param>
/// <param name="inOff">The offset into <paramref>inBuf</paramref> that the input block begins.</param>
/// <param name="outBuf">The output buffer.</param>
/// <param name="outOff">The offset into <paramref>outBuf</paramref> to write the output block.</param>
/// <exception cref="DataLengthException">If input block is wrong size, or outBuf too small.</exception>
/// <returns>The number of bytes processed and produced.</returns>
int ProcessBlock(byte[] inBuf, int inOff, byte[] outBuf, int outOff);
/// <summary>
/// Reset the cipher to the same state as it was after the last init (if there was one).
/// </summary>
void Reset();
}
}

44
MinecraftClient/Crypto/Streams/BouncyAes/IBufferedCipher.cs
View file

@ -1,44 +0,0 @@
using System;
namespace Org.BouncyCastle.Crypto
{
/// <remarks>Block cipher engines are expected to conform to this interface.</remarks>
public interface IBufferedCipher
{
/// <summary>The name of the algorithm this cipher implements.</summary>
string AlgorithmName { get; }
/// <summary>Initialise the cipher.</summary>
/// <param name="forEncryption">If true the cipher is initialised for encryption,
/// if false for decryption.</param>
/// <param name="parameters">The key and other data required by the cipher.</param>
void Init(bool forEncryption, ICipherParameters parameters);
int GetBlockSize();
int GetOutputSize(int inputLen);
int GetUpdateOutputSize(int inputLen);
byte[] ProcessByte(byte input);
int ProcessByte(byte input, byte[] output, int outOff);
byte[] ProcessBytes(byte[] input);
byte[] ProcessBytes(byte[] input, int inOff, int length);
int ProcessBytes(byte[] input, byte[] output, int outOff);
int ProcessBytes(byte[] input, int inOff, int length, byte[] output, int outOff);
byte[] DoFinal();
byte[] DoFinal(byte[] input);
byte[] DoFinal(byte[] input, int inOff, int length);
int DoFinal(byte[] output, int outOff);
int DoFinal(byte[] input, byte[] output, int outOff);
int DoFinal(byte[] input, int inOff, int length, byte[] output, int outOff);
/// <summary>
/// Reset the cipher. After resetting the cipher is in the same state
/// as it was after the last init (if there was one).
/// </summary>
void Reset();
}
}

11
MinecraftClient/Crypto/Streams/BouncyAes/ICipherParameters.cs
View file

@ -1,11 +0,0 @@
using System;
namespace Org.BouncyCastle.Crypto
{
/**
* all parameter classes implement this.
*/
public interface ICipherParameters
{
}
}

43
MinecraftClient/Crypto/Streams/BouncyAes/KeyParameter.cs
View file

@ -1,43 +0,0 @@
using System;
using Org.BouncyCastle.Crypto;
namespace Org.BouncyCastle.Crypto.Parameters
{
public class KeyParameter
: ICipherParameters
{
private readonly byte[] key;
public KeyParameter(
byte[] key)
{
if (key == null)
throw new ArgumentNullException("key");
this.key = (byte[]) key.Clone();
}
public KeyParameter(
byte[] key,
int keyOff,
int keyLen)
{
if (key == null)
throw new ArgumentNullException("key");
if (keyOff < 0 || keyOff > key.Length)
throw new ArgumentOutOfRangeException("keyOff");
if (keyLen < 0 || (keyOff + keyLen) > key.Length)
throw new ArgumentOutOfRangeException("keyLen");
this.key = new byte[keyLen];
Array.Copy(key, keyOff, this.key, 0, keyLen);
}
public byte[] GetKey()
{
return (byte[]) key.Clone();
}
}
}

28
MinecraftClient/Crypto/Streams/BouncyAes/OutputLengthException.cs
View file

@ -1,28 +0,0 @@
using System;
namespace Org.BouncyCastle.Crypto
{
#if !(NETCF_1_0 || NETCF_2_0 || SILVERLIGHT)
[Serializable]
#endif
public class OutputLengthException
: DataLengthException
{
public OutputLengthException()
{
}
public OutputLengthException(
string message)
: base(message)
{
}
public OutputLengthException(
string message,
Exception exception)
: base(message, exception)
{
}
}
}

266
MinecraftClient/Crypto/Streams/BouncyAes/Pack.cs
View file

@ -1,266 +0,0 @@
using System;
namespace Org.BouncyCastle.Crypto.Utilities
{
internal sealed class Pack
{
private Pack()
{
}
internal static void UInt16_To_BE(ushort n, byte[] bs)
{
bs[0] = (byte)(n >> 8);
bs[1] = (byte)(n);
}
internal static void UInt16_To_BE(ushort n, byte[] bs, int off)
{
bs[off] = (byte)(n >> 8);
bs[off + 1] = (byte)(n);
}
internal static ushort BE_To_UInt16(byte[] bs)
{
uint n = (uint)bs[0] << 8
| (uint)bs[1];
return (ushort)n;
}
internal static ushort BE_To_UInt16(byte[] bs, int off)
{
uint n = (uint)bs[off] << 8
| (uint)bs[off + 1];
return (ushort)n;
}
internal static byte[] UInt32_To_BE(uint n)
{
byte[] bs = new byte[4];
UInt32_To_BE(n, bs, 0);
return bs;
}
internal static void UInt32_To_BE(uint n, byte[] bs)
{
bs[0] = (byte)(n >> 24);
bs[1] = (byte)(n >> 16);
bs[2] = (byte)(n >> 8);
bs[3] = (byte)(n);
}
internal static void UInt32_To_BE(uint n, byte[] bs, int off)
{
bs[off] = (byte)(n >> 24);
bs[off + 1] = (byte)(n >> 16);
bs[off + 2] = (byte)(n >> 8);
bs[off + 3] = (byte)(n);
}
internal static byte[] UInt32_To_BE(uint[] ns)
{
byte[] bs = new byte[4 * ns.Length];
UInt32_To_BE(ns, bs, 0);
return bs;
}
internal static void UInt32_To_BE(uint[] ns, byte[] bs, int off)
{
for (int i = 0; i < ns.Length; ++i)
{
UInt32_To_BE(ns[i], bs, off);
off += 4;
}
}
internal static uint BE_To_UInt32(byte[] bs)
{
return (uint)bs[0] << 24
| (uint)bs[1] << 16
| (uint)bs[2] << 8
| (uint)bs[3];
}
internal static uint BE_To_UInt32(byte[] bs, int off)
{
return (uint)bs[off] << 24
| (uint)bs[off + 1] << 16
| (uint)bs[off + 2] << 8
| (uint)bs[off + 3];
}
internal static void BE_To_UInt32(byte[] bs, int off, uint[] ns)
{
for (int i = 0; i < ns.Length; ++i)
{
ns[i] = BE_To_UInt32(bs, off);
off += 4;
}
}
internal static byte[] UInt64_To_BE(ulong n)
{
byte[] bs = new byte[8];
UInt64_To_BE(n, bs, 0);
return bs;
}
internal static void UInt64_To_BE(ulong n, byte[] bs)
{
UInt32_To_BE((uint)(n >> 32), bs);
UInt32_To_BE((uint)(n), bs, 4);
}
internal static void UInt64_To_BE(ulong n, byte[] bs, int off)
{
UInt32_To_BE((uint)(n >> 32), bs, off);
UInt32_To_BE((uint)(n), bs, off + 4);
}
internal static ulong BE_To_UInt64(byte[] bs)
{
uint hi = BE_To_UInt32(bs);
uint lo = BE_To_UInt32(bs, 4);
return ((ulong)hi << 32) | (ulong)lo;
}
internal static ulong BE_To_UInt64(byte[] bs, int off)
{
uint hi = BE_To_UInt32(bs, off);
uint lo = BE_To_UInt32(bs, off + 4);
return ((ulong)hi << 32) | (ulong)lo;
}
internal static void UInt16_To_LE(ushort n, byte[] bs)
{
bs[0] = (byte)(n);
bs[1] = (byte)(n >> 8);
}
internal static void UInt16_To_LE(ushort n, byte[] bs, int off)
{
bs[off] = (byte)(n);
bs[off + 1] = (byte)(n >> 8);
}
internal static ushort LE_To_UInt16(byte[] bs)
{
uint n = (uint)bs[0]
| (uint)bs[1] << 8;
return (ushort)n;
}
internal static ushort LE_To_UInt16(byte[] bs, int off)
{
uint n = (uint)bs[off]
| (uint)bs[off + 1] << 8;
return (ushort)n;
}
internal static byte[] UInt32_To_LE(uint n)
{
byte[] bs = new byte[4];
UInt32_To_LE(n, bs, 0);
return bs;
}
internal static void UInt32_To_LE(uint n, byte[] bs)
{
bs[0] = (byte)(n);
bs[1] = (byte)(n >> 8);
bs[2] = (byte)(n >> 16);
bs[3] = (byte)(n >> 24);
}
internal static void UInt32_To_LE(uint n, byte[] bs, int off)
{
bs[off] = (byte)(n);
bs[off + 1] = (byte)(n >> 8);
bs[off + 2] = (byte)(n >> 16);
bs[off + 3] = (byte)(n >> 24);
}
internal static byte[] UInt32_To_LE(uint[] ns)
{
byte[] bs = new byte[4 * ns.Length];
UInt32_To_LE(ns, bs, 0);
return bs;
}
internal static void UInt32_To_LE(uint[] ns, byte[] bs, int off)
{
for (int i = 0; i < ns.Length; ++i)
{
UInt32_To_LE(ns[i], bs, off);
off += 4;
}
}
internal static uint LE_To_UInt32(byte[] bs)
{
return (uint)bs[0]
| (uint)bs[1] << 8
| (uint)bs[2] << 16
| (uint)bs[3] << 24;
}
internal static uint LE_To_UInt32(byte[] bs, int off)
{
return (uint)bs[off]
| (uint)bs[off + 1] << 8
| (uint)bs[off + 2] << 16
| (uint)bs[off + 3] << 24;
}
internal static void LE_To_UInt32(byte[] bs, int off, uint[] ns)
{
for (int i = 0; i < ns.Length; ++i)
{
ns[i] = LE_To_UInt32(bs, off);
off += 4;
}
}
internal static void LE_To_UInt32(byte[] bs, int bOff, uint[] ns, int nOff, int count)
{
for (int i = 0; i < count; ++i)
{
ns[nOff + i] = LE_To_UInt32(bs, bOff);
bOff += 4;
}
}
internal static byte[] UInt64_To_LE(ulong n)
{
byte[] bs = new byte[8];
UInt64_To_LE(n, bs, 0);
return bs;
}
internal static void UInt64_To_LE(ulong n, byte[] bs)
{
UInt32_To_LE((uint)(n), bs);
UInt32_To_LE((uint)(n >> 32), bs, 4);
}
internal static void UInt64_To_LE(ulong n, byte[] bs, int off)
{
UInt32_To_LE((uint)(n), bs, off);
UInt32_To_LE((uint)(n >> 32), bs, off + 4);
}
internal static ulong LE_To_UInt64(byte[] bs)
{
uint lo = LE_To_UInt32(bs);
uint hi = LE_To_UInt32(bs, 4);
return ((ulong)hi << 32) | (ulong)lo;
}
internal static ulong LE_To_UInt64(byte[] bs, int off)
{
uint lo = LE_To_UInt32(bs, off);
uint hi = LE_To_UInt32(bs, off + 4);
return ((ulong)hi << 32) | (ulong)lo;
}
}
}

43
MinecraftClient/Crypto/Streams/BouncyAes/ParametersWithIV.cs
View file

@ -1,43 +0,0 @@
using System;
namespace Org.BouncyCastle.Crypto.Parameters
{
public class ParametersWithIV
: ICipherParameters
{
private readonly ICipherParameters parameters;
private readonly byte[] iv;
public ParametersWithIV(
ICipherParameters parameters,
byte[] iv)
: this(parameters, iv, 0, iv.Length)
{
}
public ParametersWithIV(
ICipherParameters parameters,
byte[] iv,
int ivOff,
int ivLen)
{
// NOTE: 'parameters' may be null to imply key re-use
if (iv == null)
throw new ArgumentNullException("iv");
this.parameters = parameters;
this.iv = new byte[ivLen];
Array.Copy(iv, ivOff, this.iv, 0, ivLen);
}
public byte[] GetIV()
{
return (byte[]) iv.Clone();
}
public ICipherParameters Parameters
{
get { return parameters; }
}
}
}

108
MinecraftClient/Crypto/Streams/MonoAesStream.cs
View file

@ -1,108 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
using System.IO;
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Crypto.Engines;
using Org.BouncyCastle.Crypto.Modes;
using Org.BouncyCastle.Crypto.IO;
namespace MinecraftClient.Crypto.Streams
{
/// <summary>
/// An encrypted stream using AES, used for encrypting network data on the fly using AES.
/// This is a mono-compatible adaptation which uses AES engine from the BouncyCastle project.
/// </summary>
public class MonoAesStream : Stream, IAesStream
{
CipherStream cstream;
public MonoAesStream(System.IO.Stream stream, byte[] key)
{
BaseStream = stream;
BufferedBlockCipher enc = GenerateAES(key, true);
BufferedBlockCipher dec = GenerateAES(key, false);
cstream = new CipherStream(stream, dec, enc);
}
public System.IO.Stream BaseStream { get; set; }
public override bool CanRead
{
get { return true; }
}
public override bool CanSeek
{
get { return false; }
}
public override bool CanWrite
{
get { return true; }
}
public override void Flush()
{
BaseStream.Flush();
}
public override long Length
{
get { throw new NotSupportedException(); }
}
public override long Position
{
get
{
throw new NotSupportedException();
}
set
{
throw new NotSupportedException();
}
}
public override int ReadByte()
{
byte[] temp = new byte[1];
Read(temp, 0, 1);
return temp[0];
}
public override int Read(byte[] buffer, int offset, int count)
{
return cstream.Read(buffer, offset, count);
}
public override long Seek(long offset, System.IO.SeekOrigin origin)
{
throw new NotSupportedException();
}
public override void SetLength(long value)
{
throw new NotSupportedException();
}
public override void WriteByte(byte b)
{
Write(new byte[] { b }, 0, 1);
}
public override void Write(byte[] buffer, int offset, int count)
{
cstream.Write(buffer, offset, count);
}
private BufferedBlockCipher GenerateAES(byte[] key, bool forEncryption)
{
BufferedBlockCipher cipher = new BufferedBlockCipher(new CfbBlockCipher(new AesFastEngine(), 8));
cipher.Init(forEncryption, new ParametersWithIV(new KeyParameter(key), key));
return cipher;
}
}
}

33
MinecraftClient/FileMonitor.cs
View file

@ -11,8 +11,8 @@ namespace MinecraftClient
/// </summary>
public class FileMonitor : IDisposable
{
private FileSystemWatcher monitor = null;
private Thread polling = null;
private Tuple<FileSystemWatcher, CancellationTokenSource>? monitor = null;
private Tuple<Thread, CancellationTokenSource>? polling = null;
/// <summary>
/// Create a new FileMonitor and start monitoring
@ -30,13 +30,13 @@ namespace MinecraftClient
try
{
monitor = new FileSystemWatcher();
monitor.Path = folder;
monitor.IncludeSubdirectories = false;
monitor.Filter = filename;
monitor.NotifyFilter = NotifyFilters.LastWrite;
monitor.Changed += handler;
monitor.EnableRaisingEvents = true;
monitor = new Tuple<FileSystemWatcher, CancellationTokenSource>(new FileSystemWatcher(), new CancellationTokenSource());
monitor.Item1.Path = folder;
monitor.Item1.IncludeSubdirectories = false;
monitor.Item1.Filter = filename;
monitor.Item1.NotifyFilter = NotifyFilters.LastWrite;
monitor.Item1.Changed += handler;
monitor.Item1.EnableRaisingEvents = true;
}
catch
{
@ -47,9 +47,10 @@ namespace MinecraftClient
}
monitor = null;
polling = new Thread(() => PollingThread(folder, filename, handler));
polling.Name = String.Format("{0} Polling thread: {1}", this.GetType().Name, Path.Combine(folder, filename));
polling.Start();
var cancellationTokenSource = new CancellationTokenSource();
polling = new Tuple<Thread, CancellationTokenSource>(new Thread(() => PollingThread(folder, filename, handler, cancellationTokenSource.Token)), cancellationTokenSource);
polling.Item1.Name = String.Format("{0} Polling thread: {1}", this.GetType().Name, Path.Combine(folder, filename));
polling.Item1.Start();
}
}
@ -59,9 +60,9 @@ namespace MinecraftClient
public void Dispose()
{
if (monitor != null)
monitor.Dispose();
monitor.Item1.Dispose();
if (polling != null)
polling.Abort();
polling.Item2.Cancel();
}
/// <summary>
@ -70,11 +71,11 @@ namespace MinecraftClient
/// <param name="folder">Folder to monitor</param>
/// <param name="filename">File name to monitor</param>
/// <param name="handler">Callback when file changes</param>
private void PollingThread(string folder, string filename, FileSystemEventHandler handler)
private void PollingThread(string folder, string filename, FileSystemEventHandler handler, CancellationToken cancellationToken)
{
string filePath = Path.Combine(folder, filename);
DateTime lastWrite = GetLastWrite(filePath);
while (true)
while (!cancellationToken.IsCancellationRequested)
{
Thread.Sleep(5000);
DateTime lastWriteNew = GetLastWrite(filePath);

95
MinecraftClient/McClient.cs
View file

@ -122,8 +122,8 @@ namespace MinecraftClient
TcpClient client;
IMinecraftCom handler;
Thread cmdprompt;
Thread timeoutdetector;
CancellationTokenSource cmdprompt = null;
Tuple<Thread, CancellationTokenSource>? timeoutdetector = null;
public ILogger Log;
@ -227,11 +227,11 @@ namespace MinecraftClient
handler = Protocol.ProtocolHandler.GetProtocolHandler(client, protocolversion, forgeInfo, this);
Log.Info(Translations.Get("mcc.version_supported"));
if (!singlecommand)
if (!singlecommand)
{
timeoutdetector = new Thread(new ThreadStart(TimeoutDetector));
timeoutdetector.Name = "MCC Connection timeout detector";
timeoutdetector.Start();
timeoutdetector = new(new Thread(new ParameterizedThreadStart(TimeoutDetector)), new CancellationTokenSource());
timeoutdetector.Item1.Name = "MCC Connection timeout detector";
timeoutdetector.Item1.Start(timeoutdetector.Item2.Token);
}
try
@ -254,9 +254,10 @@ namespace MinecraftClient
Log.Info(Translations.Get("mcc.joined", (Settings.internalCmdChar == ' ' ? "" : "" + Settings.internalCmdChar)));
cmdprompt = new Thread(new ThreadStart(CommandPrompt));
cmdprompt.Name = "MCC Command prompt";
cmdprompt.Start();
cmdprompt = new CancellationTokenSource();
ConsoleInteractive.ConsoleReader.BeginReadThread(cmdprompt);
ConsoleInteractive.ConsoleReader.MessageReceived += ConsoleReaderOnMessageReceived;
ConsoleInteractive.ConsoleReader.OnKeyInput += ConsoleIO.AutocompleteHandler;
}
}
else
@ -283,7 +284,7 @@ namespace MinecraftClient
{
if (timeoutdetector != null)
{
timeoutdetector.Abort();
timeoutdetector.Item2.Cancel();
timeoutdetector = null;
}
if (ReconnectionAttemptsLeft > 0)
@ -293,8 +294,11 @@ namespace MinecraftClient
ReconnectionAttemptsLeft--;
Program.Restart();
}
else if (!singlecommand && Settings.interactiveMode)
else if (!singlecommand && Settings.interactiveMode)
{
ConsoleInteractive.ConsoleReader.StopReadThread();
ConsoleInteractive.ConsoleReader.MessageReceived -= ConsoleReaderOnMessageReceived;
ConsoleInteractive.ConsoleReader.OnKeyInput -= ConsoleIO.AutocompleteHandler;
Program.HandleFailure();
}
}
@ -392,22 +396,29 @@ namespace MinecraftClient
/// <summary>
/// Periodically checks for server keepalives and consider that connection has been lost if the last received keepalive is too old.
/// </summary>
private void TimeoutDetector()
private void TimeoutDetector(object? o)
{
UpdateKeepAlive();
do
{
Thread.Sleep(TimeSpan.FromSeconds(15));
if (((CancellationToken)o!).IsCancellationRequested)
return;
lock (lastKeepAliveLock)
{
if (lastKeepAlive.AddSeconds(30) < DateTime.Now)
{
if (((CancellationToken)o!).IsCancellationRequested)
return;
OnConnectionLost(ChatBot.DisconnectReason.ConnectionLost, Translations.Get("error.timeout"));
return;
}
}
}
while (true);
while (! ( (CancellationToken)o! ).IsCancellationRequested);
}
/// <summary>
@ -437,12 +448,15 @@ namespace MinecraftClient
handler.Dispose();
}
if (cmdprompt != null)
cmdprompt.Abort();
if (timeoutdetector != null)
if (cmdprompt != null)
{
timeoutdetector.Abort();
cmdprompt.Cancel();
cmdprompt = null;
}
if (timeoutdetector != null)
{
timeoutdetector.Item2.Cancel();
timeoutdetector = null;
}
@ -459,8 +473,8 @@ namespace MinecraftClient
if (timeoutdetector != null)
{
if (Thread.CurrentThread != timeoutdetector)
timeoutdetector.Abort();
if (Thread.CurrentThread != timeoutdetector.Item1)
timeoutdetector.Item2.Cancel();
timeoutdetector = null;
}
@ -507,32 +521,35 @@ namespace MinecraftClient
}
}
if (!will_restart)
if (!will_restart)
{
ConsoleInteractive.ConsoleReader.StopReadThread();
ConsoleInteractive.ConsoleReader.MessageReceived -= ConsoleReaderOnMessageReceived;
ConsoleInteractive.ConsoleReader.OnKeyInput -= ConsoleIO.AutocompleteHandler;
Program.HandleFailure();
}
}
#endregion
#region Command prompt and internal MCC commands
/// <summary>
/// Allows the user to send chat messages, commands, and leave the server.
/// </summary>
private void CommandPrompt()
private void ConsoleReaderOnMessageReceived(object? sender, string e)
{
try
{
Thread.Sleep(500);
while (client.Client.Connected)
{
string text = ConsoleIO.ReadLine();
InvokeOnMainThread(() => HandleCommandPromptText(text));
}
}
catch (IOException) { }
catch (NullReferenceException) { }
}
if (client.Client == null)
return;
if (client.Client.Connected)
{
new Thread(() => {
InvokeOnMainThread(() => HandleCommandPromptText(e));
}).Start();
}
else
return;
}
/// <summary>
/// Allows the user to send chat messages, commands, and leave the server.
/// Process text from the MCC command prompt on the main thread.
@ -547,7 +564,7 @@ namespace MinecraftClient
{
case "autocomplete":
if (command.Length > 1) { ConsoleIO.WriteLine((char)0x00 + "autocomplete" + (char)0x00 + handler.AutoComplete(command[1])); }
else Console.WriteLine((char)0x00 + "autocomplete" + (char)0x00);
else ConsoleIO.WriteLine((char)0x00 + "autocomplete" + (char)0x00);
break;
}
}

493
MinecraftClient/MinecraftClient.csproj
View file

@ -1,429 +1,64 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">x86</Platform>
<ProductVersion>8.0.30703</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{1E2FACE4-F5CA-4323-9641-740C6A551770}</ProjectGuid>
<OutputType>Exe</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>MinecraftClient</RootNamespace>
<AssemblyName>MinecraftClient</AssemblyName>
<TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
<TargetFrameworkProfile>Client</TargetFrameworkProfile>
<FileAlignment>512</FileAlignment>
<PublishUrl>publish\</PublishUrl>
<Install>true</Install>
<InstallFrom>Disk</InstallFrom>
<UpdateEnabled>false</UpdateEnabled>
<UpdateMode>Foreground</UpdateMode>
<UpdateInterval>7</UpdateInterval>
<UpdateIntervalUnits>Days</UpdateIntervalUnits>
<UpdatePeriodically>false</UpdatePeriodically>
<UpdateRequired>false</UpdateRequired>
<MapFileExtensions>true</MapFileExtensions>
<ApplicationRevision>0</ApplicationRevision>
<ApplicationVersion>1.0.0.%2a</ApplicationVersion>
<IsWebBootstrapper>false</IsWebBootstrapper>
<UseApplicationTrust>false</UseApplicationTrust>
<BootstrapperEnabled>true</BootstrapperEnabled>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
<PlatformTarget>x86</PlatformTarget>
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
<PlatformTarget>x86</PlatformTarget>
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup />
<PropertyGroup>
<SignManifests>false</SignManifests>
</PropertyGroup>
<PropertyGroup>
<ApplicationIcon>Resources\AppIcon.ico</ApplicationIcon>
</PropertyGroup>
<PropertyGroup>
<StartupObject>MinecraftClient.Program</StartupObject>
</PropertyGroup>
<PropertyGroup />
<ItemGroup>
<Reference Include="System" />
<Reference Include="System.Core" />
<Reference Include="System.Drawing" />
<Reference Include="System.Runtime.Serialization" />
<Reference Include="System.Windows.Forms" />
<Reference Include="System.Xml.Linq" />
<Reference Include="System.Data.DataSetExtensions" />
<Reference Include="Microsoft.CSharp" />
<Reference Include="System.Data" />
<Reference Include="System.Xml" />
</ItemGroup>
<ItemGroup>
<Compile Include="AutoTimeout.cs" />
<Compile Include="ChatBots\AutoDrop.cs" />
<Compile Include="ChatBots\Mailer.cs" />
<Compile Include="Commands\SetRnd.cs" />
<Compile Include="Protocol\JwtPayloadDecode.cs" />
<Compile Include="Protocol\Handlers\PacketPalettes\PacketPalette118.cs" />
<Compile Include="Protocol\MojangAPI.cs" />
<Compile Include="Mapping\CubeFromWorld.cs" />
<Compile Include="Mapping\Material2Tool.cs" />
<Compile Include="ChatBots\ReplayCapture.cs" />
<Compile Include="Commands\DropItem.cs" />
<Compile Include="Commands\Entitycmd.cs" />
<Compile Include="ChatBots\Alerts.cs" />
<Compile Include="ChatBots\AntiAFK.cs" />
<Compile Include="ChatBots\AutoAttack.cs" />
<Compile Include="ChatBots\AutoCraft.cs" />
<Compile Include="ChatBots\AutoEat.cs" />
<Compile Include="ChatBots\AutoFishing.cs" />
<Compile Include="ChatBots\AutoRespond.cs" />
<Compile Include="ChatBots\AutoRelog.cs" />
<Compile Include="ChatBots\ChatLog.cs" />
<Compile Include="ChatBots\HangmanGame.cs" />
<Compile Include="ChatBots\PlayerListLogger.cs" />
<Compile Include="ChatBots\RemoteControl.cs" />
<Compile Include="ChatBots\Script.cs" />
<Compile Include="ChatBots\ScriptScheduler.cs" />
<Compile Include="ChatBots\TestBot.cs" />
<Compile Include="ChatBot.cs" />
<Compile Include="Command.cs" />
<Compile Include="Commands\Animation.cs" />
<Compile Include="Commands\ChangeSlot.cs" />
<Compile Include="Commands\Connect.cs" />
<Compile Include="Commands\Debug.cs" />
<Compile Include="Commands\Dig.cs" />
<Compile Include="Commands\Inventory.cs" />
<Compile Include="Commands\Look.cs" />
<Compile Include="Commands\Move.cs" />
<Compile Include="Commands\Exit.cs" />
<Compile Include="Commands\Log.cs" />
<Compile Include="Commands\Reco.cs" />
<Compile Include="Commands\Respawn.cs" />
<Compile Include="Commands\Script.cs" />
<Compile Include="Commands\Send.cs" />
<Compile Include="Commands\Set.cs" />
<Compile Include="Commands\Health.cs" />
<Compile Include="Commands\Sneak.cs" />
<Compile Include="Commands\Tps.cs" />
<Compile Include="Commands\Useblock.cs" />
<Compile Include="Commands\UseItem.cs" />
<Compile Include="DefaultConfigResource.Designer.cs">
<AutoGen>True</AutoGen>
<DesignTime>True</DesignTime>
<DependentUpon>DefaultConfigResource.resx</DependentUpon>
</Compile>
<Compile Include="Logger\FileLogLogger.cs" />
<Compile Include="Logger\ILogger.cs" />
<Compile Include="INIFile.cs" />
<Compile Include="Inventory\Container.cs" />
<Compile Include="Inventory\ContainerType.cs" />
<Compile Include="Inventory\ContainerTypeExtensions.cs" />
<Compile Include="Inventory\Effects.cs" />
<Compile Include="Inventory\Hand.cs" />
<Compile Include="Inventory\Item.cs" />
<Compile Include="Inventory\ItemMovingHelper.cs" />
<Compile Include="Inventory\ItemPalettes\ItemPalette.cs" />
<Compile Include="Inventory\ItemPalettes\ItemPalette115.cs" />
<Compile Include="Inventory\ItemPalettes\ItemPalette1161.cs" />
<Compile Include="Inventory\ItemPalettes\ItemPalette1162.cs" />
<Compile Include="Inventory\ItemPalettes\ItemPaletteGenerator.cs" />
<Compile Include="Inventory\ItemType.cs" />
<Compile Include="Inventory\ItemTypeExtensions.cs" />
<Compile Include="Inventory\WindowActionType.cs" />
<Compile Include="Logger\LoggerBase.cs" />
<Compile Include="Mapping\BlockPalettes\Palette112.cs" />
<Compile Include="Mapping\BlockPalettes\Palette113.cs" />
<Compile Include="Mapping\BlockPalettes\Palette114.cs" />
<Compile Include="Mapping\BlockPalettes\Palette115.cs" />
<Compile Include="Mapping\BlockPalettes\BlockPaletteGenerator.cs" />
<Compile Include="Mapping\BlockPalettes\BlockPalette.cs" />
<Compile Include="Mapping\BlockPalettes\Palette116.cs" />
<Compile Include="Mapping\CommandBlockFlags.cs" />
<Compile Include="Mapping\CommandBlockMode.cs" />
<Compile Include="Mapping\Entity.cs" />
<Compile Include="Mapping\EntityPalettes\EntityPalette112.cs" />
<Compile Include="Mapping\EntityPalettes\EntityPalette113.cs" />
<Compile Include="Mapping\EntityPalettes\EntityPalette.cs" />
<Compile Include="Mapping\EntityPalettes\EntityPalette114.cs" />
<Compile Include="Mapping\EntityPalettes\EntityPalette115.cs" />
<Compile Include="Mapping\EntityPalettes\EntityPalette1161.cs" />
<Compile Include="Mapping\EntityPalettes\EntityPalette1162.cs" />
<Compile Include="Mapping\EntityPose.cs" />
<Compile Include="Mapping\EntityType.cs" />
<Compile Include="Mapping\EntityPalettes\EntityPaletteGenerator.cs" />
<Compile Include="Mapping\EntityTypeExtensions.cs" />
<Compile Include="Mapping\MaterialExtensions.cs" />
<Compile Include="Logger\FilteredLogger.cs" />
<Compile Include="Protocol\EntityActionType.cs" />
<Compile Include="Protocol\GuidExtensions.cs" />
<Compile Include="Protocol\Handlers\Compression\DeflateStream.cs" />
<Compile Include="Protocol\Handlers\Compression\ParallelDeflateOutputStream.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\ComHelper.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\EncryptionAlgorithm.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\Events.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\Exceptions.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\ExtractExistingFileAction.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\FileSelector.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\OffsetStream.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\Shared.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\WinZipAes.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\ZipConstants.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\ZipCrypto.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\ZipDirEntry.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\ZipEntry.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\ZipEntry.Extract.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\ZipEntry.Read.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\ZipEntry.Write.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\ZipEntrySource.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\ZipErrorAction.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\ZipFile.AddUpdate.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\ZipFile.Check.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\ZipFile.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\ZipFile.Events.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\ZipFile.Extract.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\ZipFile.Read.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\ZipFile.Save.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\ZipFile.SaveSelfExtractor.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\ZipFile.Selector.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\ZipFile.x-IEnumerable.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\ZipInputStream.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\ZipOutputStream.cs" />
<Compile Include="Protocol\Handlers\Compression\Zip\ZipSegmentedStream.cs" />
<Compile Include="Protocol\Handlers\DataTypes.cs" />
<Compile Include="Protocol\Handlers\Forge\FMLVersion.cs" />
<Compile Include="Protocol\Handlers\PacketPalettes\PacketPalette110.cs" />
<Compile Include="Protocol\Handlers\PacketPalettes\PacketPalette112.cs" />
<Compile Include="Protocol\Handlers\PacketPalettes\PacketPalette1122.cs" />
<Compile Include="Protocol\Handlers\PacketPalettes\PacketPalette113.cs" />
<Compile Include="Protocol\Handlers\PacketPalettes\PacketPalette114.cs" />
<Compile Include="Protocol\Handlers\PacketPalettes\PacketPalette115.cs" />
<Compile Include="Protocol\Handlers\PacketPalettes\PacketPalette116.cs" />
<Compile Include="Protocol\Handlers\PacketPalettes\PacketPalette1162.cs" />
<Compile Include="Protocol\Handlers\PacketPalettes\PacketPalette117.cs" />
<Compile Include="Protocol\Handlers\PacketPalettes\PacketPalette17.cs" />
<Compile Include="Protocol\Handlers\PacketPalettes\PacketPaletteHelper.cs" />
<Compile Include="Protocol\Handlers\PacketType18Handler.cs" />
<Compile Include="Protocol\Handlers\PacketPalettes\PacketTypePalette.cs" />
<Compile Include="Protocol\Handlers\PacketTypesIn.cs" />
<Compile Include="Protocol\Handlers\PacketTypesOut.cs" />
<Compile Include="Protocol\Handlers\Protocol18Forge.cs" />
<Compile Include="Protocol\Handlers\Protocol18Terrain.cs" />
<Compile Include="Protocol\Handlers\SocketWrapper.cs" />
<Compile Include="Protocol\DataTypeGenerator.cs" />
<Compile Include="FileMonitor.cs" />
<Compile Include="Inventory\VillagerTrade.cs" />
<Compile Include="Protocol\MicrosoftAuthentication.cs" />
<Compile Include="Protocol\ProxiedWebRequest.cs" />
<Compile Include="Protocol\ReplayHandler.cs" />
<Compile Include="TaskWithDelay.cs" />
<Compile Include="TaskWithResult.cs" />
<Compile Include="Translations.cs" />
<Compile Include="Inventory\VillagerInfo.cs" />
<Compile Include="WinAPI\ConsoleIcon.cs" />
<Compile Include="ConsoleIO.cs" />
<Compile Include="Crypto\Streams\BouncyAes\AesFastEngine.cs" />
<Compile Include="Crypto\Streams\BouncyAes\BufferedBlockCipher.cs" />
<Compile Include="Crypto\Streams\BouncyAes\BufferedCipherBase.cs" />
<Compile Include="Crypto\Streams\BouncyAes\CfbBlockCipher.cs" />
<Compile Include="Crypto\Streams\BouncyAes\Check.cs" />
<Compile Include="Crypto\Streams\BouncyAes\CipherStream.cs" />
<Compile Include="Crypto\Streams\BouncyAes\CryptoException.cs" />
<Compile Include="Crypto\Streams\BouncyAes\DataLengthException.cs" />
<Compile Include="Crypto\Streams\BouncyAes\IBlockCipher.cs" />
<Compile Include="Crypto\Streams\BouncyAes\IBufferedCipher.cs" />
<Compile Include="Crypto\Streams\BouncyAes\ICipherParameters.cs" />
<Compile Include="Crypto\Streams\BouncyAes\KeyParameter.cs" />
<Compile Include="Crypto\Streams\BouncyAes\OutputLengthException.cs" />
<Compile Include="Crypto\Streams\BouncyAes\Pack.cs" />
<Compile Include="Crypto\Streams\BouncyAes\ParametersWithIV.cs" />
<Compile Include="Crypto\Streams\MonoAesStream.cs" />
<Compile Include="Crypto\Streams\RegularAesStream.cs" />
<Compile Include="Crypto\CryptoHandler.cs" />
<Compile Include="CSharpRunner.cs" />
<Compile Include="Json.cs" />
<Compile Include="Mapping\Block.cs" />
<Compile Include="Mapping\Chunk.cs" />
<Compile Include="Mapping\ChunkColumn.cs" />
<Compile Include="Mapping\Direction.cs" />
<Compile Include="Mapping\Material.cs" />
<Compile Include="Mapping\Movement.cs" />
<Compile Include="Mapping\World.cs" />
<Compile Include="Protocol\ChatParser.cs" />
<Compile Include="Protocol\Dns\Header.cs" />
<Compile Include="Protocol\Dns\Question.cs" />
<Compile Include="Protocol\Dns\RecordReader.cs" />
<Compile Include="Protocol\Dns\Records\NotUsed\RecordA6.cs" />
<Compile Include="Protocol\Dns\Records\NotUsed\RecordAPL.cs" />
<Compile Include="Protocol\Dns\Records\NotUsed\RecordATMA.cs" />
<Compile Include="Protocol\Dns\Records\NotUsed\RecordCERT.cs" />
<Compile Include="Protocol\Dns\Records\NotUsed\RecordDHCID.cs" />
<Compile Include="Protocol\Dns\Records\NotUsed\RecordDNSKEY.cs" />
<Compile Include="Protocol\Dns\Records\NotUsed\RecordEID.cs" />
<Compile Include="Protocol\Dns\Records\NotUsed\RecordGID.cs" />
<Compile Include="Protocol\Dns\Records\NotUsed\RecordHIP.cs" />
<Compile Include="Protocol\Dns\Records\NotUsed\RecordIPSECKEY.cs" />
<Compile Include="Protocol\Dns\Records\NotUsed\RecordNIMLOC.cs" />
<Compile Include="Protocol\Dns\Records\NotUsed\RecordNSEC.cs" />
<Compile Include="Protocol\Dns\Records\NotUsed\RecordNSEC3.cs" />
<Compile Include="Protocol\Dns\Records\NotUsed\RecordNSEC3PARAM.cs" />
<Compile Include="Protocol\Dns\Records\NotUsed\RecordOPT.cs" />
<Compile Include="Protocol\Dns\Records\NotUsed\RecordRRSIG.cs" />
<Compile Include="Protocol\Dns\Records\NotUsed\RecordSINK.cs" />
<Compile Include="Protocol\Dns\Records\NotUsed\RecordSPF.cs" />
<Compile Include="Protocol\Dns\Records\NotUsed\RecordSSHFP.cs" />
<Compile Include="Protocol\Dns\Records\NotUsed\RecordUID.cs" />
<Compile Include="Protocol\Dns\Records\NotUsed\RecordUINFO.cs" />
<Compile Include="Protocol\Dns\Records\NotUsed\RecordUnknown.cs" />
<Compile Include="Protocol\Dns\Records\NotUsed\RecordUNSPEC.cs" />
<Compile Include="Protocol\Dns\Records\Obsolete\RecordGPOS.cs" />
<Compile Include="Protocol\Dns\Records\Obsolete\RecordMD.cs" />
<Compile Include="Protocol\Dns\Records\Obsolete\RecordMF.cs" />
<Compile Include="Protocol\Dns\Records\Obsolete\RecordNSAPPTR.cs" />
<Compile Include="Protocol\Dns\Records\Obsolete\RecordNXT.cs" />
<Compile Include="Protocol\Dns\Records\Record.cs" />
<Compile Include="Protocol\Dns\Records\RecordA.cs" />
<Compile Include="Protocol\Dns\Records\RecordAAAA.cs" />
<Compile Include="Protocol\Dns\Records\RecordAFSDB.cs" />
<Compile Include="Protocol\Dns\Records\RecordCNAME.cs" />
<Compile Include="Protocol\Dns\Records\RecordDNAME.cs" />
<Compile Include="Protocol\Dns\Records\RecordDS.cs" />
<Compile Include="Protocol\Dns\Records\RecordHINFO.cs" />
<Compile Include="Protocol\Dns\Records\RecordISDN.cs" />
<Compile Include="Protocol\Dns\Records\RecordKEY.cs" />
<Compile Include="Protocol\Dns\Records\RecordKX.cs" />
<Compile Include="Protocol\Dns\Records\RecordLOC.cs" />
<Compile Include="Protocol\Dns\Records\RecordMB.cs" />
<Compile Include="Protocol\Dns\Records\RecordMG.cs" />
<Compile Include="Protocol\Dns\Records\RecordMINFO.cs" />
<Compile Include="Protocol\Dns\Records\RecordMR.cs" />
<Compile Include="Protocol\Dns\Records\RecordMX.cs" />
<Compile Include="Protocol\Dns\Records\RecordNAPTR.cs" />
<Compile Include="Protocol\Dns\Records\RecordNS.cs" />
<Compile Include="Protocol\Dns\Records\RecordNSAP.cs" />
<Compile Include="Protocol\Dns\Records\RecordNULL.cs" />
<Compile Include="Protocol\Dns\Records\RecordPTR.cs" />
<Compile Include="Protocol\Dns\Records\RecordPX.cs" />
<Compile Include="Protocol\Dns\Records\RecordRP.cs" />
<Compile Include="Protocol\Dns\Records\RecordRT.cs" />
<Compile Include="Protocol\Dns\Records\RecordSIG.cs" />
<Compile Include="Protocol\Dns\Records\RecordSOA.cs" />
<Compile Include="Protocol\Dns\Records\RecordSRV.cs" />
<Compile Include="Protocol\Dns\Records\RecordTKEY.cs" />
<Compile Include="Protocol\Dns\Records\RecordTSIG.cs" />
<Compile Include="Protocol\Dns\Records\RecordTXT.cs" />
<Compile Include="Protocol\Dns\Records\RecordWKS.cs" />
<Compile Include="Protocol\Dns\Records\RecordX25.cs" />
<Compile Include="Protocol\Dns\Request.cs" />
<Compile Include="Protocol\Dns\Resolver.cs" />
<Compile Include="Protocol\Dns\Response.cs" />
<Compile Include="Protocol\Dns\RR.cs" />
<Compile Include="Protocol\Dns\Structs.cs" />
<Compile Include="Protocol\Handlers\Forge\FMLHandshakeClientState.cs" />
<Compile Include="Protocol\Handlers\Forge\FMLHandshakeDiscriminator.cs" />
<Compile Include="Protocol\Handlers\Forge\ForgeInfo.cs" />
<Compile Include="Protocol\Handlers\Compression\CRC32.cs" />
<Compile Include="Protocol\Handlers\Compression\Deflate.cs" />
<Compile Include="Protocol\Handlers\Compression\GZipStream.cs" />
<Compile Include="Protocol\Handlers\Compression\Inflate.cs" />
<Compile Include="Protocol\Handlers\Compression\InfTree.cs" />
<Compile Include="Protocol\Handlers\Compression\Tree.cs" />
<Compile Include="Protocol\Handlers\Compression\Zlib.cs" />
<Compile Include="Protocol\Handlers\Compression\ZlibBaseStream.cs" />
<Compile Include="Protocol\Handlers\Compression\ZlibCodec.cs" />
<Compile Include="Protocol\Handlers\Compression\ZlibConstants.cs" />
<Compile Include="Protocol\Handlers\ZlibUtils.cs" />
<Compile Include="Crypto\IAesStream.cs" />
<Compile Include="Program.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="McClient.cs" />
<Compile Include="Protocol\Handlers\Compression\ZlibStream.cs" />
<Compile Include="Protocol\Handlers\Protocol18.cs" />
<Compile Include="Protocol\Handlers\Protocol16.cs" />
<Compile Include="Protocol\IMinecraftCom.cs" />
<Compile Include="Protocol\IMinecraftComHandler.cs" />
<Compile Include="Protocol\ProtocolHandler.cs" />
<Compile Include="Protocol\Session\CacheType.cs" />
<Compile Include="Protocol\Session\SessionCache.cs" />
<Compile Include="Protocol\Session\SessionToken.cs" />
<Compile Include="Proxy\ProxyHandler.cs" />
<Compile Include="Proxy\Handlers\EventArgs\CreateConnectionAsyncCompletedEventArgs.cs" />
<Compile Include="Proxy\Handlers\Exceptions\ProxyException.cs" />
<Compile Include="Proxy\Handlers\HttpProxyClient.cs" />
<Compile Include="Proxy\Handlers\IProxyClient.cs" />
<Compile Include="Proxy\Handlers\ProxyClientFactory.cs" />
<Compile Include="Proxy\Handlers\Socks4aProxyClient.cs" />
<Compile Include="Proxy\Handlers\Socks4ProxyClient.cs" />
<Compile Include="Proxy\Handlers\Socks5ProxyClient.cs" />
<Compile Include="Proxy\Handlers\Utils.cs" />
<Compile Include="Settings.cs" />
<Compile Include="Commands\List.cs" />
<Compile Include="Mapping\Location.cs" />
<Compile Include="WinAPI\ExitCleanUp.cs" />
<Compile Include="WinAPI\WindowsVersion.cs" />
</ItemGroup>
<ItemGroup>
<BootstrapperPackage Include=".NETFramework,Version=v4.0,Profile=Client">
<Visible>False</Visible>
<ProductName>Microsoft .NET Framework 4 Client Profile %28x86 and x64%29</ProductName>
<Install>true</Install>
</BootstrapperPackage>
<BootstrapperPackage Include="Microsoft.Net.Client.3.5">
<Visible>False</Visible>
<ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName>
<Install>false</Install>
</BootstrapperPackage>
<BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
<Visible>False</Visible>
<ProductName>.NET Framework 3.5 SP1</ProductName>
<Install>false</Install>
</BootstrapperPackage>
<BootstrapperPackage Include="Microsoft.Windows.Installer.3.1">
<Visible>False</Visible>
<ProductName>Windows Installer 3.1</ProductName>
<Install>true</Install>
</BootstrapperPackage>
</ItemGroup>
<ItemGroup>
<Content Include="Protocol\Dns\Records\totla.txt" />
<Content Include="Resources\AppIcon.ico" />
<Content Include="Resources\containers\ContainerType.BrewingStand.txt" />
<Content Include="Resources\containers\ContainerType.Crafting.txt" />
<Content Include="Resources\containers\ContainerType.Generic_3x3.txt" />
<Content Include="Resources\containers\ContainerType.Generic_9x3.txt" />
<Content Include="Resources\containers\ContainerType.Generic_9x6.txt" />
<Content Include="Resources\containers\ContainerType.PlayerInventory.txt" />
</ItemGroup>
<ItemGroup>
<EmbeddedResource Include="DefaultConfigResource.resx">
<Generator>PublicResXFileCodeGenerator</Generator>
<LastGenOutput>DefaultConfigResource.Designer.cs</LastGenOutput>
</EmbeddedResource>
</ItemGroup>
<ItemGroup>
<None Include="Resources\config\MinecraftClient.ini" />
<None Include="Resources\lang\de.ini" />
<None Include="Resources\lang\en.ini" />
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
</Project>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net6.0</TargetFramework>
<OutputType>Exe</OutputType>
<PublishUrl>publish\</PublishUrl>
<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
<LangVersion>default</LangVersion>
<Nullable>enable</Nullable>
</PropertyGroup>
<PropertyGroup>
<SignManifests>false</SignManifests>
</PropertyGroup>
<PropertyGroup>
<ApplicationIcon>Resources\AppIcon.ico</ApplicationIcon>
</PropertyGroup>
<PropertyGroup>
<StartupObject>MinecraftClient.Program</StartupObject>
</PropertyGroup>
<ItemGroup>
<Content Include="Resources\AppIcon.ico" />
<Content Include="Resources\containers\ContainerType.BrewingStand.txt" />
<Content Include="Resources\containers\ContainerType.Crafting.txt" />
<Content Include="Resources\containers\ContainerType.Generic_3x3.txt" />
<Content Include="Resources\containers\ContainerType.Generic_9x3.txt" />
<Content Include="Resources\containers\ContainerType.Generic_9x6.txt" />
<Content Include="Resources\containers\ContainerType.PlayerInventory.txt" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="DnsClient" Version="1.5.0" />
<PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.11.0-1.final" />
<PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
<PackageReference Include="Microsoft.DotNet.UpgradeAssistant.Extensions.Default.Analyzers" Version="0.2.233001">
<PrivateAssets>all</PrivateAssets>
</PackageReference>
<PackageReference Include="Microsoft.Windows.Compatibility" Version="5.0.2" />
</ItemGroup>
<ItemGroup>
<Compile Remove="config\ChatBots\AutoLook.cs" />
<Compile Remove="config\ChatBots\AutoTree.cs" />
<Compile Remove="config\ChatBots\ClckRuAPI.cs" />
<Compile Remove="config\ChatBots\CobblestoneMiner.cs" />
<Compile Remove="config\ChatBots\DiscordWebhook.cs" />
<Compile Remove="config\ChatBots\OreMiner.cs" />
<Compile Remove="config\ChatBots\PayKassa.cs" />
<Compile Remove="config\ChatBots\QIWIAPI.cs" />
<Compile Remove="config\ChatBots\SugarCaneMiner.cs" />
<Compile Remove="config\ChatBots\TreeFarmer.cs" />
<Compile Remove="config\ChatBots\VkMessager.cs" />
<Compile Remove="config\sample-script-extended.cs" />
<Compile Remove="config\sample-script-pm-forwarder.cs" />
<Compile Remove="config\sample-script-random-command.cs" />
<Compile Remove="config\sample-script-with-chatbot.cs" />
<Compile Remove="config\sample-script-with-http-request.cs" />
<Compile Remove="config\sample-script-with-task.cs" />
<Compile Remove="config\sample-script-with-world-access.cs" />
<Compile Remove="config\sample-script.cs" />
<Compile Remove="config\ChatBots\MineCube.cs" />
<Compile Remove="config\ChatBots\SugarCaneFarmer.cs" />
<Compile Remove="Mapping\VillagerInfo.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\ConsoleInteractive\ConsoleInteractive\ConsoleInteractive\ConsoleInteractive.csproj" />
</ItemGroup>
</Project>

22
MinecraftClient/MinecraftClient.csproj.user
View file

@ -1,22 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
<StartArguments>TestBot - localhost</StartArguments>
</PropertyGroup>
<PropertyGroup>
<PublishUrlHistory>publish\</PublishUrlHistory>
<InstallUrlHistory />
<SupportUrlHistory />
<UpdateUrlHistory />
<BootstrapperUrlHistory />
<ErrorReportUrlHistory />
<FallbackCulture>en-US</FallbackCulture>
<VerifyUploadedFiles>false</VerifyUploadedFiles>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
<StartArguments>TestBot - localhost</StartArguments>
</PropertyGroup>
<PropertyGroup>
<LangVersion>4</LangVersion>
</PropertyGroup>
</Project>

198
MinecraftClient/Program.cs
View file

@ -4,6 +4,7 @@ using System.Linq;
using System.Text;
using MinecraftClient.Protocol;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Threading;
using MinecraftClient.Protocol.Handlers.Forge;
using MinecraftClient.Protocol.Session;
@ -35,7 +36,7 @@ namespace MinecraftClient
public const string MCHighestVersion = "1.18.2";
public static readonly string BuildInfo = null;
private static Thread offlinePrompt = null;
private static Tuple<Thread, CancellationTokenSource>? offlinePrompt = null;
private static bool useMcVersionOnce = false;
/// <summary>
@ -43,21 +44,6 @@ namespace MinecraftClient
/// </summary>
static void Main(string[] args)
{
Console.WriteLine("Minecraft Console Client v{0} - for MC {1} to {2} - Github.com/MCCTeam", Version, MCLowestVersion, MCHighestVersion);
//Build information to facilitate processing of bug reports
if (BuildInfo != null)
{
ConsoleIO.WriteLineFormatted("§8" + BuildInfo);
}
//Debug input ?
if (args.Length == 1 && args[0] == "--keyboard-debug")
{
ConsoleIO.WriteLine("Keyboard debug mode: Press any key to display info");
ConsoleIO.DebugReadInput();
}
//Setup ConsoleIO
ConsoleIO.LogPrefix = "§8[MCC] ";
if (args.Length >= 1 && args[args.Length - 1] == "BasicIO" || args.Length >= 1 && args[args.Length - 1] == "BasicIO-NoColor")
@ -69,10 +55,34 @@ namespace MinecraftClient
ConsoleIO.BasicIO = true;
args = args.Where(o => !Object.ReferenceEquals(o, args[args.Length - 1])).ToArray();
}
if (!ConsoleIO.BasicIO)
ConsoleInteractive.ConsoleWriter.Init();
ConsoleIO.WriteLine($"Minecraft Console Client v{Version} - for MC {MCLowestVersion} to {MCHighestVersion} - Github.com/MCCTeam");
//Build information to facilitate processing of bug reports
if (BuildInfo != null)
{
ConsoleIO.WriteLineFormatted("§8" + BuildInfo);
}
//Debug input ?
if (args.Length == 1 && args[0] == "--keyboard-debug")
{
ConsoleIO.WriteLine("Keyboard debug mode: Press any key to display info");
ConsoleIO.DebugReadInput();
}
//Take advantage of Windows 10 / Mac / Linux UTF-8 console
if (isUsingMono || WindowsVersion.WinMajorVersion >= 10)
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
// If we're on windows, check if our version is Win10 or greater.
if (WindowsVersion.WinMajorVersion >= 10)
Console.OutputEncoding = Console.InputEncoding = Encoding.UTF8;
}
else {
// Apply to all other operating systems.
Console.OutputEncoding = Console.InputEncoding = Encoding.UTF8;
}
@ -145,8 +155,8 @@ namespace MinecraftClient
bool useBrowser = Settings.AccountType == ProtocolHandler.AccountType.Microsoft && Settings.LoginMethod == "browser";
if (Settings.Login == "" && !useBrowser)
{
Console.Write(ConsoleIO.BasicIO ? Translations.Get("mcc.login_basic_io") + "\n" : Translations.Get("mcc.login"));
Settings.Login = Console.ReadLine();
ConsoleIO.WriteLine(ConsoleIO.BasicIO ? Translations.Get("mcc.login_basic_io") : Translations.Get("mcc.login"));
Settings.Login = ConsoleIO.ReadLine();
}
if (Settings.Password == ""
&& (Settings.SessionCaching == CacheType.None || !SessionCache.Contains(Settings.Login.ToLower()))
@ -160,7 +170,7 @@ namespace MinecraftClient
{
// Do NOT use Program.Exit() as creating new Thread cause program to freeze
if (client != null) { client.Disconnect(); ConsoleIO.Reset(); }
if (offlinePrompt != null) { offlinePrompt.Abort(); offlinePrompt = null; ConsoleIO.Reset(); }
if (offlinePrompt != null) { offlinePrompt.Item2.Cancel(); offlinePrompt = null; ConsoleIO.Reset(); }
if (Settings.playerHeadAsIcon) { ConsoleIcon.revertToMCCIcon(); }
});
@ -174,15 +184,9 @@ namespace MinecraftClient
/// </summary>
private static void RequestPassword()
{
Console.Write(ConsoleIO.BasicIO ? Translations.Get("mcc.password_basic_io", Settings.Login) + "\n" : Translations.Get("mcc.password"));
ConsoleIO.WriteLine(ConsoleIO.BasicIO ? Translations.Get("mcc.password_basic_io", Settings.Login) + "\n" : Translations.Get("mcc.password"));
Settings.Password = ConsoleIO.BasicIO ? Console.ReadLine() : ConsoleIO.ReadPassword();
if (Settings.Password == "") { Settings.Password = "-"; }
if (!ConsoleIO.BasicIO)
{
//Hide password length
Console.CursorTop--; Console.Write(Translations.Get("mcc.password_hidden", "<******>"));
for (int i = 19; i < Console.BufferWidth; i++) { Console.Write(' '); }
}
}
/// <summary>
@ -257,7 +261,7 @@ namespace MinecraftClient
if (Settings.ServerIP == "")
{
Translations.Write("mcc.ip");
string addressInput = Console.ReadLine();
string addressInput = ConsoleIO.ReadLine();
if (addressInput.StartsWith("realms:"))
{
if (Settings.MinecraftRealmsEnabled)
@ -387,12 +391,6 @@ namespace MinecraftClient
default: failureReason = "error.login.unknown"; break;
}
failureMessage += Translations.Get(failureReason);
if (result == ProtocolHandler.LoginResult.SSLError && isUsingMono)
{
Translations.WriteLineFormatted("error.login.ssl_help");
return;
}
HandleFailure(failureMessage, false, ChatBot.DisconnectReason.LoginRejected);
}
}
@ -403,10 +401,11 @@ namespace MinecraftClient
/// <param name="delaySeconds">Optional delay, in seconds, before restarting</param>
public static void Restart(int delaySeconds = 0)
{
ConsoleInteractive.ConsoleReader.StopReadThread();
new Thread(new ThreadStart(delegate
{
if (client != null) { client.Disconnect(); ConsoleIO.Reset(); }
if (offlinePrompt != null) { offlinePrompt.Abort(); offlinePrompt = null; ConsoleIO.Reset(); }
if (offlinePrompt != null) { offlinePrompt.Item2.Cancel(); offlinePrompt.Item1.Join(); offlinePrompt = null; ConsoleIO.Reset(); }
if (delaySeconds > 0)
{
Translations.WriteLine("mcc.restart_delay", delaySeconds);
@ -425,7 +424,7 @@ namespace MinecraftClient
new Thread(new ThreadStart(delegate
{
if (client != null) { client.Disconnect(); ConsoleIO.Reset(); }
if (offlinePrompt != null) { offlinePrompt.Abort(); offlinePrompt = null; ConsoleIO.Reset(); }
if (offlinePrompt != null) { offlinePrompt.Item2.Cancel(); offlinePrompt.Item1.Join(); offlinePrompt = null; ConsoleIO.Reset(); }
if (Settings.playerHeadAsIcon) { ConsoleIcon.revertToMCCIcon(); }
Environment.Exit(exitcode);
})).Start();
@ -459,7 +458,7 @@ namespace MinecraftClient
if (versionError)
{
Translations.Write("mcc.server_version");
Settings.ServerVersion = Console.ReadLine();
Settings.ServerVersion = ConsoleInteractive.ConsoleReader.RequestImmediateInput();
if (Settings.ServerVersion != "")
{
useMcVersionOnce = true;
@ -468,53 +467,89 @@ namespace MinecraftClient
}
}
if (offlinePrompt == null)
if (offlinePrompt == null)
{
offlinePrompt = new Thread(new ThreadStart(delegate
{
ConsoleInteractive.ConsoleReader.StopReadThread();
var cancellationTokenSource = new CancellationTokenSource();
offlinePrompt = new(new Thread(new ThreadStart(delegate {
bool exitThread = false;
string command = " ";
ConsoleIO.WriteLineFormatted(Translations.Get("mcc.disconnected", (Settings.internalCmdChar == ' ' ? "" : "" + Settings.internalCmdChar)));
Translations.WriteLineFormatted("mcc.press_exit");
while (command.Length > 0)
while (!cancellationTokenSource.IsCancellationRequested)
{
if (!ConsoleIO.BasicIO)
if (exitThread)
return;
while (command.Length > 0)
{
ConsoleIO.Write('>');
}
command = Console.ReadLine().Trim();
if (command.Length > 0)
{
string message = "";
if (Settings.internalCmdChar != ' '
&& command[0] == Settings.internalCmdChar)
command = command.Substring(1);
if (command.StartsWith("reco"))
{
message = new Commands.Reco().Run(null, Settings.ExpandVars(command), null);
}
else if (command.StartsWith("connect"))
{
message = new Commands.Connect().Run(null, Settings.ExpandVars(command), null);
}
else if (command.StartsWith("exit") || command.StartsWith("quit"))
{
message = new Commands.Exit().Run(null, Settings.ExpandVars(command), null);
}
else if (command.StartsWith("help"))
{
ConsoleIO.WriteLineFormatted("§8MCC: " + (Settings.internalCmdChar == ' ' ? "" : "" + Settings.internalCmdChar) + new Commands.Reco().GetCmdDescTranslated());
ConsoleIO.WriteLineFormatted("§8MCC: " + (Settings.internalCmdChar == ' ' ? "" : "" + Settings.internalCmdChar) + new Commands.Connect().GetCmdDescTranslated());
}
else ConsoleIO.WriteLineFormatted(Translations.Get("icmd.unknown", command.Split(' ')[0]));
if (message != "")
ConsoleIO.WriteLineFormatted("§8MCC: " + message);
if (cancellationTokenSource.IsCancellationRequested)
return;
command = ConsoleInteractive.ConsoleReader.RequestImmediateInput().Trim();
if (command.Length > 0)
{
string message = "";
if (Settings.internalCmdChar != ' '
&& command[0] == Settings.internalCmdChar)
command = command.Substring(1);
if (command.StartsWith("reco"))
{
message = new Commands.Reco().Run(null, Settings.ExpandVars(command), null);
if (message == "")
{
exitThread = true;
break;
}
}
else if (command.StartsWith("connect"))
{
message = new Commands.Connect().Run(null, Settings.ExpandVars(command), null);
if (message == "")
{
exitThread = true;
break;
}
}
else if (command.StartsWith("exit") || command.StartsWith("quit"))
{
message = new Commands.Exit().Run(null, Settings.ExpandVars(command), null);
}
else if (command.StartsWith("help"))
{
ConsoleIO.WriteLineFormatted("§8MCC: " +
(Settings.internalCmdChar == ' '
? ""
: "" + Settings.internalCmdChar) +
new Commands.Reco().GetCmdDescTranslated());
ConsoleIO.WriteLineFormatted("§8MCC: " +
(Settings.internalCmdChar == ' '
? ""
: "" + Settings.internalCmdChar) +
new Commands.Connect().GetCmdDescTranslated());
}
else
ConsoleIO.WriteLineFormatted(Translations.Get("icmd.unknown",
command.Split(' ')[0]));
if (message != "")
ConsoleIO.WriteLineFormatted("§8MCC: " + message);
}
else
{
_ = new Commands.Exit().Run(null, Settings.ExpandVars(command), null);
}
}
if (exitThread)
return;
}
}));
offlinePrompt.Start();
})), cancellationTokenSource);
offlinePrompt.Item1.Start();
}
}
else
@ -533,17 +568,6 @@ namespace MinecraftClient
}
/// <summary>
/// Detect if the user is running Minecraft Console Client through Mono
/// </summary>
public static bool isUsingMono
{
get
{
return Type.GetType("Mono.Runtime") != null;
}
}
/// <summary>
/// Enumerate types in namespace through reflection
/// </summary>

3
MinecraftClient/Protocol/ChatParser.cs
View file

@ -1,5 +1,6 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
@ -87,7 +88,7 @@ namespace MinecraftClient.Protocol
if (!System.IO.Directory.Exists("lang"))
System.IO.Directory.CreateDirectory("lang");
string Language_File = "lang" + (Program.isUsingMono ? '/' : '\\') + Settings.Language + ".lang";
string Language_File = "lang" + Path.DirectorySeparatorChar + Settings.Language + ".lang";
//File not found? Try downloading language file from Mojang's servers?
if (!System.IO.File.Exists(Language_File))

351
MinecraftClient/Protocol/Dns/Header.cs
View file

@ -1,351 +0,0 @@
using System;
using System.IO;
using System.Collections.Generic;
using System.Net;
using System.Text;
namespace Heijden.DNS
{
#region RFC specification
/*
4.1.1. Header section format
The header contains the following fields:
1 1 1 1 1 1
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| ID |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|QR| Opcode |AA|TC|RD|RA| Z | RCODE |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| QDCOUNT |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| ANCOUNT |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| NSCOUNT |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| ARCOUNT |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
where:
ID A 16 bit identifier assigned by the program that
generates any kind of query. This identifier is copied
the corresponding reply and can be used by the requester
to match up replies to outstanding queries.
QR A one bit field that specifies whether this message is a
query (0), or a response (1).
OPCODE A four bit field that specifies kind of query in this
message. This value is set by the originator of a query
and copied into the response. The values are:
0 a standard query (QUERY)
1 an inverse query (IQUERY)
2 a server status request (STATUS)
3-15 reserved for future use
AA Authoritative Answer - this bit is valid in responses,
and specifies that the responding name server is an
authority for the domain name in question section.
Note that the contents of the answer section may have
multiple owner names because of aliases. The AA bit
corresponds to the name which matches the query name, or
the first owner name in the answer section.
TC TrunCation - specifies that this message was truncated
due to length greater than that permitted on the
transmission channel.
RD Recursion Desired - this bit may be set in a query and
is copied into the response. If RD is set, it directs
the name server to pursue the query recursively.
Recursive query support is optional.
RA Recursion Available - this be is set or cleared in a
response, and denotes whether recursive query support is
available in the name server.
Z Reserved for future use. Must be zero in all queries
and responses.
RCODE Response code - this 4 bit field is set as part of
responses. The values have the following
interpretation:
0 No error condition
1 Format error - The name server was
unable to interpret the query.
2 Server failure - The name server was
unable to process this query due to a
problem with the name server.
3 Name Error - Meaningful only for
responses from an authoritative name
server, this code signifies that the
domain name referenced in the query does
not exist.
4 Not Implemented - The name server does
not support the requested kind of query.
5 Refused - The name server refuses to
perform the specified operation for
policy reasons. For example, a name
server may not wish to provide the
information to the particular requester,
or a name server may not wish to perform
a particular operation (e.g., zone
transfer) for particular data.
6-15 Reserved for future use.
QDCOUNT an unsigned 16 bit integer specifying the number of
entries in the question section.
ANCOUNT an unsigned 16 bit integer specifying the number of
resource records in the answer section.
NSCOUNT an unsigned 16 bit integer specifying the number of name
server resource records in the authority records
section.
ARCOUNT an unsigned 16 bit integer specifying the number of
resource records in the additional records section.
*/
#endregion
public class Header
{
/// <summary>
/// An identifier assigned by the program
/// </summary>
public ushort ID;
// internal flag
private ushort Flags;
/// <summary>
/// the number of entries in the question section
/// </summary>
public ushort QDCOUNT;
/// <summary>
/// the number of resource records in the answer section
/// </summary>
public ushort ANCOUNT;
/// <summary>
/// the number of name server resource records in the authority records section
/// </summary>
public ushort NSCOUNT;
/// <summary>
/// the number of resource records in the additional records section
/// </summary>
public ushort ARCOUNT;
public Header()
{
}
public Header(RecordReader rr)
{
ID = rr.ReadUInt16();
Flags = rr.ReadUInt16();
QDCOUNT = rr.ReadUInt16();
ANCOUNT = rr.ReadUInt16();
NSCOUNT = rr.ReadUInt16();
ARCOUNT = rr.ReadUInt16();
}
private ushort SetBits(ushort oldValue, int position, int length, bool blnValue)
{
return SetBits(oldValue, position, length, blnValue ? (ushort)1 : (ushort)0);
}
private ushort SetBits(ushort oldValue, int position, int length, ushort newValue)
{
// sanity check
if (length <= 0 || position >= 16)
return oldValue;
// get some mask to put on
int mask = (2 << (length - 1)) - 1;
// clear out value
oldValue &= (ushort)~(mask << position);
// set new value
oldValue |= (ushort)((newValue & mask) << position);
return oldValue;
}
private ushort GetBits(ushort oldValue, int position, int length)
{
// sanity check
if (length <= 0 || position >= 16)
return 0;
// get some mask to put on
int mask = (2 << (length - 1)) - 1;
// shift down to get some value and mask it
return (ushort)((oldValue >> position) & mask);
}
/// <summary>
/// Represents the header as a byte array
/// </summary>
public byte[] Data
{
get
{
List<byte> data = new List<byte>();
data.AddRange(WriteShort(ID));
data.AddRange(WriteShort(Flags));
data.AddRange(WriteShort(QDCOUNT));
data.AddRange(WriteShort(ANCOUNT));
data.AddRange(WriteShort(NSCOUNT));
data.AddRange(WriteShort(ARCOUNT));
return data.ToArray();
}
}
private byte[] WriteShort(ushort sValue)
{
return BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)sValue));
}
/// <summary>
/// query (false), or a response (true)
/// </summary>
public bool QR
{
get
{
return GetBits(Flags, 15, 1) == 1;
}
set
{
Flags = SetBits(Flags, 15, 1, value);
}
}
/// <summary>
/// Specifies kind of query
/// </summary>
public OPCode OPCODE
{
get
{
return (OPCode)GetBits(Flags, 11, 4);
}
set
{
Flags = SetBits(Flags, 11, 4, (ushort)value);
}
}
/// <summary>
/// Authoritative Answer
/// </summary>
public bool AA
{
get
{
return GetBits(Flags, 10, 1) == 1;
}
set
{
Flags = SetBits(Flags, 10, 1, value);
}
}
/// <summary>
/// TrunCation
/// </summary>
public bool TC
{
get
{
return GetBits(Flags, 9, 1) == 1;
}
set
{
Flags = SetBits(Flags, 9, 1, value);
}
}
/// <summary>
/// Recursion Desired
/// </summary>
public bool RD
{
get
{
return GetBits(Flags, 8, 1) == 1;
}
set
{
Flags = SetBits(Flags, 8, 1, value);
}
}
/// <summary>
/// Recursion Available
/// </summary>
public bool RA
{
get
{
return GetBits(Flags, 7, 1) == 1;
}
set
{
Flags = SetBits(Flags, 7, 1, value);
}
}
/// <summary>
/// Reserved for future use
/// </summary>
public ushort Z
{
get
{
return GetBits(Flags, 4, 3);
}
set
{
Flags = SetBits(Flags, 4, 3, value);
}
}
/// <summary>
/// Response code
/// </summary>
public RCode RCODE
{
get
{
return (RCode)GetBits(Flags, 0, 4);
}
set
{
Flags = SetBits(Flags, 0, 4, (ushort)value);
}
}
}
}

129
MinecraftClient/Protocol/Dns/Question.cs
View file

@ -1,129 +0,0 @@
using System;
using System.IO;
using System.Collections.Generic;
using System.Net;
using System.Text;
namespace Heijden.DNS
{
#region Rfc 1034/1035
/*
4.1.2. Question section format
The question section is used to carry the "question" in most queries,
i.e., the parameters that define what is being asked. The section
contains QDCOUNT (usually 1) entries, each of the following format:
1 1 1 1 1 1
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| |
/ QNAME /
/ /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| QTYPE |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| QCLASS |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
where:
QNAME a domain name represented as a sequence of labels, where
each label consists of a length octet followed by that
number of octets. The domain name terminates with the
zero length octet for the null label of the root. Note
that this field may be an odd number of octets; no
padding is used.
QTYPE a two octet code which specifies the type of the query.
The values for this field include all codes valid for a
TYPE field, together with some more general codes which
can match more than one type of RR.
QCLASS a two octet code that specifies the class of the query.
For example, the QCLASS field is IN for the Internet.
*/
#endregion
public class Question
{
private string m_QName;
public string QName
{
get
{
return m_QName;
}
set
{
m_QName = value;
if (!m_QName.EndsWith("."))
m_QName += ".";
}
}
public QType QType;
public QClass QClass;
public Question(string QName,QType QType,QClass QClass)
{
this.QName = QName;
this.QType = QType;
this.QClass = QClass;
}
public Question(RecordReader rr)
{
QName = rr.ReadDomainName();
QType = (QType)rr.ReadUInt16();
QClass = (QClass)rr.ReadUInt16();
}
private byte[] WriteName(string src)
{
if (!src.EndsWith("."))
src += ".";
if (src == ".")
return new byte[1];
StringBuilder sb = new StringBuilder();
int intI, intJ, intLen = src.Length;
sb.Append('\0');
for (intI = 0, intJ = 0; intI < intLen; intI++, intJ++)
{
sb.Append(src[intI]);
if (src[intI] == '.')
{
sb[intI - intJ] = (char)(intJ & 0xff);
intJ = -1;
}
}
sb[sb.Length - 1] = '\0';
return System.Text.Encoding.ASCII.GetBytes(sb.ToString());
}
public byte[] Data
{
get
{
List<byte> data = new List<byte>();
data.AddRange(WriteName(QName));
data.AddRange(WriteShort((ushort)QType));
data.AddRange(WriteShort((ushort)QClass));
return data.ToArray();
}
}
private byte[] WriteShort(ushort sValue)
{
return BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)sValue));
}
public override string ToString()
{
return string.Format("{0,-32}\t{1}\t{2}", QName, QClass, QType);
}
}
}

156
MinecraftClient/Protocol/Dns/RR.cs
View file

@ -1,156 +0,0 @@
using System;
namespace Heijden.DNS
{
#region RFC info
/*
3.2. RR definitions
3.2.1. Format
All RRs have the same top level format shown below:
1 1 1 1 1 1
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| |
/ /
/ NAME /
| |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| TYPE |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| CLASS |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| TTL |
| |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| RDLENGTH |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--|
/ RDATA /
/ /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
where:
NAME an owner name, i.e., the name of the node to which this
resource record pertains.
TYPE two octets containing one of the RR TYPE codes.
CLASS two octets containing one of the RR CLASS codes.
TTL a 32 bit signed integer that specifies the time interval
that the resource record may be cached before the source
of the information should again be consulted. Zero
values are interpreted to mean that the RR can only be
used for the transaction in progress, and should not be
cached. For example, SOA records are always distributed
with a zero TTL to prohibit caching. Zero values can
also be used for extremely volatile data.
RDLENGTH an unsigned 16 bit integer that specifies the length in
octets of the RDATA field.
RDATA a variable length string of octets that describes the
resource. The format of this information varies
according to the TYPE and CLASS of the resource record.
*/
#endregion
/// <summary>
/// Resource Record (rfc1034 3.6.)
/// </summary>
public class RR
{
/// <summary>
/// The name of the node to which this resource record pertains
/// </summary>
public string NAME;
/// <summary>
/// Specifies type of resource record
/// </summary>
public Type Type;
/// <summary>
/// Specifies type class of resource record, mostly IN but can be CS, CH or HS
/// </summary>
public Class Class;
/// <summary>
/// Time to live, the time interval that the resource record may be cached
/// </summary>
public uint TTL
{
get
{
return (uint)Math.Max(0, m_TTL - TimeLived);
}
set
{
m_TTL = value;
}
}
private uint m_TTL;
/// <summary>
///
/// </summary>
public ushort RDLENGTH;
/// <summary>
/// One of the Record* classes
/// </summary>
public Record RECORD;
public int TimeLived;
public RR(RecordReader rr)
{
TimeLived = 0;
NAME = rr.ReadDomainName();
Type = (Type)rr.ReadUInt16();
Class = (Class)rr.ReadUInt16();
TTL = rr.ReadUInt32();
RDLENGTH = rr.ReadUInt16();
RECORD = rr.ReadRecord(Type);
RECORD.RR = this;
}
public override string ToString()
{
return string.Format("{0,-32} {1}\t{2}\t{3}\t{4}",
NAME,
TTL,
Class,
Type,
RECORD);
}
}
public class AnswerRR : RR
{
public AnswerRR(RecordReader br)
: base(br)
{
}
}
public class AuthorityRR : RR
{
public AuthorityRR(RecordReader br)
: base(br)
{
}
}
public class AdditionalRR : RR
{
public AdditionalRR(RecordReader br)
: base(br)
{
}
}
}

243
MinecraftClient/Protocol/Dns/RecordReader.cs
View file

@ -1,243 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace Heijden.DNS
{
public class RecordReader
{
private byte[] m_Data;
private int m_Position;
public RecordReader(byte[] data)
{
m_Data = data;
m_Position = 0;
}
public int Position
{
get
{
return m_Position;
}
set
{
m_Position = value;
}
}
public RecordReader(byte[] data, int Position)
{
m_Data = data;
m_Position = Position;
}
public byte ReadByte()
{
if (m_Position >= m_Data.Length)
return 0;
else
return m_Data[m_Position++];
}
public char ReadChar()
{
return (char)ReadByte();
}
public UInt16 ReadUInt16()
{
return (UInt16)(ReadByte() << 8 | ReadByte());
}
public UInt16 ReadUInt16(int offset)
{
m_Position += offset;
return ReadUInt16();
}
public UInt32 ReadUInt32()
{
return (UInt32)(ReadUInt16() << 16 | ReadUInt16());
}
public string ReadDomainName()
{
StringBuilder name = new StringBuilder();
int length = 0;
// get the length of the first label
while ((length = ReadByte()) != 0)
{
// top 2 bits set denotes domain name compression and to reference elsewhere
if ((length & 0xc0) == 0xc0)
{
// work out the existing domain name, copy this pointer
RecordReader newRecordReader = new RecordReader(m_Data, (length & 0x3f) << 8 | ReadByte());
name.Append(newRecordReader.ReadDomainName());
return name.ToString();
}
// if not using compression, copy a char at a time to the domain name
while (length > 0)
{
name.Append(ReadChar());
length--;
}
name.Append('.');
}
if (name.Length == 0)
return ".";
else
return name.ToString();
}
public string ReadString()
{
short length = this.ReadByte();
StringBuilder name = new StringBuilder();
for(int intI=0;intI<length;intI++)
name.Append(ReadChar());
return name.ToString();
}
public byte[] ReadBytes(int intLength)
{
List<byte> list = new List<byte>();
for(int intI=0;intI<intLength;intI++)
list.Add(ReadByte());
return list.ToArray();
}
public Record ReadRecord(Type type)
{
switch (type)
{
case Type.A:
return new RecordA(this);
case Type.NS:
return new RecordNS(this);
case Type.MD:
return new RecordMD(this);
case Type.MF:
return new RecordMF(this);
case Type.CNAME:
return new RecordCNAME(this);
case Type.SOA:
return new RecordSOA(this);
case Type.MB:
return new RecordMB(this);
case Type.MG:
return new RecordMG(this);
case Type.MR:
return new RecordMR(this);
case Type.NULL:
return new RecordNULL(this);
case Type.WKS:
return new RecordWKS(this);
case Type.PTR:
return new RecordPTR(this);
case Type.HINFO:
return new RecordHINFO(this);
case Type.MINFO:
return new RecordMINFO(this);
case Type.MX:
return new RecordMX(this);
case Type.TXT:
return new RecordTXT(this);
case Type.RP:
return new RecordRP(this);
case Type.AFSDB:
return new RecordAFSDB(this);
case Type.X25:
return new RecordX25(this);
case Type.ISDN:
return new RecordISDN(this);
case Type.RT:
return new RecordRT(this);
case Type.NSAP:
return new RecordNSAP(this);
case Type.NSAPPTR:
return new RecordNSAPPTR(this);
case Type.SIG:
return new RecordSIG(this);
case Type.KEY:
return new RecordKEY(this);
case Type.PX:
return new RecordPX(this);
case Type.GPOS:
return new RecordGPOS(this);
case Type.AAAA:
return new RecordAAAA(this);
case Type.LOC:
return new RecordLOC(this);
case Type.NXT:
return new RecordNXT(this);
case Type.EID:
return new RecordEID(this);
case Type.NIMLOC:
return new RecordNIMLOC(this);
case Type.SRV:
return new RecordSRV(this);
case Type.ATMA:
return new RecordATMA(this);
case Type.NAPTR:
return new RecordNAPTR(this);
case Type.KX:
return new RecordKX(this);
case Type.CERT:
return new RecordCERT(this);
case Type.A6:
return new RecordA6(this);
case Type.DNAME:
return new RecordDNAME(this);
case Type.SINK:
return new RecordSINK(this);
case Type.OPT:
return new RecordOPT(this);
case Type.APL:
return new RecordAPL(this);
case Type.DS:
return new RecordDS(this);
case Type.SSHFP:
return new RecordSSHFP(this);
case Type.IPSECKEY:
return new RecordIPSECKEY(this);
case Type.RRSIG:
return new RecordRRSIG(this);
case Type.NSEC:
return new RecordNSEC(this);
case Type.DNSKEY:
return new RecordDNSKEY(this);
case Type.DHCID:
return new RecordDHCID(this);
case Type.NSEC3:
return new RecordNSEC3(this);
case Type.NSEC3PARAM:
return new RecordNSEC3PARAM(this);
case Type.HIP:
return new RecordHIP(this);
case Type.SPF:
return new RecordSPF(this);
case Type.UINFO:
return new RecordUINFO(this);
case Type.UID:
return new RecordUID(this);
case Type.GID:
return new RecordGID(this);
case Type.UNSPEC:
return new RecordUNSPEC(this);
case Type.TKEY:
return new RecordTKEY(this);
case Type.TSIG:
return new RecordTSIG(this);
default:
return new RecordUnknown(this);
}
}
}
}

25
MinecraftClient/Protocol/Dns/Records/NotUsed/RecordA6.cs
View file

@ -1,25 +0,0 @@
using System;
/*
*/
namespace Heijden.DNS
{
public class RecordA6 : Record
{
public byte[] RDATA;
public RecordA6(RecordReader rr)
{
// re-read length
ushort RDLENGTH = rr.ReadUInt16(-2);
RDATA = rr.ReadBytes(RDLENGTH);
}
public override string ToString()
{
return string.Format("not-used");
}
}
}

25
MinecraftClient/Protocol/Dns/Records/NotUsed/RecordAPL.cs
View file

@ -1,25 +0,0 @@
using System;
/*
*/
namespace Heijden.DNS
{
public class RecordAPL : Record
{
public byte[] RDATA;
public RecordAPL(RecordReader rr)
{
// re-read length
ushort RDLENGTH = rr.ReadUInt16(-2);
RDATA = rr.ReadBytes(RDLENGTH);
}
public override string ToString()
{
return string.Format("not-used");
}
}
}

25
MinecraftClient/Protocol/Dns/Records/NotUsed/RecordATMA.cs
View file

@ -1,25 +0,0 @@
using System;
/*
*/
namespace Heijden.DNS
{
public class RecordATMA : Record
{
public byte[] RDATA;
public RecordATMA(RecordReader rr)
{
// re-read length
ushort RDLENGTH = rr.ReadUInt16(-2);
RDATA = rr.ReadBytes(RDLENGTH);
}
public override string ToString()
{
return string.Format("not-used");
}
}
}

25
MinecraftClient/Protocol/Dns/Records/NotUsed/RecordCERT.cs
View file

@ -1,25 +0,0 @@
using System;
/*
*/
namespace Heijden.DNS
{
public class RecordCERT : Record
{
public byte[] RDATA;
public RecordCERT(RecordReader rr)
{
// re-read length
ushort RDLENGTH = rr.ReadUInt16(-2);
RDATA = rr.ReadBytes(RDLENGTH);
}
public override string ToString()
{
return string.Format("not-used");
}
}
}

25
MinecraftClient/Protocol/Dns/Records/NotUsed/RecordDHCID.cs
View file

@ -1,25 +0,0 @@
using System;
/*
*/
namespace Heijden.DNS
{
public class RecordDHCID : Record
{
public byte[] RDATA;
public RecordDHCID(RecordReader rr)
{
// re-read length
ushort RDLENGTH = rr.ReadUInt16(-2);
RDATA = rr.ReadBytes(RDLENGTH);
}
public override string ToString()
{
return string.Format("not-used");
}
}
}

25
MinecraftClient/Protocol/Dns/Records/NotUsed/RecordDNSKEY.cs
View file

@ -1,25 +0,0 @@
using System;
/*
*/
namespace Heijden.DNS
{
public class RecordDNSKEY : Record
{
public byte[] RDATA;
public RecordDNSKEY(RecordReader rr)
{
// re-read length
ushort RDLENGTH = rr.ReadUInt16(-2);
RDATA = rr.ReadBytes(RDLENGTH);
}
public override string ToString()
{
return string.Format("not-used");
}
}
}

25
MinecraftClient/Protocol/Dns/Records/NotUsed/RecordEID.cs
View file

@ -1,25 +0,0 @@
using System;
/*
*/
namespace Heijden.DNS
{
public class RecordEID : Record
{
public byte[] RDATA;
public RecordEID(RecordReader rr)
{
// re-read length
ushort RDLENGTH = rr.ReadUInt16(-2);
RDATA = rr.ReadBytes(RDLENGTH);
}
public override string ToString()
{
return string.Format("not-used");
}
}
}

25
MinecraftClient/Protocol/Dns/Records/NotUsed/RecordGID.cs
View file

@ -1,25 +0,0 @@
using System;
/*
*/
namespace Heijden.DNS
{
public class RecordGID : Record
{
public byte[] RDATA;
public RecordGID(RecordReader rr)
{
// re-read length
ushort RDLENGTH = rr.ReadUInt16(-2);
RDATA = rr.ReadBytes(RDLENGTH);
}
public override string ToString()
{
return string.Format("not-used");
}
}
}

25
MinecraftClient/Protocol/Dns/Records/NotUsed/RecordHIP.cs
View file

@ -1,25 +0,0 @@
using System;
/*
*/
namespace Heijden.DNS
{
public class RecordHIP : Record
{
public byte[] RDATA;
public RecordHIP(RecordReader rr)
{
// re-read length
ushort RDLENGTH = rr.ReadUInt16(-2);
RDATA = rr.ReadBytes(RDLENGTH);
}
public override string ToString()
{
return string.Format("not-used");
}
}
}

25
MinecraftClient/Protocol/Dns/Records/NotUsed/RecordIPSECKEY.cs
View file

@ -1,25 +0,0 @@
using System;
/*
*/
namespace Heijden.DNS
{
public class RecordIPSECKEY : Record
{
public byte[] RDATA;
public RecordIPSECKEY(RecordReader rr)
{
// re-read length
ushort RDLENGTH = rr.ReadUInt16(-2);
RDATA = rr.ReadBytes(RDLENGTH);
}
public override string ToString()
{
return string.Format("not-used");
}
}
}

25
MinecraftClient/Protocol/Dns/Records/NotUsed/RecordNIMLOC.cs
View file

@ -1,25 +0,0 @@
using System;
/*
*/
namespace Heijden.DNS
{
public class RecordNIMLOC : Record
{
public byte[] RDATA;
public RecordNIMLOC(RecordReader rr)
{
// re-read length
ushort RDLENGTH = rr.ReadUInt16(-2);
RDATA = rr.ReadBytes(RDLENGTH);
}
public override string ToString()
{
return string.Format("not-used");
}
}
}

25
MinecraftClient/Protocol/Dns/Records/NotUsed/RecordNSEC.cs
View file

@ -1,25 +0,0 @@
using System;
/*
*/
namespace Heijden.DNS
{
public class RecordNSEC : Record
{
public byte[] RDATA;
public RecordNSEC(RecordReader rr)
{
// re-read length
ushort RDLENGTH = rr.ReadUInt16(-2);
RDATA = rr.ReadBytes(RDLENGTH);
}
public override string ToString()
{
return string.Format("not-used");
}
}
}

25
MinecraftClient/Protocol/Dns/Records/NotUsed/RecordNSEC3.cs
View file

@ -1,25 +0,0 @@
using System;
/*
*/
namespace Heijden.DNS
{
public class RecordNSEC3 : Record
{
public byte[] RDATA;
public RecordNSEC3(RecordReader rr)
{
// re-read length
ushort RDLENGTH = rr.ReadUInt16(-2);
RDATA = rr.ReadBytes(RDLENGTH);
}
public override string ToString()
{
return string.Format("not-used");
}
}
}

25
MinecraftClient/Protocol/Dns/Records/NotUsed/RecordNSEC3PARAM.cs
View file

@ -1,25 +0,0 @@
using System;
/*
*/
namespace Heijden.DNS
{
public class RecordNSEC3PARAM : Record
{
public byte[] RDATA;
public RecordNSEC3PARAM(RecordReader rr)
{
// re-read length
ushort RDLENGTH = rr.ReadUInt16(-2);
RDATA = rr.ReadBytes(RDLENGTH);
}
public override string ToString()
{
return string.Format("not-used");
}
}
}

25
MinecraftClient/Protocol/Dns/Records/NotUsed/RecordOPT.cs
View file

@ -1,25 +0,0 @@
using System;
/*
*/
namespace Heijden.DNS
{
public class RecordOPT : Record
{
public byte[] RDATA;
public RecordOPT(RecordReader rr)
{
// re-read length
ushort RDLENGTH = rr.ReadUInt16(-2);
RDATA = rr.ReadBytes(RDLENGTH);
}
public override string ToString()
{
return string.Format("not-used");
}
}
}

25
MinecraftClient/Protocol/Dns/Records/NotUsed/RecordRRSIG.cs
View file

@ -1,25 +0,0 @@
using System;
/*
*/
namespace Heijden.DNS
{
public class RecordRRSIG : Record
{
public byte[] RDATA;
public RecordRRSIG(RecordReader rr)
{
// re-read length
ushort RDLENGTH = rr.ReadUInt16(-2);
RDATA = rr.ReadBytes(RDLENGTH);
}
public override string ToString()
{
return string.Format("not-used");
}
}
}

25
MinecraftClient/Protocol/Dns/Records/NotUsed/RecordSINK.cs
View file

@ -1,25 +0,0 @@
using System;
/*
*/
namespace Heijden.DNS
{
public class RecordSINK : Record
{
public byte[] RDATA;
public RecordSINK(RecordReader rr)
{
// re-read length
ushort RDLENGTH = rr.ReadUInt16(-2);
RDATA = rr.ReadBytes(RDLENGTH);
}
public override string ToString()
{
return string.Format("not-used");
}
}
}

25
MinecraftClient/Protocol/Dns/Records/NotUsed/RecordSPF.cs
View file

@ -1,25 +0,0 @@
using System;
/*
*/
namespace Heijden.DNS
{
public class RecordSPF : Record
{
public byte[] RDATA;
public RecordSPF(RecordReader rr)
{
// re-read length
ushort RDLENGTH = rr.ReadUInt16(-2);
RDATA = rr.ReadBytes(RDLENGTH);
}
public override string ToString()
{
return string.Format("not-used");
}
}
}

25
MinecraftClient/Protocol/Dns/Records/NotUsed/RecordSSHFP.cs
View file

@ -1,25 +0,0 @@
using System;
/*
*/
namespace Heijden.DNS
{
public class RecordSSHFP : Record
{
public byte[] RDATA;
public RecordSSHFP(RecordReader rr)
{
// re-read length
ushort RDLENGTH = rr.ReadUInt16(-2);
RDATA = rr.ReadBytes(RDLENGTH);
}
public override string ToString()
{
return string.Format("not-used");
}
}
}

25
MinecraftClient/Protocol/Dns/Records/NotUsed/RecordUID.cs
View file

@ -1,25 +0,0 @@
using System;
/*
*/
namespace Heijden.DNS
{
public class RecordUID : Record
{
public byte[] RDATA;
public RecordUID(RecordReader rr)
{
// re-read length
ushort RDLENGTH = rr.ReadUInt16(-2);
RDATA = rr.ReadBytes(RDLENGTH);
}
public override string ToString()
{
return string.Format("not-used");
}
}
}

25
MinecraftClient/Protocol/Dns/Records/NotUsed/RecordUINFO.cs
View file

@ -1,25 +0,0 @@
using System;
/*
*/
namespace Heijden.DNS
{
public class RecordUINFO : Record
{
public byte[] RDATA;
public RecordUINFO(RecordReader rr)
{
// re-read length
ushort RDLENGTH = rr.ReadUInt16(-2);
RDATA = rr.ReadBytes(RDLENGTH);
}
public override string ToString()
{
return string.Format("not-used");
}
}
}

25
MinecraftClient/Protocol/Dns/Records/NotUsed/RecordUNSPEC.cs
View file

@ -1,25 +0,0 @@
using System;
/*
*/
namespace Heijden.DNS
{
public class RecordUNSPEC : Record
{
public byte[] RDATA;
public RecordUNSPEC(RecordReader rr)
{
// re-read length
ushort RDLENGTH = rr.ReadUInt16(-2);
RDATA = rr.ReadBytes(RDLENGTH);
}
public override string ToString()
{
return string.Format("not-used");
}
}
}

15
MinecraftClient/Protocol/Dns/Records/NotUsed/RecordUnknown.cs
View file

@ -1,15 +0,0 @@
using System;
namespace Heijden.DNS
{
public class RecordUnknown : Record
{
public byte[] RDATA;
public RecordUnknown(RecordReader rr)
{
// re-read length
ushort RDLENGTH = rr.ReadUInt16(-2);
RDATA = rr.ReadBytes(RDLENGTH);
}
}
}

65
MinecraftClient/Protocol/Dns/Records/Obsolete/RecordGPOS.cs
View file

@ -1,65 +0,0 @@
using System;
/*
* http://tools.ietf.org/rfc/rfc1712.txt
*
3. RDATA Format
MSB LSB
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
/ LONGITUDE /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
/ LATITUDE /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
/ ALTITUDE /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
where:
LONGITUDE The real number describing the longitude encoded as a
printable string. The precision is limited by 256 charcters
within the range -90..90 degrees. Positive numbers
indicate locations north of the equator.
LATITUDE The real number describing the latitude encoded as a
printable string. The precision is limited by 256 charcters
within the range -180..180 degrees. Positive numbers
indicate locations east of the prime meridian.
ALTITUDE The real number describing the altitude (in meters) from
mean sea-level encoded as a printable string. The precision
is limited by 256 charcters. Positive numbers indicate
locations above mean sea-level.
Latitude/Longitude/Altitude values are encoded as strings as to avoid
the precision limitations imposed by encoding as unsigned integers.
Although this might not be considered optimal, it allows for a very
high degree of precision with an acceptable average encoded record
length.
*/
namespace Heijden.DNS
{
public class RecordGPOS : Record
{
public string LONGITUDE;
public string LATITUDE;
public string ALTITUDE;
public RecordGPOS(RecordReader rr)
{
LONGITUDE = rr.ReadString();
LATITUDE = rr.ReadString();
ALTITUDE = rr.ReadString();
}
public override string ToString()
{
return string.Format("{0} {1} {2}",
LONGITUDE,
LATITUDE,
ALTITUDE);
}
}
}

41
MinecraftClient/Protocol/Dns/Records/Obsolete/RecordMD.cs
View file

@ -1,41 +0,0 @@
using System;
/*
3.3.4. MD RDATA format (Obsolete)
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
/ MADNAME /
/ /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
where:
MADNAME A <domain-name> which specifies a host which has a mail
agent for the domain which should be able to deliver
mail for the domain.
MD records cause additional section processing which looks up an A type
record corresponding to MADNAME.
MD is obsolete. See the definition of MX and [RFC-974] for details of
the new scheme. The recommended policy for dealing with MD RRs found in
a master file is to reject them, or to convert them to MX RRs with a
preference of 0.
* */
namespace Heijden.DNS
{
public class RecordMD : Record
{
public string MADNAME;
public RecordMD(RecordReader rr)
{
MADNAME = rr.ReadDomainName();
}
public override string ToString()
{
return MADNAME;
}
}
}

41
MinecraftClient/Protocol/Dns/Records/Obsolete/RecordMF.cs
View file

@ -1,41 +0,0 @@
using System;
/*
*
3.3.5. MF RDATA format (Obsolete)
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
/ MADNAME /
/ /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
where:
MADNAME A <domain-name> which specifies a host which has a mail
agent for the domain which will accept mail for
forwarding to the domain.
MF records cause additional section processing which looks up an A type
record corresponding to MADNAME.
MF is obsolete. See the definition of MX and [RFC-974] for details ofw
the new scheme. The recommended policy for dealing with MD RRs found in
a master file is to reject them, or to convert them to MX RRs with a
preference of 10. */
namespace Heijden.DNS
{
public class RecordMF : Record
{
public string MADNAME;
public RecordMF(RecordReader rr)
{
MADNAME = rr.ReadDomainName();
}
public override string ToString()
{
return MADNAME;
}
}
}

57
MinecraftClient/Protocol/Dns/Records/Obsolete/RecordNSAPPTR.cs
View file

@ -1,57 +0,0 @@
using System;
/*
* http://tools.ietf.org/rfc/rfc1348.txt
* The NSAP-PTR RR
The NSAP-PTR RR is defined with mnemonic NSAP-PTR and a type code 23
(decimal).
Its function is analogous to the PTR record used for IP addresses [4,7].
NSAP-PTR has the following format:
<NSAP-suffix> <ttl> <class> NSAP-PTR <owner>
All fields are required.
<NSAP-suffix> enumerates the actual octet values assigned by the
assigning authority for the LOCAL network. Its format in master
files is a <character-string> syntactically identical to that used in
TXT and HINFO.
The format of NSAP-PTR is class insensitive. NSAP-PTR RR causes no
additional section processing.
For example:
In net ff08000574.nsap-in-addr.arpa:
444433332222111199990123000000ff NSAP-PTR foo.bar.com.
Or in net 11110031f67293.nsap-in-addr.arpa:
67894444333322220000 NSAP-PTR host.school.de.
The RR data is the ASCII representation of the digits. It is encoded
as a <character-string>.
*/
namespace Heijden.DNS
{
public class RecordNSAPPTR : Record
{
public string OWNER;
public RecordNSAPPTR(RecordReader rr)
{
OWNER = rr.ReadString();
}
public override string ToString()
{
return string.Format("{0}",OWNER);
}
}
}

80
MinecraftClient/Protocol/Dns/Records/Obsolete/RecordNXT.cs
View file

@ -1,80 +0,0 @@
using System;
using System.Text;
/*
* http://tools.ietf.org/rfc/rfc2065.txt
*
5.2 NXT RDATA Format
The RDATA for an NXT RR consists simply of a domain name followed by
a bit map.
The type number for the NXT RR is 30.
1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| next domain name /
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| type bit map /
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
The NXT RR type bit map is one bit per RR type present for the owner
name similar to the WKS socket bit map. The first bit represents RR
type zero (an illegal type which should not be present.) A one bit
indicates that at least one RR of that type is present for the owner
name. A zero indicates that no such RR is present. All bits not
specified because they are beyond the end of the bit map are assumed
to be zero. Note that bit 30, for NXT, will always be on so the
minimum bit map length is actually four octets. The NXT bit map
should be printed as a list of RR type mnemonics or decimal numbers
similar to the WKS RR.
The domain name may be compressed with standard DNS name compression
when being transmitted over the network. The size of the bit map can
be inferred from the RDLENGTH and the length of the next domain name.
*/
namespace Heijden.DNS
{
public class RecordNXT : Record
{
public string NEXTDOMAINNAME;
public byte[] BITMAP;
public RecordNXT(RecordReader rr)
{
ushort length = rr.ReadUInt16(-2);
NEXTDOMAINNAME = rr.ReadDomainName();
length -= (ushort)rr.Position;
BITMAP = new byte[length];
BITMAP = rr.ReadBytes(length);
}
private bool IsSet(int bitNr)
{
int intByte = (int)(bitNr / 8);
int intOffset = (bitNr % 8);
byte b = BITMAP[intByte];
int intTest = 1 << intOffset;
if ((b & intTest) == 0)
return false;
else
return true;
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
for (int bitNr = 1; bitNr < (BITMAP.Length * 8); bitNr++)
{
if (IsSet(bitNr))
sb.Append(" " + (Type)bitNr);
}
return string.Format("{0}{1}", NEXTDOMAINNAME, sb.ToString());
}
}
}

12
MinecraftClient/Protocol/Dns/Records/Record.cs
View file

@ -1,12 +0,0 @@
// Stuff records are made of
namespace Heijden.DNS
{
public abstract class Record
{
/// <summary>
/// The Resource Record this RDATA record belongs to
/// </summary>
public RR RR;
}
}

38
MinecraftClient/Protocol/Dns/Records/RecordA.cs
View file

@ -1,38 +0,0 @@
using System;
/*
3.4.1. A RDATA format
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| ADDRESS |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
where:
ADDRESS A 32 bit Internet address.
Hosts that have multiple Internet addresses will have multiple A
records.
*
*/
namespace Heijden.DNS
{
public class RecordA : Record
{
public System.Net.IPAddress Address;
public RecordA(RecordReader rr)
{
System.Net.IPAddress.TryParse(string.Format("{0}.{1}.{2}.{3}",
rr.ReadByte(),
rr.ReadByte(),
rr.ReadByte(),
rr.ReadByte()), out this.Address);
}
public override string ToString()
{
return Address.ToString();
}
}
}

38
MinecraftClient/Protocol/Dns/Records/RecordAAAA.cs
View file

@ -1,38 +0,0 @@
using System;
#region Rfc info
/*
2.2 AAAA data format
A 128 bit IPv6 address is encoded in the data portion of an AAAA
resource record in network byte order (high-order byte first).
*/
#endregion
namespace Heijden.DNS
{
public class RecordAAAA : Record
{
public System.Net.IPAddress Address;
public RecordAAAA(RecordReader rr)
{
System.Net.IPAddress.TryParse(
string.Format("{0:x}:{1:x}:{2:x}:{3:x}:{4:x}:{5:x}:{6:x}:{7:x}",
rr.ReadUInt16(),
rr.ReadUInt16(),
rr.ReadUInt16(),
rr.ReadUInt16(),
rr.ReadUInt16(),
rr.ReadUInt16(),
rr.ReadUInt16(),
rr.ReadUInt16()), out this.Address);
}
public override string ToString()
{
return Address.ToString();
}
}
}

52
MinecraftClient/Protocol/Dns/Records/RecordAFSDB.cs
View file

@ -1,52 +0,0 @@
using System;
/* http://tools.ietf.org/rfc/rfc1183.txt
* 1. AFS Data Base location
This section defines an extension of the DNS to locate servers both
for AFS (AFS is a registered trademark of Transarc Corporation) and
for the Open Software Foundation's (OSF) Distributed Computing
Environment (DCE) authenticated naming system using HP/Apollo's NCA,
both to be components of the OSF DCE. The discussion assumes that
the reader is familiar with AFS [5] and NCA [6].
The AFS (originally the Andrew File System) system uses the DNS to
map from a domain name to the name of an AFS cell database server.
The DCE Naming service uses the DNS for a similar function: mapping
from the domain name of a cell to authenticated name servers for that
cell. The method uses a new RR type with mnemonic AFSDB and type
code of 18 (decimal).
AFSDB has the following format:
<owner> <ttl> <class> AFSDB <subtype> <hostname>
Both RDATA fields are required in all AFSDB RRs. The <subtype> field
is a 16 bit integer. The <hostname> field is a domain name of a host
that has a server for the cell named by the owner name of the RR.
*/
namespace Heijden.DNS
{
public class RecordAFSDB : Record
{
public ushort SUBTYPE;
public string HOSTNAME;
public RecordAFSDB(RecordReader rr)
{
SUBTYPE = rr.ReadUInt16();
//HOSTNAME = rr.ReadString();
HOSTNAME = rr.ReadDomainName();
}
public override string ToString()
{
return string.Format("{0} {1}",
SUBTYPE,
HOSTNAME);
}
}
}

39
MinecraftClient/Protocol/Dns/Records/RecordCNAME.cs
View file

@ -1,39 +0,0 @@
using System;
/*
*
3.3.1. CNAME RDATA format
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
/ CNAME /
/ /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
where:
CNAME A <domain-name> which specifies the canonical or primary
name for the owner. The owner name is an alias.
CNAME RRs cause no additional section processing, but name servers may
choose to restart the query at the canonical name in certain cases. See
the description of name server logic in [RFC-1034] for details.
*
*/
namespace Heijden.DNS
{
public class RecordCNAME : Record
{
public string CNAME;
public RecordCNAME(RecordReader rr)
{
CNAME = rr.ReadDomainName();
}
public override string ToString()
{
return CNAME;
}
}
}

34
MinecraftClient/Protocol/Dns/Records/RecordDNAME.cs
View file

@ -1,34 +0,0 @@
using System;
/*
* http://tools.ietf.org/rfc/rfc2672.txt
*
3. The DNAME Resource Record
The DNAME RR has mnemonic DNAME and type code 39 (decimal).
DNAME has the following format:
<owner> <ttl> <class> DNAME <target>
The format is not class-sensitive. All fields are required. The
RDATA field <target> is a <domain-name> [DNSIS].
*
*/
namespace Heijden.DNS
{
public class RecordDNAME : Record
{
public string TARGET;
public RecordDNAME(RecordReader rr)
{
TARGET = rr.ReadDomainName();
}
public override string ToString()
{
return TARGET;
}
}
}

64
MinecraftClient/Protocol/Dns/Records/RecordDS.cs
View file

@ -1,64 +0,0 @@
using System;
using System.Text;
/*
* http://tools.ietf.org/rfc/rfc3658.txt
*
2.4. Wire Format of the DS record
The DS (type=43) record contains these fields: key tag, algorithm,
digest type, and the digest of a public key KEY record that is
allowed and/or used to sign the child's apex KEY RRset. Other keys
MAY sign the child's apex KEY RRset.
1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| key tag | algorithm | Digest type |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| digest (length depends on type) |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| (SHA-1 digest is 20 bytes) |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-|
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-|
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*/
namespace Heijden.DNS
{
public class RecordDS : Record
{
public UInt16 KEYTAG;
public byte ALGORITHM;
public byte DIGESTTYPE;
public byte[] DIGEST;
public RecordDS(RecordReader rr)
{
ushort length = rr.ReadUInt16(-2);
KEYTAG = rr.ReadUInt16();
ALGORITHM = rr.ReadByte();
DIGESTTYPE = rr.ReadByte();
length -= 4;
DIGEST = new byte[length];
DIGEST = rr.ReadBytes(length);
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
for (int intI = 0; intI < DIGEST.Length; intI++)
sb.AppendFormat("{0:x2}", DIGEST[intI]);
return string.Format("{0} {1} {2} {3}",
KEYTAG,
ALGORITHM,
DIGESTTYPE,
sb.ToString());
}
}
}

45
MinecraftClient/Protocol/Dns/Records/RecordHINFO.cs
View file

@ -1,45 +0,0 @@
using System;
/*
3.3.2. HINFO RDATA format
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
/ CPU /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
/ OS /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
where:
CPU A <character-string> which specifies the CPU type.
OS A <character-string> which specifies the operating
system type.
Standard values for CPU and OS can be found in [RFC-1010].
HINFO records are used to acquire general information about a host. The
main use is for protocols such as FTP that can use special procedures
when talking between machines or operating systems of the same type.
*/
namespace Heijden.DNS
{
public class RecordHINFO : Record
{
public string CPU;
public string OS;
public RecordHINFO(RecordReader rr)
{
CPU = rr.ReadString();
OS = rr.ReadString();
}
public override string ToString()
{
return string.Format("CPU={0} OS={1}",CPU,OS);
}
}
}

91
MinecraftClient/Protocol/Dns/Records/RecordISDN.cs
View file

@ -1,91 +0,0 @@
using System;
/* http://tools.ietf.org/rfc/rfc1183.txt
3.2. The ISDN RR
The ISDN RR is defined with mnemonic ISDN and type code 20 (decimal).
An ISDN (Integrated Service Digital Network) number is simply a
telephone number. The intent of the members of the CCITT is to
upgrade all telephone and data network service to a common service.
The numbering plan (E.163/E.164) is the same as the familiar
international plan for POTS (an un-official acronym, meaning Plain
Old Telephone Service). In E.166, CCITT says "An E.163/E.164
telephony subscriber may become an ISDN subscriber without a number
change."
ISDN has the following format:
<owner> <ttl> <class> ISDN <ISDN-address> <sa>
The <ISDN-address> field is required; <sa> is optional.
<ISDN-address> identifies the ISDN number of <owner> and DDI (Direct
Dial In) if any, as defined by E.164 [8] and E.163 [7], the ISDN and
PSTN (Public Switched Telephone Network) numbering plan. E.163
defines the country codes, and E.164 the form of the addresses. Its
format in master files is a <character-string> syntactically
identical to that used in TXT and HINFO.
<sa> specifies the subaddress (SA). The format of <sa> in master
files is a <character-string> syntactically identical to that used in
TXT and HINFO.
The format of ISDN is class insensitive. ISDN RRs cause no
additional section processing.
The <ISDN-address> is a string of characters, normally decimal
digits, beginning with the E.163 country code and ending with the DDI
if any. Note that ISDN, in Q.931, permits any IA5 character in the
general case.
The <sa> is a string of hexadecimal digits. For digits 0-9, the
concrete encoding in the Q.931 call setup information element is
identical to BCD.
For example:
Relay.Prime.COM. IN ISDN 150862028003217
sh.Prime.COM. IN ISDN 150862028003217 004
(Note: "1" is the country code for the North American Integrated
Numbering Area, i.e., the system of "area codes" familiar to people
in those countries.)
The RR data is the ASCII representation of the digits. It is encoded
as one or two <character-string>s, i.e., count followed by
characters.
CCITT recommendation E.166 [9] defines prefix escape codes for the
representation of ISDN (E.163/E.164) addresses in X.121, and PSDN
(X.121) addresses in E.164. It specifies that the exact codes are a
"national matter", i.e., different on different networks. A host
connected to the ISDN may be able to use both the X25 and ISDN
addresses, with the local prefix added.
*/
namespace Heijden.DNS
{
public class RecordISDN : Record
{
public string ISDNADDRESS;
public string SA;
public RecordISDN(RecordReader rr)
{
ISDNADDRESS = rr.ReadString();
SA = rr.ReadString();
}
public override string ToString()
{
return string.Format("{0} {1}",
ISDNADDRESS,
SA);
}
}
}

65
MinecraftClient/Protocol/Dns/Records/RecordKEY.cs
View file

@ -1,65 +0,0 @@
using System;
#region Rfc info
/* http://www.ietf.org/rfc/rfc2535.txt
*
3.1 KEY RDATA format
The RDATA for a KEY RR consists of flags, a protocol octet, the
algorithm number octet, and the public key itself. The format is as
follows:
1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| flags | protocol | algorithm |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| /
/ public key /
/ /
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-|
The KEY RR is not intended for storage of certificates and a separate
certificate RR has been developed for that purpose, defined in [RFC
2538].
The meaning of the KEY RR owner name, flags, and protocol octet are
described in Sections 3.1.1 through 3.1.5 below. The flags and
algorithm must be examined before any data following the algorithm
octet as they control the existence and format of any following data.
The algorithm and public key fields are described in Section 3.2.
The format of the public key is algorithm dependent.
KEY RRs do not specify their validity period but their authenticating
SIG RR(s) do as described in Section 4 below.
*/
#endregion
namespace Heijden.DNS
{
public class RecordKEY : Record
{
public UInt16 FLAGS;
public byte PROTOCOL;
public byte ALGORITHM;
public string PUBLICKEY;
public RecordKEY(RecordReader rr)
{
FLAGS = rr.ReadUInt16();
PROTOCOL = rr.ReadByte();
ALGORITHM = rr.ReadByte();
PUBLICKEY = rr.ReadString();
}
public override string ToString()
{
return string.Format("{0} {1} {2} \"{3}\"",
FLAGS,
PROTOCOL,
ALGORITHM,
PUBLICKEY);
}
}
}

65
MinecraftClient/Protocol/Dns/Records/RecordKX.cs
View file

@ -1,65 +0,0 @@
using System;
/*
* http://tools.ietf.org/rfc/rfc2230.txt
*
* 3.1 KX RDATA format
The KX DNS record has the following RDATA format:
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| PREFERENCE |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
/ EXCHANGER /
/ /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
where:
PREFERENCE A 16 bit non-negative integer which specifies the
preference given to this RR among other KX records
at the same owner. Lower values are preferred.
EXCHANGER A <domain-name> which specifies a host willing to
act as a mail exchange for the owner name.
KX records MUST cause type A additional section processing for the
host specified by EXCHANGER. In the event that the host processing
the DNS transaction supports IPv6, KX records MUST also cause type
AAAA additional section processing.
The KX RDATA field MUST NOT be compressed.
*/
namespace Heijden.DNS
{
public class RecordKX : Record, IComparable
{
public ushort PREFERENCE;
public string EXCHANGER;
public RecordKX(RecordReader rr)
{
PREFERENCE = rr.ReadUInt16();
EXCHANGER = rr.ReadDomainName();
}
public override string ToString()
{
return string.Format("{0} {1}", PREFERENCE, EXCHANGER);
}
public int CompareTo(object objA)
{
RecordKX recordKX = objA as RecordKX;
if (recordKX == null)
return -1;
else if (this.PREFERENCE > recordKX.PREFERENCE)
return 1;
else if (this.PREFERENCE < recordKX.PREFERENCE)
return -1;
else // they are the same, now compare case insensitive names
return string.Compare(this.EXCHANGER, recordKX.EXCHANGER, true);
}
}
}

199
MinecraftClient/Protocol/Dns/Records/RecordLOC.cs
View file

@ -1,199 +0,0 @@
using System;
using System.Text;
/*
* http://www.ietf.org/rfc/rfc1876.txt
*
2. RDATA Format
MSB LSB
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
0| VERSION | SIZE |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
2| HORIZ PRE | VERT PRE |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
4| LATITUDE |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
6| LATITUDE |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
8| LONGITUDE |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
10| LONGITUDE |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
12| ALTITUDE |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
14| ALTITUDE |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
where:
VERSION Version number of the representation. This must be zero.
Implementations are required to check this field and make
no assumptions about the format of unrecognized versions.
SIZE The diameter of a sphere enclosing the described entity, in
centimeters, expressed as a pair of four-bit unsigned
integers, each ranging from zero to nine, with the most
significant four bits representing the base and the second
number representing the power of ten by which to multiply
the base. This allows sizes from 0e0 (<1cm) to 9e9
(90,000km) to be expressed. This representation was chosen
such that the hexadecimal representation can be read by
eye; 0x15 = 1e5. Four-bit values greater than 9 are
undefined, as are values with a base of zero and a non-zero
exponent.
Since 20000000m (represented by the value 0x29) is greater
than the equatorial diameter of the WGS 84 ellipsoid
(12756274m), it is therefore suitable for use as a
"worldwide" size.
HORIZ PRE The horizontal precision of the data, in centimeters,
expressed using the same representation as SIZE. This is
the diameter of the horizontal "circle of error", rather
than a "plus or minus" value. (This was chosen to match
the interpretation of SIZE; to get a "plus or minus" value,
divide by 2.)
VERT PRE The vertical precision of the data, in centimeters,
expressed using the sane representation as for SIZE. This
is the total potential vertical error, rather than a "plus
or minus" value. (This was chosen to match the
interpretation of SIZE; to get a "plus or minus" value,
divide by 2.) Note that if altitude above or below sea
level is used as an approximation for altitude relative to
the [WGS 84] ellipsoid, the precision value should be
adjusted.
LATITUDE The latitude of the center of the sphere described by the
SIZE field, expressed as a 32-bit integer, most significant
octet first (network standard byte order), in thousandths
of a second of arc. 2^31 represents the equator; numbers
above that are north latitude.
LONGITUDE The longitude of the center of the sphere described by the
SIZE field, expressed as a 32-bit integer, most significant
octet first (network standard byte order), in thousandths
of a second of arc, rounded away from the prime meridian.
2^31 represents the prime meridian; numbers above that are
east longitude.
ALTITUDE The altitude of the center of the sphere described by the
SIZE field, expressed as a 32-bit integer, most significant
octet first (network standard byte order), in centimeters,
from a base of 100,000m below the [WGS 84] reference
spheroid used by GPS (semimajor axis a=6378137.0,
reciprocal flattening rf=298.257223563). Altitude above
(or below) sea level may be used as an approximation of
altitude relative to the the [WGS 84] spheroid, though due
to the Earth's surface not being a perfect spheroid, there
will be differences. (For example, the geoid (which sea
level approximates) for the continental US ranges from 10
meters to 50 meters below the [WGS 84] spheroid.
Adjustments to ALTITUDE and/or VERT PRE will be necessary
in most cases. The Defense Mapping Agency publishes geoid
height values relative to the [WGS 84] ellipsoid.
*/
namespace Heijden.DNS
{
public class RecordLOC : Record
{
public byte VERSION;
public byte SIZE;
public byte HORIZPRE;
public byte VERTPRE;
public UInt32 LATITUDE;
public UInt32 LONGITUDE;
public UInt32 ALTITUDE;
private string SizeToString(byte s)
{
string strUnit = "cm";
int intBase = s >> 4;
int intPow = s & 0x0f;
if (intPow >= 2)
{
intPow -= 2;
strUnit = "m";
}
/*
if (intPow >= 3)
{
intPow -= 3;
strUnit = "km";
}
*/
StringBuilder sb = new StringBuilder();
sb.AppendFormat("{0}", intBase);
for (; intPow > 0; intPow--)
sb.Append('0');
sb.Append(strUnit);
return sb.ToString();
}
private string LonToTime(UInt32 r)
{
UInt32 Mid = 2147483648; // 2^31
char Dir = 'E';
if (r > Mid)
{
Dir = 'W';
r -= Mid;
}
double h = r / (360000.0 * 10.0);
double m = 60.0 * (h - (int)h);
double s = 60.0 * (m - (int)m);
return string.Format("{0} {1} {2:0.000} {3}", (int)h, (int)m, s, Dir);
}
private string ToTime(UInt32 r, char Below,char Above)
{
UInt32 Mid = 2147483648; // 2^31
char Dir = '?';
if (r > Mid)
{
Dir = Above;
r -= Mid;
}
else
{
Dir = Below;
r = Mid - r;
}
double h = r / (360000.0 * 10.0);
double m = 60.0 * (h - (int)h);
double s = 60.0 * (m - (int)m);
return string.Format("{0} {1} {2:0.000} {3}", (int)h, (int)m, s, Dir);
}
private string ToAlt(UInt32 a)
{
double alt = (a / 100.0) - 100000.00;
return string.Format("{0:0.00}m", alt);
}
public RecordLOC(RecordReader rr)
{
VERSION = rr.ReadByte(); // must be 0!
SIZE = rr.ReadByte();
HORIZPRE = rr.ReadByte();
VERTPRE = rr.ReadByte();
LATITUDE = rr.ReadUInt32();
LONGITUDE = rr.ReadUInt32();
ALTITUDE = rr.ReadUInt32();
}
public override string ToString()
{
return string.Format("{0} {1} {2} {3} {4} {5}",
ToTime(LATITUDE,'S','N'),
ToTime(LONGITUDE,'W','E'),
ToAlt(ALTITUDE),
SizeToString(SIZE),
SizeToString(HORIZPRE),
SizeToString(VERTPRE));
}
}
}

35
MinecraftClient/Protocol/Dns/Records/RecordMB.cs
View file

@ -1,35 +0,0 @@
using System;
/*
3.3.3. MB RDATA format (EXPERIMENTAL)
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
/ MADNAME /
/ /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
where:
MADNAME A <domain-name> which specifies a host which has the
specified mailbox.
MB records cause additional section processing which looks up an A type
RRs corresponding to MADNAME.
*/
namespace Heijden.DNS
{
public class RecordMB : Record
{
public string MADNAME;
public RecordMB(RecordReader rr)
{
MADNAME = rr.ReadDomainName();
}
public override string ToString()
{
return MADNAME;
}
}
}

34
MinecraftClient/Protocol/Dns/Records/RecordMG.cs
View file

@ -1,34 +0,0 @@
using System;
/*
3.3.6. MG RDATA format (EXPERIMENTAL)
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
/ MGMNAME /
/ /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
where:
MGMNAME A <domain-name> which specifies a mailbox which is a
member of the mail group specified by the domain name.
MG records cause no additional section processing.
*/
namespace Heijden.DNS
{
public class RecordMG : Record
{
public string MGMNAME;
public RecordMG(RecordReader rr)
{
MGMNAME = rr.ReadDomainName();
}
public override string ToString()
{
return MGMNAME;
}
}
}

52
MinecraftClient/Protocol/Dns/Records/RecordMINFO.cs
View file

@ -1,52 +0,0 @@
using System;
/*
3.3.7. MINFO RDATA format (EXPERIMENTAL)
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
/ RMAILBX /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
/ EMAILBX /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
where:
RMAILBX A <domain-name> which specifies a mailbox which is
responsible for the mailing list or mailbox. If this
domain name names the root, the owner of the MINFO RR is
responsible for itself. Note that many existing mailing
lists use a mailbox X-request for the RMAILBX field of
mailing list X, e.g., Msgroup-request for Msgroup. This
field provides a more general mechanism.
EMAILBX A <domain-name> which specifies a mailbox which is to
receive error messages related to the mailing list or
mailbox specified by the owner of the MINFO RR (similar
to the ERRORS-TO: field which has been proposed). If
this domain name names the root, errors should be
returned to the sender of the message.
MINFO records cause no additional section processing. Although these
records can be associated with a simple mailbox, they are usually used
with a mailing list.
*/
namespace Heijden.DNS
{
public class RecordMINFO : Record
{
public string RMAILBX;
public string EMAILBX;
public RecordMINFO(RecordReader rr)
{
RMAILBX = rr.ReadDomainName();
EMAILBX = rr.ReadDomainName();
}
public override string ToString()
{
return string.Format("{0} {1}",RMAILBX,EMAILBX);
}
}
}

36
MinecraftClient/Protocol/Dns/Records/RecordMR.cs
View file

@ -1,36 +0,0 @@
using System;
/*
3.3.8. MR RDATA format (EXPERIMENTAL)
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
/ NEWNAME /
/ /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
where:
NEWNAME A <domain-name> which specifies a mailbox which is the
proper rename of the specified mailbox.
MR records cause no additional section processing. The main use for MR
is as a forwarding entry for a user who has moved to a different
mailbox.
*/
namespace Heijden.DNS
{
public class RecordMR : Record
{
public string NEWNAME;
public RecordMR(RecordReader rr)
{
NEWNAME = rr.ReadDomainName();
}
public override string ToString()
{
return NEWNAME;
}
}
}

59
MinecraftClient/Protocol/Dns/Records/RecordMX.cs
View file

@ -1,59 +0,0 @@
using System;
namespace Heijden.DNS
{
/*
3.3.9. MX RDATA format
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| PREFERENCE |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
/ EXCHANGE /
/ /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
where:
PREFERENCE A 16 bit integer which specifies the preference given to
this RR among others at the same owner. Lower values
are preferred.
EXCHANGE A <domain-name> which specifies a host willing to act as
a mail exchange for the owner name.
MX records cause type A additional section processing for the host
specified by EXCHANGE. The use of MX RRs is explained in detail in
[RFC-974].
*/
public class RecordMX : Record, IComparable
{
public ushort PREFERENCE;
public string EXCHANGE;
public RecordMX(RecordReader rr)
{
PREFERENCE = rr.ReadUInt16();
EXCHANGE = rr.ReadDomainName();
}
public override string ToString()
{
return string.Format("{0} {1}", PREFERENCE, EXCHANGE);
}
public int CompareTo(object objA)
{
RecordMX recordMX = objA as RecordMX;
if (recordMX == null)
return -1;
else if (this.PREFERENCE > recordMX.PREFERENCE)
return 1;
else if (this.PREFERENCE < recordMX.PREFERENCE)
return -1;
else // they are the same, now compare case insensitive names
return string.Compare(this.EXCHANGE, recordMX.EXCHANGE, true);
}
}
}

77
MinecraftClient/Protocol/Dns/Records/RecordNAPTR.cs
View file

@ -1,77 +0,0 @@
using System;
/*
* http://www.faqs.org/rfcs/rfc2915.html
*
8. DNS Packet Format
The packet format for the NAPTR record is:
1 1 1 1 1 1
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| ORDER |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| PREFERENCE |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
/ FLAGS /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
/ SERVICES /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
/ REGEXP /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
/ REPLACEMENT /
/ /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
where:
FLAGS A <character-string> which contains various flags.
SERVICES A <character-string> which contains protocol and service
identifiers.
REGEXP A <character-string> which contains a regular expression.
REPLACEMENT A <domain-name> which specifies the new value in the
case where the regular expression is a simple replacement
operation.
<character-string> and <domain-name> as used here are defined in
RFC1035 [1].
*/
namespace Heijden.DNS
{
public class RecordNAPTR : Record
{
public ushort ORDER;
public ushort PREFERENCE;
public string FLAGS;
public string SERVICES;
public string REGEXP;
public string REPLACEMENT;
public RecordNAPTR(RecordReader rr)
{
ORDER = rr.ReadUInt16();
PREFERENCE = rr.ReadUInt16();
FLAGS = rr.ReadString();
SERVICES = rr.ReadString();
REGEXP = rr.ReadString();
REPLACEMENT = rr.ReadDomainName();
}
public override string ToString()
{
return string.Format("{0} {1} \"{2}\" \"{3}\" \"{4}\" {5}",
ORDER,
PREFERENCE,
FLAGS,
SERVICES,
REGEXP,
REPLACEMENT);
}
}
}

43
MinecraftClient/Protocol/Dns/Records/RecordNS.cs
View file

@ -1,43 +0,0 @@
using System;
/*
3.3.11. NS RDATA format
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
/ NSDNAME /
/ /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
where:
NSDNAME A <domain-name> which specifies a host which should be
authoritative for the specified class and domain.
NS records cause both the usual additional section processing to locate
a type A record, and, when used in a referral, a special search of the
zone in which they reside for glue information.
The NS RR states that the named host should be expected to have a zone
starting at owner name of the specified class. Note that the class may
not indicate the protocol family which should be used to communicate
with the host, although it is typically a strong hint. For example,
hosts which are name servers for either Internet (IN) or Hesiod (HS)
class information are normally queried using IN class protocols.
*/
namespace Heijden.DNS
{
public class RecordNS : Record
{
public string NSDNAME;
public RecordNS(RecordReader rr)
{
NSDNAME = rr.ReadDomainName();
}
public override string ToString()
{
return NSDNAME;
}
}
}

72
MinecraftClient/Protocol/Dns/Records/RecordNSAP.cs
View file

@ -1,72 +0,0 @@
using System;
using System.Text;
/*
* http://tools.ietf.org/rfc/rfc1348.txt
* http://tools.ietf.org/html/rfc1706
*
* |--------------|
| <-- IDP --> |
|--------------|-------------------------------------|
| AFI | IDI | <-- DSP --> |
|-----|--------|-------------------------------------|
| 47 | 0005 | DFI | AA |Rsvd | RD |Area | ID |Sel |
|-----|--------|-----|----|-----|----|-----|----|----|
octets | 1 | 2 | 1 | 3 | 2 | 2 | 2 | 6 | 1 |
|-----|--------|-----|----|-----|----|-----|----|----|
IDP Initial Domain Part
AFI Authority and Format Identifier
IDI Initial Domain Identifier
DSP Domain Specific Part
DFI DSP Format Identifier
AA Administrative Authority
Rsvd Reserved
RD Routing Domain Identifier
Area Area Identifier
ID System Identifier
SEL NSAP Selector
Figure 1: GOSIP Version 2 NSAP structure.
*/
namespace Heijden.DNS
{
public class RecordNSAP : Record
{
public ushort LENGTH;
public byte[] NSAPADDRESS;
public RecordNSAP(RecordReader rr)
{
LENGTH = rr.ReadUInt16();
NSAPADDRESS = rr.ReadBytes(LENGTH);
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.AppendFormat("{0} ", LENGTH);
for (int intI = 0; intI < NSAPADDRESS.Length; intI++)
sb.AppendFormat("{0:X00}", NSAPADDRESS[intI]);
return sb.ToString();
}
public string ToGOSIPV2()
{
return string.Format("{0:X}.{1:X}.{2:X}.{3:X}.{4:X}.{5:X}.{6:X}{7:X}.{8:X}",
NSAPADDRESS[0], // AFI
NSAPADDRESS[1] << 8 | NSAPADDRESS[2], // IDI
NSAPADDRESS[3], // DFI
NSAPADDRESS[4] << 16 | NSAPADDRESS[5] << 8 | NSAPADDRESS[6], // AA
NSAPADDRESS[7] << 8 | NSAPADDRESS[8], // Rsvd
NSAPADDRESS[9] << 8 | NSAPADDRESS[10],// RD
NSAPADDRESS[11] << 8 | NSAPADDRESS[12],// Area
NSAPADDRESS[13] << 16 | NSAPADDRESS[14] << 8 | NSAPADDRESS[15], // ID-High
NSAPADDRESS[16] << 16 | NSAPADDRESS[17] << 8 | NSAPADDRESS[18], // ID-Low
NSAPADDRESS[19]);
}
}
}

38
MinecraftClient/Protocol/Dns/Records/RecordNULL.cs
View file

@ -1,38 +0,0 @@
using System;
/*
3.3.10. NULL RDATA format (EXPERIMENTAL)
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
/ <anything> /
/ /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
Anything at all may be in the RDATA field so long as it is 65535 octets
or less.
NULL records cause no additional section processing. NULL RRs are not
allowed in master files. NULLs are used as placeholders in some
experimental extensions of the DNS.
*/
namespace Heijden.DNS
{
public class RecordNULL : Record
{
public byte[] ANYTHING;
public RecordNULL(RecordReader rr)
{
rr.Position -= 2;
// re-read length
ushort RDLENGTH = rr.ReadUInt16();
ANYTHING = new byte[RDLENGTH];
ANYTHING = rr.ReadBytes(RDLENGTH);
}
public override string ToString()
{
return string.Format("...binary data... ({0}) bytes",ANYTHING.Length);
}
}
}

38
MinecraftClient/Protocol/Dns/Records/RecordPTR.cs
View file

@ -1,38 +0,0 @@
using System;
/*
3.3.12. PTR RDATA format
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
/ PTRDNAME /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
where:
PTRDNAME A <domain-name> which points to some location in the
domain name space.
PTR records cause no additional section processing. These RRs are used
in special domains to point to some other location in the domain space.
These records are simple data, and don't imply any special processing
similar to that performed by CNAME, which identifies aliases. See the
description of the IN-ADDR.ARPA domain for an example.
*/
namespace Heijden.DNS
{
public class RecordPTR : Record
{
public string PTRDNAME;
public RecordPTR(RecordReader rr)
{
PTRDNAME = rr.ReadDomainName();
}
public override string ToString()
{
return PTRDNAME;
}
}
}

97
MinecraftClient/Protocol/Dns/Records/RecordPX.cs
View file

@ -1,97 +0,0 @@
using System;
/*
* http://tools.ietf.org/rfc/rfc2163.txt
*
4. The new DNS resource record for MIXER mapping rules: PX
The specification of the Internet DNS (RFC1035) provides a number of
specific resource records (RRs) to contain specific pieces of
information. In particular they contain the Mail eXchanger (MX) RR
and the host Address (A) records which are used by the Internet SMTP
mailers. As we will store the RFC822 to X.400 mapping information in
the already existing DNS name tree, we need to define a new DNS RR in
order to avoid any possible clash or misuse of already existing data
structures. The same new RR will also be used to store the mappings
from X.400 to RFC822. More over the mapping information, i.e., the
MCGAMs, has a specific format and syntax which require an appropriate
data structure and processing. A further advantage of defining a new
RR is the ability to include flexibility for some eventual future
development.
The definition of the new 'PX' DNS resource record is:
class: IN (Internet)
name: PX (pointer to X.400/RFC822 mapping information)
value: 26
The PX RDATA format is:
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| PREFERENCE |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
/ MAP822 /
/ /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
/ MAPX400 /
/ /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
where:
PREFERENCE A 16 bit integer which specifies the preference given to
this RR among others at the same owner. Lower values
are preferred;
MAP822 A <domain-name> element containing <rfc822-domain>, the
RFC822 part of the MCGAM;
MAPX400 A <domain-name> element containing the value of
<x400-in-domain-syntax> derived from the X.400 part of
the MCGAM (see sect. 4.2);
PX records cause no additional section processing. The PX RR format
is the usual one:
<name> [<class>] [<TTL>] <type> <RDATA>
When we store in DNS a 'table1' or a 'gate1' entry, then <name> will
be an X.400 mail domain name in DNS syntax (see sect. 4.2). When we
store a 'table2' or a 'gate2' table entry, <name> will be an RFC822
mail domain name, including both fully qualified DNS domains and mail
only domains (MX-only domains). All normal DNS conventions, like
default values, wildcards, abbreviations and message compression,
apply also for all the components of the PX RR. In particular <name>,
MAP822 and MAPX400, as <domain-name> elements, must have the final
"." (root) when they are fully qualified.
*/
namespace Heijden.DNS
{
public class RecordPX : Record
{
public UInt16 PREFERENCE;
public string MAP822;
public string MAPX400;
public RecordPX(RecordReader rr)
{
PREFERENCE = rr.ReadUInt16();
MAP822 = rr.ReadDomainName();
MAPX400 = rr.ReadDomainName();
}
public override string ToString()
{
return string.Format("{0} {1} {2}",
PREFERENCE,
MAP822,
MAPX400);
}
}
}

54
MinecraftClient/Protocol/Dns/Records/RecordRP.cs
View file

@ -1,54 +0,0 @@
using System;
/* http://tools.ietf.org/rfc/rfc1183.txt
2.2. The Responsible Person RR
The method uses a new RR type with mnemonic RP and type code of 17
(decimal).
RP has the following format:
<owner> <ttl> <class> RP <mbox-dname> <txt-dname>
Both RDATA fields are required in all RP RRs.
The first field, <mbox-dname>, is a domain name that specifies the
mailbox for the responsible person. Its format in master files uses
the DNS convention for mailbox encoding, identical to that used for
the RNAME mailbox field in the SOA RR. The root domain name (just
".") may be specified for <mbox-dname> to indicate that no mailbox is
available.
The second field, <txt-dname>, is a domain name for which TXT RR's
exist. A subsequent query can be performed to retrieve the
associated TXT resource records at <txt-dname>. This provides a
level of indirection so that the entity can be referred to from
multiple places in the DNS. The root domain name (just ".") may be
specified for <txt-dname> to indicate that the TXT_DNAME is absent,
and no associated TXT RR exists.
*/
namespace Heijden.DNS
{
public class RecordRP : Record
{
public string MBOXDNAME;
public string TXTDNAME;
public RecordRP(RecordReader rr)
{
//MBOXDNAME = rr.ReadString();
MBOXDNAME = rr.ReadDomainName();
TXTDNAME = rr.ReadDomainName();
}
public override string ToString()
{
return string.Format("{0} {1}",
MBOXDNAME,
TXTDNAME);
}
}
}

76
MinecraftClient/Protocol/Dns/Records/RecordRT.cs
View file

@ -1,76 +0,0 @@
using System;
/* http://tools.ietf.org/rfc/rfc1183.txt
3.3. The Route Through RR
The Route Through RR is defined with mnemonic RT and type code 21
(decimal).
The RT resource record provides a route-through binding for hosts
that do not have their own direct wide area network addresses. It is
used in much the same way as the MX RR.
RT has the following format:
<owner> <ttl> <class> RT <preference> <intermediate-host>
Both RDATA fields are required in all RT RRs.
The first field, <preference>, is a 16 bit integer, representing the
preference of the route. Smaller numbers indicate more preferred
routes.
<intermediate-host> is the domain name of a host which will serve as
an intermediate in reaching the host specified by <owner>. The DNS
RRs associated with <intermediate-host> are expected to include at
least one A, X25, or ISDN record.
The format of the RT RR is class insensitive. RT records cause type
X25, ISDN, and A additional section processing for <intermediate-
host>.
For example,
sh.prime.com. IN RT 2 Relay.Prime.COM.
IN RT 10 NET.Prime.COM.
*.prime.com. IN RT 90 Relay.Prime.COM.
When a host is looking up DNS records to attempt to route a datagram,
it first looks for RT records for the destination host, which point
to hosts with address records (A, X25, ISDN) compatible with the wide
area networks available to the host. If it is itself in the set of
RT records, it discards any RTs with preferences higher or equal to
its own. If there are no (remaining) RTs, it can then use address
records of the destination itself.
Wild-card RTs are used exactly as are wild-card MXs. RT's do not
"chain"; that is, it is not valid to use the RT RRs found for a host
referred to by an RT.
The concrete encoding is identical to the MX RR.
*/
namespace Heijden.DNS
{
public class RecordRT : Record
{
public ushort PREFERENCE;
public string INTERMEDIATEHOST;
public RecordRT(RecordReader rr)
{
PREFERENCE = rr.ReadUInt16();
INTERMEDIATEHOST = rr.ReadDomainName();
}
public override string ToString()
{
return string.Format("{0} {1}",
PREFERENCE,
INTERMEDIATEHOST);
}
}
}

77
MinecraftClient/Protocol/Dns/Records/RecordSIG.cs
View file

@ -1,77 +0,0 @@
using System;
#region Rfc info
/*
* http://www.ietf.org/rfc/rfc2535.txt
* 4.1 SIG RDATA Format
The RDATA portion of a SIG RR is as shown below. The integrity of
the RDATA information is protected by the signature field.
1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| type covered | algorithm | labels |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| original TTL |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| signature expiration |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| signature inception |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| key tag | |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ signer's name +
| /
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-/
/ /
/ signature /
/ /
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*/
#endregion
namespace Heijden.DNS
{
public class RecordSIG : Record
{
public UInt16 TYPECOVERED;
public byte ALGORITHM;
public byte LABELS;
public UInt32 ORIGINALTTL;
public UInt32 SIGNATUREEXPIRATION;
public UInt32 SIGNATUREINCEPTION;
public UInt16 KEYTAG;
public string SIGNERSNAME;
public string SIGNATURE;
public RecordSIG(RecordReader rr)
{
TYPECOVERED = rr.ReadUInt16();
ALGORITHM = rr.ReadByte();
LABELS = rr.ReadByte();
ORIGINALTTL = rr.ReadUInt32();
SIGNATUREEXPIRATION = rr.ReadUInt32();
SIGNATUREINCEPTION = rr.ReadUInt32();
KEYTAG = rr.ReadUInt16();
SIGNERSNAME = rr.ReadDomainName();
SIGNATURE = rr.ReadString();
}
public override string ToString()
{
return string.Format("{0} {1} {2} {3} {4} {5} {6} {7} \"{8}\"",
TYPECOVERED,
ALGORITHM,
LABELS,
ORIGINALTTL,
SIGNATUREEXPIRATION,
SIGNATUREINCEPTION,
KEYTAG,
SIGNERSNAME,
SIGNATURE);
}
}
}

105
MinecraftClient/Protocol/Dns/Records/RecordSOA.cs
View file

@ -1,105 +0,0 @@
using System;
/*
3.3.13. SOA RDATA format
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
/ MNAME /
/ /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
/ RNAME /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| SERIAL |
| |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| REFRESH |
| |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| RETRY |
| |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| EXPIRE |
| |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| MINIMUM |
| |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
where:
MNAME The <domain-name> of the name server that was the
original or primary source of data for this zone.
RNAME A <domain-name> which specifies the mailbox of the
person responsible for this zone.
SERIAL The unsigned 32 bit version number of the original copy
of the zone. Zone transfers preserve this value. This
value wraps and should be compared using sequence space
arithmetic.
REFRESH A 32 bit time interval before the zone should be
refreshed.
RETRY A 32 bit time interval that should elapse before a
failed refresh should be retried.
EXPIRE A 32 bit time value that specifies the upper limit on
the time interval that can elapse before the zone is no
longer authoritative.
MINIMUM The unsigned 32 bit minimum TTL field that should be
exported with any RR from this zone.
SOA records cause no additional section processing.
All times are in units of seconds.
Most of these fields are pertinent only for name server maintenance
operations. However, MINIMUM is used in all query operations that
retrieve RRs from a zone. Whenever a RR is sent in a response to a
query, the TTL field is set to the maximum of the TTL field from the RR
and the MINIMUM field in the appropriate SOA. Thus MINIMUM is a lower
bound on the TTL field for all RRs in a zone. Note that this use of
MINIMUM should occur when the RRs are copied into the response and not
when the zone is loaded from a master file or via a zone transfer. The
reason for this provison is to allow future dynamic update facilities to
change the SOA RR with known semantics.
*/
namespace Heijden.DNS
{
public class RecordSOA : Record
{
public string MNAME;
public string RNAME;
public uint SERIAL;
public uint REFRESH;
public uint RETRY;
public uint EXPIRE;
public uint MINIMUM;
public RecordSOA(RecordReader rr)
{
MNAME = rr.ReadDomainName();
RNAME = rr.ReadDomainName();
SERIAL = rr.ReadUInt32();
REFRESH = rr.ReadUInt32();
RETRY = rr.ReadUInt32();
EXPIRE = rr.ReadUInt32();
MINIMUM = rr.ReadUInt32();
}
public override string ToString()
{
return string.Format("{0} {1} {2} {3} {4} {5} {6}",
MNAME,
RNAME,
SERIAL,
REFRESH,
RETRY,
EXPIRE,
MINIMUM);
}
}
}

93
MinecraftClient/Protocol/Dns/Records/RecordSRV.cs
View file

@ -1,93 +0,0 @@
using System;
/*
* http://www.ietf.org/rfc/rfc2782.txt
*
Priority
The priority of this target host. A client MUST attempt to
contact the target host with the lowest-numbered priority it can
reach; target hosts with the same priority SHOULD be tried in an
order defined by the weight field. The range is 0-65535. This
is a 16 bit unsigned integer in network byte order.
Weight
A server selection mechanism. The weight field specifies a
relative weight for entries with the same priority. Larger
weights SHOULD be given a proportionately higher probability of
being selected. The range of this number is 0-65535. This is a
16 bit unsigned integer in network byte order. Domain
administrators SHOULD use Weight 0 when there isn't any server
selection to do, to make the RR easier to read for humans (less
noisy). In the presence of records containing weights greater
than 0, records with weight 0 should have a very small chance of
being selected.
In the absence of a protocol whose specification calls for the
use of other weighting information, a client arranges the SRV
RRs of the same Priority in the order in which target hosts,
specified by the SRV RRs, will be contacted. The following
algorithm SHOULD be used to order the SRV RRs of the same
priority:
To select a target to be contacted next, arrange all SRV RRs
(that have not been ordered yet) in any order, except that all
those with weight 0 are placed at the beginning of the list.
Compute the sum of the weights of those RRs, and with each RR
associate the running sum in the selected order. Then choose a
uniform random number between 0 and the sum computed
(inclusive), and select the RR whose running sum value is the
first in the selected order which is greater than or equal to
the random number selected. The target host specified in the
selected SRV RR is the next one to be contacted by the client.
Remove this SRV RR from the set of the unordered SRV RRs and
apply the described algorithm to the unordered SRV RRs to select
the next target host. Continue the ordering process until there
are no unordered SRV RRs. This process is repeated for each
Priority.
Port
The port on this target host of this service. The range is 0-
65535. This is a 16 bit unsigned integer in network byte order.
This is often as specified in Assigned Numbers but need not be.
Target
The domain name of the target host. There MUST be one or more
address records for this name, the name MUST NOT be an alias (in
the sense of RFC 1034 or RFC 2181). Implementors are urged, but
not required, to return the address record(s) in the Additional
Data section. Unless and until permitted by future standards
action, name compression is not to be used for this field.
A Target of "." means that the service is decidedly not
available at this domain.
*/
namespace Heijden.DNS
{
public class RecordSRV : Record
{
public ushort PRIORITY;
public ushort WEIGHT;
public ushort PORT;
public string TARGET;
public RecordSRV(RecordReader rr)
{
PRIORITY = rr.ReadUInt16();
WEIGHT = rr.ReadUInt16();
PORT = rr.ReadUInt16();
TARGET = rr.ReadDomainName();
}
public override string ToString()
{
return string.Format("{0} {1} {2} {3}",
PRIORITY,
WEIGHT,
PORT,
TARGET);
}
}
}

62
MinecraftClient/Protocol/Dns/Records/RecordTKEY.cs
View file

@ -1,62 +0,0 @@
using System;
/*
* http://tools.ietf.org/rfc/rfc2930.txt
*
2. The TKEY Resource Record
The TKEY resource record (RR) has the structure given below. Its RR
type code is 249.
Field Type Comment
----- ---- -------
Algorithm: domain
Inception: u_int32_t
Expiration: u_int32_t
Mode: u_int16_t
Error: u_int16_t
Key Size: u_int16_t
Key Data: octet-stream
Other Size: u_int16_t
Other Data: octet-stream undefined by this specification
*/
namespace Heijden.DNS
{
public class RecordTKEY : Record
{
public string ALGORITHM;
public UInt32 INCEPTION;
public UInt32 EXPIRATION;
public UInt16 MODE;
public UInt16 ERROR;
public UInt16 KEYSIZE;
public byte[] KEYDATA;
public UInt16 OTHERSIZE;
public byte[] OTHERDATA;
public RecordTKEY(RecordReader rr)
{
ALGORITHM = rr.ReadDomainName();
INCEPTION = rr.ReadUInt32();
EXPIRATION = rr.ReadUInt32();
MODE = rr.ReadUInt16();
ERROR = rr.ReadUInt16();
KEYSIZE = rr.ReadUInt16();
KEYDATA = rr.ReadBytes(KEYSIZE);
OTHERSIZE = rr.ReadUInt16();
OTHERDATA = rr.ReadBytes(OTHERSIZE);
}
public override string ToString()
{
return string.Format("{0} {1} {2} {3} {4}",
ALGORITHM,
INCEPTION,
EXPIRATION,
MODE,
ERROR);
}
}
}

64
MinecraftClient/Protocol/Dns/Records/RecordTSIG.cs
View file

@ -1,64 +0,0 @@
using System;
/*
* http://www.ietf.org/rfc/rfc2845.txt
*
* Field Name Data Type Notes
--------------------------------------------------------------
Algorithm Name domain-name Name of the algorithm
in domain name syntax.
Time Signed u_int48_t seconds since 1-Jan-70 UTC.
Fudge u_int16_t seconds of error permitted
in Time Signed.
MAC Size u_int16_t number of octets in MAC.
MAC octet stream defined by Algorithm Name.
Original ID u_int16_t original message ID
Error u_int16_t expanded RCODE covering
TSIG processing.
Other Len u_int16_t length, in octets, of
Other Data.
Other Data octet stream empty unless Error == BADTIME
*/
namespace Heijden.DNS
{
public class RecordTSIG : Record
{
public string ALGORITHMNAME;
public long TIMESIGNED;
public UInt16 FUDGE;
public UInt16 MACSIZE;
public byte[] MAC;
public UInt16 ORIGINALID;
public UInt16 ERROR;
public UInt16 OTHERLEN;
public byte[] OTHERDATA;
public RecordTSIG(RecordReader rr)
{
ALGORITHMNAME = rr.ReadDomainName();
TIMESIGNED = rr.ReadUInt32() << 32 | rr.ReadUInt32();
FUDGE = rr.ReadUInt16();
MACSIZE = rr.ReadUInt16();
MAC = rr.ReadBytes(MACSIZE);
ORIGINALID = rr.ReadUInt16();
ERROR = rr.ReadUInt16();
OTHERLEN = rr.ReadUInt16();
OTHERDATA = rr.ReadBytes(OTHERLEN);
}
public override string ToString()
{
DateTime dateTime = new DateTime(1970, 1, 1, 0, 0, 0, 0);
dateTime = dateTime.AddSeconds(TIMESIGNED);
string printDate = dateTime.ToShortDateString() + " " + dateTime.ToShortTimeString();
return string.Format("{0} {1} {2} {3} {4}",
ALGORITHMNAME,
printDate,
FUDGE,
ORIGINALID,
ERROR);
}
}
}

38
MinecraftClient/Protocol/Dns/Records/RecordTXT.cs
View file

@ -1,38 +0,0 @@
using System;
#region Rfc info
/*
3.3.14. TXT RDATA format
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
/ TXT-DATA /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
where:
TXT-DATA One or more <character-string>s.
TXT RRs are used to hold descriptive text. The semantics of the text
depends on the domain where it is found.
*
*/
#endregion
namespace Heijden.DNS
{
public class RecordTXT : Record
{
public string TXT;
public RecordTXT(RecordReader rr)
{
TXT = rr.ReadString();
}
public override string ToString()
{
return string.Format("\"{0}\"",TXT);
}
}
}

75
MinecraftClient/Protocol/Dns/Records/RecordWKS.cs
View file

@ -1,75 +0,0 @@
using System;
/*
* 3.4.2. WKS RDATA format
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| ADDRESS |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| PROTOCOL | |
+--+--+--+--+--+--+--+--+ |
| |
/ <BIT MAP> /
/ /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
where:
ADDRESS An 32 bit Internet address
PROTOCOL An 8 bit IP protocol number
<BIT MAP> A variable length bit map. The bit map must be a
multiple of 8 bits long.
The WKS record is used to describe the well known services supported by
a particular protocol on a particular internet address. The PROTOCOL
field specifies an IP protocol number, and the bit map has one bit per
port of the specified protocol. The first bit corresponds to port 0,
the second to port 1, etc. If the bit map does not include a bit for a
protocol of interest, that bit is assumed zero. The appropriate values
and mnemonics for ports and protocols are specified in [RFC-1010].
For example, if PROTOCOL=TCP (6), the 26th bit corresponds to TCP port
25 (SMTP). If this bit is set, a SMTP server should be listening on TCP
port 25; if zero, SMTP service is not supported on the specified
address.
The purpose of WKS RRs is to provide availability information for
servers for TCP and UDP. If a server supports both TCP and UDP, or has
multiple Internet addresses, then multiple WKS RRs are used.
WKS RRs cause no additional section processing.
In master files, both ports and protocols are expressed using mnemonics
or decimal numbers.
*/
namespace Heijden.DNS
{
public class RecordWKS : Record
{
public string ADDRESS;
public int PROTOCOL;
public byte[] BITMAP;
public RecordWKS(RecordReader rr)
{
ushort length = rr.ReadUInt16(-2);
ADDRESS = string.Format("{0}.{1}.{2}.{3}",
rr.ReadByte(),
rr.ReadByte(),
rr.ReadByte(),
rr.ReadByte());
PROTOCOL = (int)rr.ReadByte();
length -= 5;
BITMAP = new byte[length];
BITMAP = rr.ReadBytes(length);
}
public override string ToString()
{
return string.Format("{0} {1}",ADDRESS,PROTOCOL);
}
}
}

51
MinecraftClient/Protocol/Dns/Records/RecordX25.cs
View file

@ -1,51 +0,0 @@
using System;
/* http://tools.ietf.org/rfc/rfc1183.txt
3.1. The X25 RR
The X25 RR is defined with mnemonic X25 and type code 19 (decimal).
X25 has the following format:
<owner> <ttl> <class> X25 <PSDN-address>
<PSDN-address> is required in all X25 RRs.
<PSDN-address> identifies the PSDN (Public Switched Data Network)
address in the X.121 [10] numbering plan associated with <owner>.
Its format in master files is a <character-string> syntactically
identical to that used in TXT and HINFO.
The format of X25 is class insensitive. X25 RRs cause no additional
section processing.
The <PSDN-address> is a string of decimal digits, beginning with the
4 digit DNIC (Data Network Identification Code), as specified in
X.121. National prefixes (such as a 0) MUST NOT be used.
For example:
Relay.Prime.COM. X25 311061700956
*/
namespace Heijden.DNS
{
public class RecordX25 : Record
{
public string PSDNADDRESS;
public RecordX25(RecordReader rr)
{
PSDNADDRESS = rr.ReadString();
}
public override string ToString()
{
return string.Format("{0}",
PSDNADDRESS);
}
}
}

21
MinecraftClient/Protocol/Dns/Records/totla.txt
View file

@ -1,21 +0,0 @@
Record.cs
RecordA.cs
RecordAAAA.cs
RecordCNAME.cs
RecordHINFO.cs
RecordMB.cs
RecordMD.cs
RecordMF.cs
RecordMG.cs
RecordMINFO.cs
RecordMR.cs
RecordMX.cs
RecordNS.cs
RecordNULL.cs
RecordPTR.cs
RecordReader.cs
RecordSOA.cs
RecordTXT.cs
RecordUnknown.cs
RecordWKS.cs
totla.txt

40
MinecraftClient/Protocol/Dns/Request.cs
View file

@ -1,40 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace Heijden.DNS
{
public class Request
{
public Header header;
private List<Question> questions;
public Request()
{
header = new Header();
header.OPCODE = OPCode.Query;
header.QDCOUNT = 0;
questions = new List<Question>();
}
public void AddQuestion(Question question)
{
questions.Add(question);
}
public byte[] Data
{
get
{
List<byte> data = new List<byte>();
header.QDCOUNT = (ushort)questions.Count;
data.AddRange(header.Data);
foreach (Question q in questions)
data.AddRange(q.Data);
return data.ToArray();
}
}
}
}

987
MinecraftClient/Protocol/Dns/Resolver.cs
View file

@ -1,987 +0,0 @@
using System;
using System.IO;
using System.Collections.Generic;
using System.Net;
using System.Text;
using System.Net.Sockets;
using System.Net.NetworkInformation;
using System.Diagnostics;
using System.Runtime.Remoting.Messaging;
/*
* Network Working Group P. Mockapetris
* Request for Comments: 1035 ISI
* November 1987
*
* DOMAIN NAMES - IMPLEMENTATION AND SPECIFICATION
*
*/
namespace Heijden.DNS
{
/// <summary>
/// Resolver is the main class to do DNS query lookups
/// </summary>
public class Resolver
{
/// <summary>
/// Version of this set of routines, when not in a library
/// </summary>
public string Version
{
get
{
return System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString();
}
}
/// <summary>
/// Default DNS port
/// </summary>
public const int DefaultPort = 53;
/// <summary>
/// Gets list of OPENDNS servers
/// </summary>
public static readonly IPEndPoint[] DefaultDnsServers =
{
new IPEndPoint(IPAddress.Parse("208.67.222.222"), DefaultPort),
new IPEndPoint(IPAddress.Parse("208.67.220.220"), DefaultPort)
};
private ushort m_Unique;
private bool m_UseCache;
private bool m_Recursion;
private int m_Retries;
private int m_Timeout;
private TransportType m_TransportType;
private List<IPEndPoint> m_DnsServers;
private Dictionary<string,Response> m_ResponseCache;
/// <summary>
/// Constructor of Resolver using DNS servers specified.
/// </summary>
/// <param name="DnsServers">Set of DNS servers</param>
public Resolver(IPEndPoint[] DnsServers)
{
m_ResponseCache = new Dictionary<string, Response>();
m_DnsServers = new List<IPEndPoint>();
m_DnsServers.AddRange(DnsServers);
m_Unique = (ushort)(new Random()).Next();
m_Retries = 3;
m_Timeout = 1;
m_Recursion = true;
m_UseCache = true;
m_TransportType = TransportType.Udp;
}
/// <summary>
/// Constructor of Resolver using DNS server specified.
/// </summary>
/// <param name="DnsServer">DNS server to use</param>
public Resolver(IPEndPoint DnsServer)
: this(new IPEndPoint[] { DnsServer })
{
}
/// <summary>
/// Constructor of Resolver using DNS server and port specified.
/// </summary>
/// <param name="ServerIpAddress">DNS server to use</param>
/// <param name="ServerPortNumber">DNS port to use</param>
public Resolver(IPAddress ServerIpAddress, int ServerPortNumber)
: this(new IPEndPoint(ServerIpAddress,ServerPortNumber))
{
}
/// <summary>
/// Constructor of Resolver using DNS address and port specified.
/// </summary>
/// <param name="ServerIpAddress">DNS server address to use</param>
/// <param name="ServerPortNumber">DNS port to use</param>
public Resolver(string ServerIpAddress, int ServerPortNumber)
: this(IPAddress.Parse(ServerIpAddress), ServerPortNumber)
{
}
/// <summary>
/// Constructor of Resolver using DNS address.
/// </summary>
/// <param name="ServerIpAddress">DNS server address to use</param>
public Resolver(string ServerIpAddress)
: this(IPAddress.Parse(ServerIpAddress), DefaultPort)
{
}
/// <summary>
/// Resolver constructor, using DNS servers specified by Windows
/// </summary>
public Resolver()
: this(GetDnsServers())
{
}
public class VerboseOutputEventArgs : EventArgs
{
public string Message;
public VerboseOutputEventArgs(string Message)
{
this.Message = Message;
}
}
private void Verbose(string format, params object[] args)
{
if (OnVerbose != null)
OnVerbose(this, new VerboseEventArgs(string.Format(format, args)));
}
/// <summary>
/// Verbose messages from internal operations
/// </summary>
public event VerboseEventHandler OnVerbose;
public delegate void VerboseEventHandler(object sender, VerboseEventArgs e);
public class VerboseEventArgs : EventArgs
{
public string Message;
public VerboseEventArgs(string Message)
{
this.Message = Message;
}
}
/// <summary>
/// Gets or sets timeout in milliseconds
/// </summary>
public int TimeOut
{
get
{
return m_Timeout;
}
set
{
m_Timeout = value;
}
}
/// <summary>
/// Gets or sets number of retries before giving up
/// </summary>
public int Retries
{
get
{
return m_Retries;
}
set
{
if(value>=1)
m_Retries = value;
}
}
/// <summary>
/// Gets or set recursion for doing queries
/// </summary>
public bool Recursion
{
get
{
return m_Recursion;
}
set
{
m_Recursion = value;
}
}
/// <summary>
/// Gets or sets protocol to use
/// </summary>
public TransportType TransportType
{
get
{
return m_TransportType;
}
set
{
m_TransportType = value;
}
}
/// <summary>
/// Gets or sets list of DNS servers to use
/// </summary>
public IPEndPoint[] DnsServers
{
get
{
return m_DnsServers.ToArray();
}
set
{
m_DnsServers.Clear();
m_DnsServers.AddRange(value);
}
}
/// <summary>
/// Gets first DNS server address or sets single DNS server to use
/// </summary>
public string DnsServer
{
get
{
return m_DnsServers[0].Address.ToString();
}
set
{
IPAddress ip;
if (IPAddress.TryParse(value, out ip))
{
m_DnsServers.Clear();
m_DnsServers.Add(new IPEndPoint(ip, DefaultPort));
return;
}
Response response = Query(value, QType.A);
if (response.RecordsA.Length > 0)
{
m_DnsServers.Clear();
m_DnsServers.Add(new IPEndPoint(response.RecordsA[0].Address, DefaultPort));
}
}
}
public bool UseCache
{
get
{
return m_UseCache;
}
set
{
m_UseCache = value;
if (!m_UseCache)
m_ResponseCache.Clear();
}
}
/// <summary>
/// Clear the resolver cache
/// </summary>
public void ClearCache()
{
m_ResponseCache.Clear();
}
private Response SearchInCache(Question question)
{
if (!m_UseCache)
return null;
string strKey = question.QClass + "-" + question.QType + "-" + question.QName;
Response response = null;
lock (m_ResponseCache)
{
if (!m_ResponseCache.ContainsKey(strKey))
return null;
response = m_ResponseCache[strKey];
}
int TimeLived = (int)((DateTime.Now.Ticks - response.TimeStamp.Ticks) / TimeSpan.TicksPerSecond);
foreach (RR rr in response.RecordsRR)
{
rr.TimeLived = TimeLived;
// The TTL property calculates its actual time to live
if (rr.TTL == 0)
return null; // out of date
}
return response;
}
private void AddToCache(Response response)
{
if (!m_UseCache)
return;
// No question, no caching
if (response.Questions.Count == 0)
return;
// Only cached non-error responses
if (response.header.RCODE != RCode.NoError)
return;
Question question = response.Questions[0];
string strKey = question.QClass + "-" + question.QType + "-" + question.QName;
lock (m_ResponseCache)
{
if (m_ResponseCache.ContainsKey(strKey))
m_ResponseCache.Remove(strKey);
m_ResponseCache.Add(strKey, response);
}
}
private Response UdpRequest(Request request)
{
// RFC1035 max. size of a UDP datagram is 512 bytes
byte[] responseMessage = new byte[512];
for (int intAttempts = 0; intAttempts < m_Retries; intAttempts++)
{
for (int intDnsServer = 0; intDnsServer < m_DnsServers.Count; intDnsServer++)
{
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, m_Timeout * 1000);
try
{
socket.SendTo(request.Data, m_DnsServers[intDnsServer]);
int intReceived = socket.Receive(responseMessage);
byte[] data = new byte[intReceived];
Array.Copy(responseMessage, data, intReceived);
Response response = new Response(m_DnsServers[intDnsServer], data);
AddToCache(response);
return response;
}
catch (SocketException)
{
Verbose(string.Format(";; Connection to nameserver {0} failed", (intDnsServer + 1)));
continue; // next try
}
finally
{
m_Unique++;
// close the socket
socket.Close();
}
}
}
Response responseTimeout = new Response();
responseTimeout.Error = "Timeout Error";
return responseTimeout;
}
private Response TcpRequest(Request request)
{
//System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
//sw.Start();
byte[] responseMessage = new byte[512];
for (int intAttempts = 0; intAttempts < m_Retries; intAttempts++)
{
for (int intDnsServer = 0; intDnsServer < m_DnsServers.Count; intDnsServer++)
{
TcpClient tcpClient = new TcpClient();
tcpClient.ReceiveTimeout = m_Timeout * 1000;
try
{
IAsyncResult result = tcpClient.BeginConnect(m_DnsServers[intDnsServer].Address, m_DnsServers[intDnsServer].Port, null, null);
bool success = result.AsyncWaitHandle.WaitOne(m_Timeout*1000, true);
if (!success || !tcpClient.Connected)
{
tcpClient.Close();
Verbose(string.Format(";; Connection to nameserver {0} failed", (intDnsServer + 1)));
continue;
}
BufferedStream bs = new BufferedStream(tcpClient.GetStream());
byte[] data = request.Data;
bs.WriteByte((byte)((data.Length >> 8) & 0xff));
bs.WriteByte((byte)(data.Length & 0xff));
bs.Write(data, 0, data.Length);
bs.Flush();
Response TransferResponse = new Response();
int intSoa = 0;
int intMessageSize = 0;
//Debug.WriteLine("Sending "+ (request.Length+2) + " bytes in "+ sw.ElapsedMilliseconds+" mS");
while (true)
{
int intLength = bs.ReadByte() << 8 | bs.ReadByte();
if (intLength <= 0)
{
tcpClient.Close();
Verbose(string.Format(";; Connection to nameserver {0} failed", (intDnsServer + 1)));
throw new SocketException(); // next try
}
intMessageSize += intLength;
data = new byte[intLength];
bs.Read(data, 0, intLength);
Response response = new Response(m_DnsServers[intDnsServer], data);
//Debug.WriteLine("Received "+ (intLength+2)+" bytes in "+sw.ElapsedMilliseconds +" mS");
if (response.header.RCODE != RCode.NoError)
return response;
if (response.Questions[0].QType != QType.AXFR)
{
AddToCache(response);
return response;
}
// Zone transfer!!
if(TransferResponse.Questions.Count==0)
TransferResponse.Questions.AddRange(response.Questions);
TransferResponse.Answers.AddRange(response.Answers);
TransferResponse.Authorities.AddRange(response.Authorities);
TransferResponse.Additionals.AddRange(response.Additionals);
if (response.Answers[0].Type == Type.SOA)
intSoa++;
if (intSoa == 2)
{
TransferResponse.header.QDCOUNT = (ushort)TransferResponse.Questions.Count;
TransferResponse.header.ANCOUNT = (ushort)TransferResponse.Answers.Count;
TransferResponse.header.NSCOUNT = (ushort)TransferResponse.Authorities.Count;
TransferResponse.header.ARCOUNT = (ushort)TransferResponse.Additionals.Count;
TransferResponse.MessageSize = intMessageSize;
return TransferResponse;
}
}
} // try
catch (SocketException)
{
continue; // next try
}
finally
{
m_Unique++;
// close the socket
tcpClient.Close();
}
}
}
Response responseTimeout = new Response();
responseTimeout.Error = "Timeout Error";
return responseTimeout;
}
/// <summary>
/// Do Query on specified DNS servers
/// </summary>
/// <param name="name">Name to query</param>
/// <param name="qtype">Question type</param>
/// <param name="qclass">Class type</param>
/// <returns>Response of the query</returns>
public Response Query(string name, QType qtype, QClass qclass)
{
Question question = new Question(name, qtype, qclass);
Response response = SearchInCache(question);
if (response != null)
return response;
Request request = new Request();
request.AddQuestion(question);
return GetResponse(request);
}
/// <summary>
/// Do an QClass=IN Query on specified DNS servers
/// </summary>
/// <param name="name">Name to query</param>
/// <param name="qtype">Question type</param>
/// <returns>Response of the query</returns>
public Response Query(string name, QType qtype)
{
Question question = new Question(name, qtype, QClass.IN);
Response response = SearchInCache(question);
if (response != null)
return response;
Request request = new Request();
request.AddQuestion(question);
return GetResponse(request);
}
private Response GetResponse(Request request)
{
request.header.ID = m_Unique;
request.header.RD = m_Recursion;
if (m_TransportType == TransportType.Udp)
return UdpRequest(request);
if (m_TransportType == TransportType.Tcp)
return TcpRequest(request);
Response response = new Response();
response.Error = "Unknown TransportType";
return response;
}
/// <summary>
/// Gets a list of default DNS servers used on the Windows machine.
/// </summary>
/// <returns></returns>
public static IPEndPoint[] GetDnsServers()
{
List<IPEndPoint> list = new List<IPEndPoint>();
NetworkInterface[] adapters = NetworkInterface.GetAllNetworkInterfaces();
foreach (NetworkInterface n in adapters)
{
if (n.OperationalStatus == OperationalStatus.Up)
{
IPInterfaceProperties ipProps = n.GetIPProperties();
// thanks to Jon Webster on May 20, 2008
foreach (IPAddress ipAddr in ipProps.DnsAddresses)
{
IPEndPoint entry = new IPEndPoint(ipAddr, DefaultPort);
if (!list.Contains(entry))
list.Add(entry);
}
}
}
return list.ToArray();
}
//
private IPHostEntry MakeEntry(string HostName)
{
IPHostEntry entry = new IPHostEntry();
entry.HostName = HostName;
Response response = Query(HostName, QType.A, QClass.IN);
// fill AddressList and aliases
List<IPAddress> AddressList = new List<IPAddress>();
List<string> Aliases = new List<string>();
foreach (AnswerRR answerRR in response.Answers)
{
if (answerRR.Type == Type.A)
{
// answerRR.RECORD.ToString() == (answerRR.RECORD as RecordA).Address
AddressList.Add(IPAddress.Parse((answerRR.RECORD.ToString())));
entry.HostName = answerRR.NAME;
}
else
{
if (answerRR.Type == Type.CNAME)
Aliases.Add(answerRR.NAME);
}
}
entry.AddressList = AddressList.ToArray();
entry.Aliases = Aliases.ToArray();
return entry;
}
/// <summary>
/// Translates the IPV4 or IPV6 address into an arpa address
/// </summary>
/// <param name="ip">IP address to get the arpa address form</param>
/// <returns>The 'mirrored' IPV4 or IPV6 arpa address</returns>
public static string GetArpaFromIp(IPAddress ip)
{
if (ip.AddressFamily == AddressFamily.InterNetwork)
{
StringBuilder sb = new StringBuilder();
sb.Append("in-addr.arpa.");
foreach (byte b in ip.GetAddressBytes())
{
sb.Insert(0, string.Format("{0}.", b));
}
return sb.ToString();
}
if (ip.AddressFamily == AddressFamily.InterNetworkV6)
{
StringBuilder sb = new StringBuilder();
sb.Append("ip6.arpa.");
foreach (byte b in ip.GetAddressBytes())
{
sb.Insert(0, string.Format("{0:x}.", (b >> 4) & 0xf));
sb.Insert(0, string.Format("{0:x}.", (b >> 0) & 0xf));
}
return sb.ToString();
}
return "?";
}
public static string GetArpaFromEnum(string strEnum)
{
StringBuilder sb = new StringBuilder();
string Number = System.Text.RegularExpressions.Regex.Replace(strEnum, "[^0-9]", "");
sb.Append("e164.arpa.");
foreach (char c in Number)
{
sb.Insert(0, string.Format("{0}.", c));
}
return sb.ToString();
}
#region Deprecated methods in the original System.Net.DNS class
/// <summary>
/// Returns the Internet Protocol (IP) addresses for the specified host.
/// </summary>
/// <param name="hostNameOrAddress">The host name or IP address to resolve.</param>
/// <returns>
/// An array of type System.Net.IPAddress that holds the IP addresses for the
/// host that is specified by the hostNameOrAddress parameter.
///</returns>
public IPAddress[] GetHostAddresses(string hostNameOrAddress)
{
IPHostEntry entry = GetHostEntry(hostNameOrAddress);
return entry.AddressList;
}
private delegate IPAddress[] GetHostAddressesDelegate(string hostNameOrAddress);
/// <summary>
/// Asynchronously returns the Internet Protocol (IP) addresses for the specified
/// host.
/// </summary>
/// <param name="hostNameOrAddress">The host name or IP address to resolve.</param>
/// <param name="requestCallback">
/// An System.AsyncCallback delegate that references the method to invoke when
/// the operation is complete.
/// </param>
/// <param name="stateObject">
/// A user-defined object that contains information about the operation. This
/// object is passed to the requestCallback delegate when the operation is complete.
///</param>
/// <returns>An System.IAsyncResult instance that references the asynchronous request.</returns>
public IAsyncResult BeginGetHostAddresses(string hostNameOrAddress, AsyncCallback requestCallback, object stateObject)
{
GetHostAddressesDelegate g = new GetHostAddressesDelegate(GetHostAddresses);
return g.BeginInvoke(hostNameOrAddress, requestCallback, stateObject);
}
/// <summary>
/// Ends an asynchronous request for DNS information.
/// </summary>
/// <param name="AsyncResult">
/// An System.IAsyncResult instance returned by a call to the Heijden.Dns.Resolver.BeginGetHostAddresses(System.String,System.AsyncCallback,System.Object)
/// method.
/// </param>
/// <returns></returns>
public IPAddress[] EndGetHostAddresses(IAsyncResult AsyncResult)
{
AsyncResult aResult = (AsyncResult)AsyncResult;
GetHostAddressesDelegate g = (GetHostAddressesDelegate)aResult.AsyncDelegate;
return g.EndInvoke(AsyncResult);
}
/// <summary>
/// Creates an System.Net.IPHostEntry instance from the specified System.Net.IPAddress.
/// </summary>
/// <param name="ip">An System.Net.IPAddress.</param>
/// <returns>An System.Net.IPHostEntry.</returns>
public IPHostEntry GetHostByAddress(IPAddress ip)
{
return GetHostEntry(ip);
}
/// <summary>
/// Creates an System.Net.IPHostEntry instance from an IP address.
/// </summary>
/// <param name="address">An IP address.</param>
/// <returns>An System.Net.IPHostEntry instance.</returns>
public IPHostEntry GetHostByAddress(string address)
{
return GetHostEntry(address);
}
/// <summary>
/// Gets the DNS information for the specified DNS host name.
/// </summary>
/// <param name="hostName">The DNS name of the host</param>
/// <returns>An System.Net.IPHostEntry object that contains host information for the address specified in hostName.</returns>
public IPHostEntry GetHostByName(string hostName)
{
return MakeEntry(hostName);
}
private delegate IPHostEntry GetHostByNameDelegate(string hostName);
/// <summary>
/// Asynchronously resolves an IP address to an System.Net.IPHostEntry instance.
/// </summary>
/// <param name="hostName">The DNS name of the host</param>
/// <param name="requestCallback">An System.AsyncCallback delegate that references the method to invoke when the operation is complete.</param>
/// <param name="stateObject">
/// A user-defined object that contains information about the operation. This
/// object is passed to the requestCallback delegate when the operation is complete.
/// </param>
/// <returns>An System.IAsyncResult instance that references the asynchronous request.</returns>
public IAsyncResult BeginGetHostByName(string hostName, AsyncCallback requestCallback, object stateObject)
{
GetHostByNameDelegate g = new GetHostByNameDelegate(GetHostByName);
return g.BeginInvoke(hostName, requestCallback, stateObject);
}
/// <summary>
/// Ends an asynchronous request for DNS information.
/// </summary>
/// <param name="AsyncResult">
/// An System.IAsyncResult instance returned by a call to an
/// Heijden.Dns.Resolver.BeginGetHostByName method.
/// </param>
/// <returns></returns>
public IPHostEntry EndGetHostByName(IAsyncResult AsyncResult)
{
AsyncResult aResult = (AsyncResult)AsyncResult;
GetHostByNameDelegate g = (GetHostByNameDelegate)aResult.AsyncDelegate;
return g.EndInvoke(AsyncResult);
}
/// <summary>
/// Resolves a host name or IP address to an System.Net.IPHostEntry instance.
/// </summary>
/// <param name="hostName">A DNS-style host name or IP address.</param>
/// <returns></returns>
//[Obsolete("no problem",false)]
public IPHostEntry Resolve(string hostName)
{
return MakeEntry(hostName);
}
private delegate IPHostEntry ResolveDelegate(string hostName);
/// <summary>
/// Begins an asynchronous request to resolve a DNS host name or IP address to
/// an System.Net.IPAddress instance.
/// </summary>
/// <param name="hostName">The DNS name of the host.</param>
/// <param name="requestCallback">
/// An System.AsyncCallback delegate that references the method to invoke when
/// the operation is complete.
/// </param>
/// <param name="stateObject">
/// A user-defined object that contains information about the operation. This
/// object is passed to the requestCallback delegate when the operation is complete.
/// </param>
/// <returns>An System.IAsyncResult instance that references the asynchronous request.</returns>
public IAsyncResult BeginResolve(string hostName, AsyncCallback requestCallback, object stateObject)
{
ResolveDelegate g = new ResolveDelegate(Resolve);
return g.BeginInvoke(hostName, requestCallback, stateObject);
}
/// <summary>
/// Ends an asynchronous request for DNS information.
/// </summary>
/// <param name="AsyncResult">
/// An System.IAsyncResult instance that is returned by a call to the System.Net.Dns.BeginResolve(System.String,System.AsyncCallback,System.Object)
/// method.
/// </param>
/// <returns>An System.Net.IPHostEntry object that contains DNS information about a host.</returns>
public IPHostEntry EndResolve(IAsyncResult AsyncResult)
{
AsyncResult aResult = (AsyncResult)AsyncResult;
ResolveDelegate g = (ResolveDelegate)aResult.AsyncDelegate;
return g.EndInvoke(AsyncResult);
}
#endregion
/// <summary>
/// Resolves an IP address to an System.Net.IPHostEntry instance.
/// </summary>
/// <param name="ip">An IP address.</param>
/// <returns>
/// An System.Net.IPHostEntry instance that contains address information about
/// the host specified in address.
///</returns>
public IPHostEntry GetHostEntry(IPAddress ip)
{
Response response = Query(GetArpaFromIp(ip), QType.PTR, QClass.IN);
if (response.RecordsPTR.Length > 0)
return MakeEntry(response.RecordsPTR[0].PTRDNAME);
else
return new IPHostEntry();
}
/// <summary>
/// Resolves a host name or IP address to an System.Net.IPHostEntry instance.
/// </summary>
/// <param name="hostNameOrAddress">The host name or IP address to resolve.</param>
/// <returns>
/// An System.Net.IPHostEntry instance that contains address information about
/// the host specified in hostNameOrAddress.
///</returns>
public IPHostEntry GetHostEntry(string hostNameOrAddress)
{
IPAddress iPAddress;
if (IPAddress.TryParse(hostNameOrAddress, out iPAddress))
return GetHostEntry(iPAddress);
else
return MakeEntry(hostNameOrAddress);
}
private delegate IPHostEntry GetHostEntryViaIPDelegate(IPAddress ip);
private delegate IPHostEntry GetHostEntryDelegate(string hostNameOrAddress);
/// <summary>
/// Asynchronously resolves a host name or IP address to an System.Net.IPHostEntry instance.
/// </summary>
/// <param name="hostNameOrAddress">The host name or IP address to resolve.</param>
/// <param name="requestCallback">
/// An System.AsyncCallback delegate that references the method to invoke when
/// the operation is complete.
///</param>
/// <param name="stateObject">
/// A user-defined object that contains information about the operation. This
/// object is passed to the requestCallback delegate when the operation is complete.
/// </param>
/// <returns>An System.IAsyncResult instance that references the asynchronous request.</returns>
public IAsyncResult BeginGetHostEntry(string hostNameOrAddress, AsyncCallback requestCallback, object stateObject)
{
GetHostEntryDelegate g = new GetHostEntryDelegate(GetHostEntry);
return g.BeginInvoke(hostNameOrAddress, requestCallback, stateObject);
}
/// <summary>
/// Asynchronously resolves an IP address to an System.Net.IPHostEntry instance.
/// </summary>
/// <param name="ip">The IP address to resolve.</param>
/// <param name="requestCallback">
/// An System.AsyncCallback delegate that references the method to invoke when
/// the operation is complete.
/// </param>
/// <param name="stateObject">
/// A user-defined object that contains information about the operation. This
/// object is passed to the requestCallback delegate when the operation is complete.
/// </param>
/// <returns>An System.IAsyncResult instance that references the asynchronous request.</returns>
public IAsyncResult BeginGetHostEntry(IPAddress ip, AsyncCallback requestCallback, object stateObject)
{
GetHostEntryViaIPDelegate g = new GetHostEntryViaIPDelegate(GetHostEntry);
return g.BeginInvoke(ip, requestCallback, stateObject);
}
/// <summary>
/// Ends an asynchronous request for DNS information.
/// </summary>
/// <param name="AsyncResult">
/// An System.IAsyncResult instance returned by a call to an
/// Overload:Heijden.Dns.Resolver.BeginGetHostEntry method.
/// </param>
/// <returns>
/// An System.Net.IPHostEntry instance that contains address information about
/// the host.
///</returns>
public IPHostEntry EndGetHostEntry(IAsyncResult AsyncResult)
{
AsyncResult aResult = (AsyncResult)AsyncResult;
if (aResult.AsyncDelegate is GetHostEntryDelegate)
{
GetHostEntryDelegate g = (GetHostEntryDelegate)aResult.AsyncDelegate;
return g.EndInvoke(AsyncResult);
}
if (aResult.AsyncDelegate is GetHostEntryViaIPDelegate)
{
GetHostEntryViaIPDelegate g = (GetHostEntryViaIPDelegate)aResult.AsyncDelegate;
return g.EndInvoke(AsyncResult);
}
return null;
}
private enum RRRecordStatus
{
UNKNOWN,
NAME,
TTL,
CLASS,
TYPE,
VALUE
}
public void LoadRootFile(string strPath)
{
StreamReader sr = new StreamReader(strPath);
while (!sr.EndOfStream)
{
string strLine = sr.ReadLine();
if (strLine == null)
break;
int intI = strLine.IndexOf(';');
if (intI >= 0)
strLine = strLine.Substring(0, intI);
strLine = strLine.Trim();
if (strLine.Length == 0)
continue;
RRRecordStatus status = RRRecordStatus.NAME;
string Name="";
string Ttl="";
string Class="";
string Type="";
string Value="";
string strW = "";
for (intI = 0; intI < strLine.Length; intI++)
{
char C = strLine[intI];
if (C <= ' ' && strW!="")
{
switch (status)
{
case RRRecordStatus.NAME:
Name = strW;
status = RRRecordStatus.TTL;
break;
case RRRecordStatus.TTL:
Ttl = strW;
status = RRRecordStatus.CLASS;
break;
case RRRecordStatus.CLASS:
Class = strW;
status = RRRecordStatus.TYPE;
break;
case RRRecordStatus.TYPE:
Type = strW;
status = RRRecordStatus.VALUE;
break;
case RRRecordStatus.VALUE:
Value = strW;
status = RRRecordStatus.UNKNOWN;
break;
default:
break;
}
strW = "";
}
if (C > ' ')
strW += C;
}
}
sr.Close();
}
} // class
}

288
MinecraftClient/Protocol/Dns/Response.cs
View file

@ -1,288 +0,0 @@
using System;
using System.IO;
using System.Net;
using System.Collections;
using System.Collections.Generic;
using System.Text;
namespace Heijden.DNS
{
public class Response
{
/// <summary>
/// List of Question records
/// </summary>
public List<Question> Questions;
/// <summary>
/// List of AnswerRR records
/// </summary>
public List<AnswerRR> Answers;
/// <summary>
/// List of AuthorityRR records
/// </summary>
public List<AuthorityRR> Authorities;
/// <summary>
/// List of AdditionalRR records
/// </summary>
public List<AdditionalRR> Additionals;
public Header header;
/// <summary>
/// Error message, empty when no error
/// </summary>
public string Error;
/// <summary>
/// The Size of the message
/// </summary>
public int MessageSize;
/// <summary>
/// TimeStamp when cached
/// </summary>
public DateTime TimeStamp;
/// <summary>
/// Server which delivered this response
/// </summary>
public IPEndPoint Server;
public Response()
{
Questions = new List<Question>();
Answers = new List<AnswerRR>();
Authorities = new List<AuthorityRR>();
Additionals = new List<AdditionalRR>();
Server = new IPEndPoint(0,0);
Error = "";
MessageSize = 0;
TimeStamp = DateTime.Now;
header = new Header();
}
public Response(IPEndPoint iPEndPoint, byte[] data)
{
Error = "";
Server = iPEndPoint;
TimeStamp = DateTime.Now;
MessageSize = data.Length;
RecordReader rr = new RecordReader(data);
Questions = new List<Question>();
Answers = new List<AnswerRR>();
Authorities = new List<AuthorityRR>();
Additionals = new List<AdditionalRR>();
header = new Header(rr);
for (int intI = 0; intI < header.QDCOUNT; intI++)
{
Questions.Add(new Question(rr));
}
for (int intI = 0; intI < header.ANCOUNT; intI++)
{
Answers.Add(new AnswerRR(rr));
}
for (int intI = 0; intI < header.NSCOUNT; intI++)
{
Authorities.Add(new AuthorityRR(rr));
}
for (int intI = 0; intI < header.ARCOUNT; intI++)
{
Additionals.Add(new AdditionalRR(rr));
}
}
/// <summary>
/// List of RecordMX in Response.Answers
/// </summary>
public RecordMX[] RecordsMX
{
get
{
List<RecordMX> list = new List<RecordMX>();
foreach (AnswerRR answerRR in this.Answers)
{
RecordMX record = answerRR.RECORD as RecordMX;
if(record!=null)
list.Add(record);
}
list.Sort();
return list.ToArray();
}
}
/// <summary>
/// List of RecordTXT in Response.Answers
/// </summary>
public RecordTXT[] RecordsTXT
{
get
{
List<RecordTXT> list = new List<RecordTXT>();
foreach (AnswerRR answerRR in this.Answers)
{
RecordTXT record = answerRR.RECORD as RecordTXT;
if (record != null)
list.Add(record);
}
return list.ToArray();
}
}
/// <summary>
/// List of RecordA in Response.Answers
/// </summary>
public RecordA[] RecordsA
{
get
{
List<RecordA> list = new List<RecordA>();
foreach (AnswerRR answerRR in this.Answers)
{
RecordA record = answerRR.RECORD as RecordA;
if (record != null)
list.Add(record);
}
return list.ToArray();
}
}
/// <summary>
/// List of RecordPTR in Response.Answers
/// </summary>
public RecordPTR[] RecordsPTR
{
get
{
List<RecordPTR> list = new List<RecordPTR>();
foreach (AnswerRR answerRR in this.Answers)
{
RecordPTR record = answerRR.RECORD as RecordPTR;
if (record != null)
list.Add(record);
}
return list.ToArray();
}
}
/// <summary>
/// List of RecordCNAME in Response.Answers
/// </summary>
public RecordCNAME[] RecordsCNAME
{
get
{
List<RecordCNAME> list = new List<RecordCNAME>();
foreach (AnswerRR answerRR in this.Answers)
{
RecordCNAME record = answerRR.RECORD as RecordCNAME;
if (record != null)
list.Add(record);
}
return list.ToArray();
}
}
/// <summary>
/// List of RecordAAAA in Response.Answers
/// </summary>
public RecordAAAA[] RecordsAAAA
{
get
{
List<RecordAAAA> list = new List<RecordAAAA>();
foreach (AnswerRR answerRR in this.Answers)
{
RecordAAAA record = answerRR.RECORD as RecordAAAA;
if (record != null)
list.Add(record);
}
return list.ToArray();
}
}
/// <summary>
/// List of RecordNS in Response.Answers
/// </summary>
public RecordNS[] RecordsNS
{
get
{
List<RecordNS> list = new List<RecordNS>();
foreach (AnswerRR answerRR in this.Answers)
{
RecordNS record = answerRR.RECORD as RecordNS;
if (record != null)
list.Add(record);
}
return list.ToArray();
}
}
/// <summary>
/// List of RecordSOA in Response.Answers
/// </summary>
public RecordSOA[] RecordsSOA
{
get
{
List<RecordSOA> list = new List<RecordSOA>();
foreach (AnswerRR answerRR in this.Answers)
{
RecordSOA record = answerRR.RECORD as RecordSOA;
if (record != null)
list.Add(record);
}
return list.ToArray();
}
}
/// <summary>
/// List of RecordSRV in Response.Answers
/// </summary>
public RecordSRV[] RecordsSRV
{
get
{
List<RecordSRV> list = new List<RecordSRV>();
foreach (AnswerRR answerRR in this.Answers)
{
RecordSRV record = answerRR.RECORD as RecordSRV;
if (record != null)
list.Add(record);
}
return list.ToArray();
}
}
public RR[] RecordsRR
{
get
{
List<RR> list = new List<RR>();
foreach (RR rr in this.Answers)
{
list.Add(rr);
}
foreach (RR rr in this.Answers)
{
list.Add(rr);
}
foreach (RR rr in this.Authorities)
{
list.Add(rr);
}
foreach (RR rr in this.Additionals)
{
list.Add(rr);
}
return list.ToArray();
}
}
}
}

331
MinecraftClient/Protocol/Dns/Structs.cs
View file

@ -1,331 +0,0 @@
/*
* http://www.iana.org/assignments/dns-parameters
*
*
*
*/
namespace Heijden.DNS
{
/*
* 3.2.2. TYPE values
*
* TYPE fields are used in resource records.
* Note that these types are a subset of QTYPEs.
*
* TYPE value meaning
*/
public enum Type : ushort
{
A = 1, // a IPV4 host address
NS = 2, // an authoritative name server
MD = 3, // a mail destination (Obsolete - use MX)
MF = 4, // a mail forwarder (Obsolete - use MX)
CNAME = 5, // the canonical name for an alias
SOA = 6, // marks the start of a zone of authority
MB = 7, // a mailbox domain name (EXPERIMENTAL)
MG = 8, // a mail group member (EXPERIMENTAL)
MR = 9, // a mail rename domain name (EXPERIMENTAL)
NULL = 10, // a null RR (EXPERIMENTAL)
WKS = 11, // a well known service description
PTR = 12, // a domain name pointer
HINFO = 13, // host information
MINFO = 14, // mailbox or mail list information
MX = 15, // mail exchange
TXT = 16, // text strings
RP = 17, // The Responsible Person rfc1183
AFSDB = 18, // AFS Data Base location
X25 = 19, // X.25 address rfc1183
ISDN = 20, // ISDN address rfc1183
RT = 21, // The Route Through rfc1183
NSAP = 22, // Network service access point address rfc1706
NSAPPTR = 23, // Obsolete, rfc1348
SIG = 24, // Cryptographic public key signature rfc2931 / rfc2535
KEY = 25, // Public key as used in DNSSEC rfc2535
PX = 26, // Pointer to X.400/RFC822 mail mapping information rfc2163
GPOS = 27, // Geographical position rfc1712 (obsolete)
AAAA = 28, // a IPV6 host address, rfc3596
LOC = 29, // Location information rfc1876
NXT = 30, // Next Domain, Obsolete rfc2065 / rfc2535
EID = 31, // *** Endpoint Identifier (Patton)
NIMLOC = 32, // *** Nimrod Locator (Patton)
SRV = 33, // Location of services rfc2782
ATMA = 34, // *** ATM Address (Dobrowski)
NAPTR = 35, // The Naming Authority Pointer rfc3403
KX = 36, // Key Exchange Delegation Record rfc2230
CERT = 37, // *** CERT RFC2538
A6 = 38, // IPv6 address rfc3363 (rfc2874 rfc3226)
DNAME = 39, // A way to provide aliases for a whole domain, not just a single domain name as with CNAME. rfc2672
SINK = 40, // *** SINK Eastlake
OPT = 41, // *** OPT RFC2671
APL = 42, // *** APL [RFC3123]
DS = 43, // Delegation Signer rfc3658
SSHFP = 44, // SSH Key Fingerprint rfc4255
IPSECKEY = 45, // IPSECKEY rfc4025
RRSIG = 46, // RRSIG rfc3755
NSEC = 47, // NSEC rfc3755
DNSKEY = 48, // DNSKEY 3755
DHCID = 49, // DHCID rfc4701
NSEC3 = 50, // NSEC3 rfc5155
NSEC3PARAM = 51, // NSEC3PARAM rfc5155
HIP = 55, // Host Identity Protocol [RFC-ietf-hip-dns-09.txt]
SPF = 99, // SPF rfc4408
UINFO = 100, // *** IANA-Reserved
UID = 101, // *** IANA-Reserved
GID = 102, // *** IANA-Reserved
UNSPEC = 103, // *** IANA-Reserved
TKEY = 249, // Transaction key rfc2930
TSIG = 250, // Transaction signature rfc2845
TA=32768, // DNSSEC Trust Authorities [Weiler] 13 December 2005
DLV=32769 // DNSSEC Lookaside Validation [RFC4431]
}
/*
* 3.2.3. QTYPE values
*
* QTYPE fields appear in the question part of a query. QTYPES are a
* superset of TYPEs, hence all TYPEs are valid QTYPEs. In addition, the
* following QTYPEs are defined:
*
* QTYPE value meaning
*/
public enum QType : ushort
{
A = Type.A, // a IPV4 host address
NS = Type.NS, // an authoritative name server
MD = Type.MD, // a mail destination (Obsolete - use MX)
MF = Type.MF, // a mail forwarder (Obsolete - use MX)
CNAME = Type.CNAME, // the canonical name for an alias
SOA = Type.SOA, // marks the start of a zone of authority
MB = Type.MB, // a mailbox domain name (EXPERIMENTAL)
MG = Type.MG, // a mail group member (EXPERIMENTAL)
MR = Type.MR, // a mail rename domain name (EXPERIMENTAL)
NULL = Type.NULL, // a null RR (EXPERIMENTAL)
WKS = Type.WKS, // a well known service description
PTR = Type.PTR, // a domain name pointer
HINFO = Type.HINFO, // host information
MINFO = Type.MINFO, // mailbox or mail list information
MX = Type.MX, // mail exchange
TXT = Type.TXT, // text strings
RP = Type.RP, // The Responsible Person rfc1183
AFSDB = Type.AFSDB, // AFS Data Base location
X25 = Type.X25, // X.25 address rfc1183
ISDN = Type.ISDN, // ISDN address rfc1183
RT = Type.RT, // The Route Through rfc1183
NSAP = Type.NSAP, // Network service access point address rfc1706
NSAP_PTR = Type.NSAPPTR, // Obsolete, rfc1348
SIG = Type.SIG, // Cryptographic public key signature rfc2931 / rfc2535
KEY = Type.KEY, // Public key as used in DNSSEC rfc2535
PX = Type.PX, // Pointer to X.400/RFC822 mail mapping information rfc2163
GPOS = Type.GPOS, // Geographical position rfc1712 (obsolete)
AAAA = Type.AAAA, // a IPV6 host address
LOC = Type.LOC, // Location information rfc1876
NXT = Type.NXT, // Obsolete rfc2065 / rfc2535
EID = Type.EID, // *** Endpoint Identifier (Patton)
NIMLOC = Type.NIMLOC,// *** Nimrod Locator (Patton)
SRV = Type.SRV, // Location of services rfc2782
ATMA = Type.ATMA, // *** ATM Address (Dobrowski)
NAPTR = Type.NAPTR, // The Naming Authority Pointer rfc3403
KX = Type.KX, // Key Exchange Delegation Record rfc2230
CERT = Type.CERT, // *** CERT RFC2538
A6 = Type.A6, // IPv6 address rfc3363
DNAME = Type.DNAME, // A way to provide aliases for a whole domain, not just a single domain name as with CNAME. rfc2672
SINK = Type.SINK, // *** SINK Eastlake
OPT = Type.OPT, // *** OPT RFC2671
APL = Type.APL, // *** APL [RFC3123]
DS = Type.DS, // Delegation Signer rfc3658
SSHFP = Type.SSHFP, // *** SSH Key Fingerprint RFC-ietf-secsh-dns
IPSECKEY = Type.IPSECKEY, // rfc4025
RRSIG = Type.RRSIG, // *** RRSIG RFC-ietf-dnsext-dnssec-2535
NSEC = Type.NSEC, // *** NSEC RFC-ietf-dnsext-dnssec-2535
DNSKEY = Type.DNSKEY,// *** DNSKEY RFC-ietf-dnsext-dnssec-2535
DHCID = Type.DHCID, // rfc4701
NSEC3 = Type.NSEC3, // RFC5155
NSEC3PARAM = Type.NSEC3PARAM, // RFC5155
HIP = Type.HIP, // RFC-ietf-hip-dns-09.txt
SPF = Type.SPF, // RFC4408
UINFO = Type.UINFO, // *** IANA-Reserved
UID = Type.UID, // *** IANA-Reserved
GID = Type.GID, // *** IANA-Reserved
UNSPEC = Type.UNSPEC,// *** IANA-Reserved
TKEY = Type.TKEY, // Transaction key rfc2930
TSIG = Type.TSIG, // Transaction signature rfc2845
IXFR = 251, // incremental transfer [RFC1995]
AXFR = 252, // transfer of an entire zone [RFC1035]
MAILB = 253, // mailbox-related RRs (MB, MG or MR) [RFC1035]
MAILA = 254, // mail agent RRs (Obsolete - see MX) [RFC1035]
ANY = 255, // A request for all records [RFC1035]
TA = Type.TA, // DNSSEC Trust Authorities [Weiler] 13 December 2005
DLV = Type.DLV // DNSSEC Lookaside Validation [RFC4431]
}
/*
* 3.2.4. CLASS values
*
* CLASS fields appear in resource records. The following CLASS mnemonics
*and values are defined:
*
* CLASS value meaning
*/
public enum Class : ushort
{
IN = 1, // the Internet
CS = 2, // the CSNET class (Obsolete - used only for examples in some obsolete RFCs)
CH = 3, // the CHAOS class
HS = 4 // Hesiod [Dyer 87]
}
/*
* 3.2.5. QCLASS values
*
* QCLASS fields appear in the question section of a query. QCLASS values
* are a superset of CLASS values; every CLASS is a valid QCLASS. In
* addition to CLASS values, the following QCLASSes are defined:
*
* QCLASS value meaning
*/
public enum QClass : ushort
{
IN = Class.IN, // the Internet
CS = Class.CS, // the CSNET class (Obsolete - used only for examples in some obsolete RFCs)
CH = Class.CH, // the CHAOS class
HS = Class.HS, // Hesiod [Dyer 87]
ANY = 255 // any class
}
/*
RCODE Response code - this 4 bit field is set as part of
responses. The values have the following
interpretation:
*/
public enum RCode
{
NoError = 0, // No Error [RFC1035]
FormErr = 1, // Format Error [RFC1035]
ServFail = 2, // Server Failure [RFC1035]
NXDomain = 3, // Non-Existent Domain [RFC1035]
NotImp = 4, // Not Implemented [RFC1035]
Refused = 5, // Query Refused [RFC1035]
YXDomain = 6, // Name Exists when it should not [RFC2136]
YXRRSet = 7, // RR Set Exists when it should not [RFC2136]
NXRRSet = 8, // RR Set that should exist does not [RFC2136]
NotAuth = 9, // Server Not Authoritative for zone [RFC2136]
NotZone = 10, // Name not contained in zone [RFC2136]
RESERVED11 = 11, // Reserved
RESERVED12 = 12, // Reserved
RESERVED13 = 13, // Reserved
RESERVED14 = 14, // Reserved
RESERVED15 = 15, // Reserved
BADVERSSIG = 16, // Bad OPT Version [RFC2671]
// TSIG Signature Failure [RFC2845]
BADKEY = 17, // Key not recognized [RFC2845]
BADTIME = 18, // Signature out of time window [RFC2845]
BADMODE = 19, // Bad TKEY Mode [RFC2930]
BADNAME = 20, // Duplicate key name [RFC2930]
BADALG = 21, // Algorithm not supported [RFC2930]
BADTRUNC = 22 // Bad Truncation [RFC4635]
/*
23-3840 available for assignment
0x0016-0x0F00
3841-4095 Private Use
0x0F01-0x0FFF
4096-65535 available for assignment
0x1000-0xFFFF
*/
}
/*
OPCODE A four bit field that specifies kind of query in this
message. This value is set by the originator of a query
and copied into the response. The values are:
0 a standard query (QUERY)
1 an inverse query (IQUERY)
2 a server status request (STATUS)
3-15 reserved for future use
*/
public enum OPCode
{
Query = 0, // a standard query (QUERY)
IQUERY = 1, // OpCode Retired (previously IQUERY - No further [RFC3425]
// assignment of this code available)
Status = 2, // a server status request (STATUS) RFC1035
RESERVED3 = 3, // IANA
Notify = 4, // RFC1996
Update = 5, // RFC2136
RESERVED6 = 6,
RESERVED7 = 7,
RESERVED8 = 8,
RESERVED9 = 9,
RESERVED10 = 10,
RESERVED11 = 11,
RESERVED12 = 12,
RESERVED13 = 13,
RESERVED14 = 14,
RESERVED15 = 15,
}
public enum TransportType
{
Udp,
Tcp
}
}

30
MinecraftClient/Protocol/Handlers/Protocol16.cs
View file

@ -23,7 +23,7 @@ namespace MinecraftClient.Protocol.Handlers
private string autocomplete_result = "";
private bool encrypted = false;
private int protocolversion;
private Thread netRead;
private Tuple<Thread, CancellationTokenSource>? netRead = null;
Crypto.IAesStream s;
TcpClient c;
@ -60,20 +60,28 @@ namespace MinecraftClient.Protocol.Handlers
this.c = Client;
}
private void Updater()
private void Updater(object? o)
{
if (((CancellationToken) o!).IsCancellationRequested)
return;
try
{
do
while (!((CancellationToken) o!).IsCancellationRequested)
{
Thread.Sleep(100);
do
{
Thread.Sleep(100);
} while (Update());
}
while (Update());
}
catch (System.IO.IOException) { }
catch (SocketException) { }
catch (ObjectDisposedException) { }
if (((CancellationToken) o!).IsCancellationRequested)
return;
handler.OnConnectionLost(ChatBot.DisconnectReason.ConnectionLost, "");
}
@ -194,11 +202,11 @@ namespace MinecraftClient.Protocol.Handlers
return true; //packet has been successfully skipped
}
private void StartUpdating()
private void StartUpdating()
{
netRead = new Thread(new ThreadStart(Updater));
netRead.Name = "ProtocolPacketHandler";
netRead.Start();
netRead = new(new Thread(new ParameterizedThreadStart(Updater)), new CancellationTokenSource());
netRead.Item1.Name = "ProtocolPacketHandler";
netRead.Item1.Start(netRead.Item2.Token);
}
/// <summary>
@ -207,7 +215,7 @@ namespace MinecraftClient.Protocol.Handlers
/// <returns>Net read thread ID</returns>
public int GetNetReadThreadId()
{
return netRead != null ? netRead.ManagedThreadId : -1;
return netRead != null ? netRead.Item1.ManagedThreadId : -1;
}
public void Dispose()
@ -216,7 +224,7 @@ namespace MinecraftClient.Protocol.Handlers
{
if (netRead != null)
{
netRead.Abort();
netRead.Item2.Cancel();
c.Close();
}
}

34
MinecraftClient/Protocol/Handlers/Protocol18.cs
View file

@ -12,7 +12,6 @@ using MinecraftClient.Mapping.BlockPalettes;
using MinecraftClient.Mapping.EntityPalettes;
using MinecraftClient.Protocol.Handlers.Forge;
using MinecraftClient.Inventory;
using System.Windows.Forms;
using System.Data.SqlClient;
using System.Diagnostics;
using MinecraftClient.Inventory.ItemPalettes;
@ -72,7 +71,7 @@ namespace MinecraftClient.Protocol.Handlers
PacketTypePalette packetPalette;
SocketWrapper socketWrapper;
DataTypes dataTypes;
Thread netRead; // main thread
Tuple<Thread, CancellationTokenSource>? netRead = null; // main thread
ILogger log;
public Protocol18Handler(TcpClient Client, int protocolVersion, IMinecraftComHandler handler, ForgeInfo forgeInfo)
@ -153,14 +152,22 @@ namespace MinecraftClient.Protocol.Handlers
/// <summary>
/// Separate thread. Network reading loop.
/// </summary>
private void Updater()
private void Updater(object? o)
{
try
if (((CancellationToken) o!).IsCancellationRequested)
return;
try
{
bool keepUpdating = true;
Stopwatch stopWatch = new Stopwatch();
while (keepUpdating)
while (keepUpdating)
{
((CancellationToken)o!).ThrowIfCancellationRequested();
stopWatch.Start();
keepUpdating = Update();
stopWatch.Stop();
@ -173,7 +180,11 @@ namespace MinecraftClient.Protocol.Handlers
catch (System.IO.IOException) { }
catch (SocketException) { }
catch (ObjectDisposedException) { }
catch (OperationCanceledException) { }
if (((CancellationToken) o!).IsCancellationRequested)
return;
handler.OnConnectionLost(ChatBot.DisconnectReason.ConnectionLost, "");
}
@ -1160,11 +1171,12 @@ namespace MinecraftClient.Protocol.Handlers
/// <summary>
/// Start the updating thread. Should be called after login success.
/// </summary>
private void StartUpdating()
private void StartUpdating()
{
netRead = new Thread(new ThreadStart(Updater));
netRead.Name = "ProtocolPacketHandler";
netRead.Start();
netRead = new Tuple<Thread, CancellationTokenSource>(new Thread(new ParameterizedThreadStart(Updater)), new CancellationTokenSource());
netRead.Item1.Name = "ProtocolPacketHandler";
netRead.Item1.Start(netRead.Item2.Token);
}
/// <summary>
@ -1173,7 +1185,7 @@ namespace MinecraftClient.Protocol.Handlers
/// <returns>Net read thread ID</returns>
public int GetNetReadThreadId()
{
return netRead != null ? netRead.ManagedThreadId : -1;
return netRead != null ? netRead.Item1.ManagedThreadId : -1;
}
/// <summary>
@ -1185,7 +1197,7 @@ namespace MinecraftClient.Protocol.Handlers
{
if (netRead != null)
{
netRead.Abort();
netRead.Item2.Cancel();
socketWrapper.Disconnect();
}
}

Some files were not shown because too many files have changed in this diff Show more