SDK/MrAG/Networking.cs

1150 lines
40 KiB
C#

using System;
using System.IO;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.Collections;
using System.Collections.Generic;
namespace MrAG
{
public class Networking
{
public class GamerServicesNetworkingException : Exception{
public GamerServicesNetworkingException(string msg): base(msg){
}
}
public class Packet
{
#region Packet
TcpClient Client;
byte[] Data;
byte[] Buffer;
int curpos;
int recpos;
bool sending, recieving;
bool forcestreamclose;
public bool ShouldSwapEndian;
/// <summary>
/// Create instance of networking packet
/// </summary>
public Packet(){
this.Data = new byte[0];
this.Buffer = new byte[0];
}
public Packet(System.Net.Sockets.TcpClient c){
this.Data = new byte[0];
this.Buffer = new byte[0];
this.Client = c;
}
public Packet(TCPClient c){
this.Data = new byte[0];
this.Buffer = new byte[0];
this.Client = c.Connection.GetClient();
}
public Packet(string ip, int port){
this.Data = new byte[0];
this.Buffer = new byte[0];
this.Client = new TcpClient();
IAsyncResult ar = this.Client.BeginConnect(ip, port, null, null);
if (!ar.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(1), false)) {
this.Client.Close();
throw new TimeoutException();
}
this.Client.EndConnect(ar);
}
public TcpClient GetClient(){
return this.Client;
}
public bool Pending(){
return this.Client.Available > 0;
}
public void Close(){
this.forcestreamclose = true;
this.Buffer = null;
this.Data = null;
this.curpos = 0;
this.recpos = 0;
if (this.Client != null)
this.Client.Close();
}
public void SetTimeout(int timeout) {
this.Client.ReceiveTimeout = timeout;
this.Client.SendTimeout = timeout;
}
public byte[] GetRawSendBuffer() {
return Data;
}
public byte[] GetRawRecieveBuffer() {
return Buffer;
}
public void SetRawSendBuffer(byte[] buffer) {
Data = buffer;
curpos = buffer.Length > 0 ? buffer.Length - 1 : 0;
}
public void SetRawRecieveBuffer(byte[] buffer) {
Buffer = buffer;
recpos = 0;
}
public bool IsStillConnected() {
return !forcestreamclose;
}
public void Rewind_Send(int num) {
this.curpos -= num;
}
public void Rewind_Recieve(int num) {
this.recpos -= num;
}
public byte Shift_Left(byte b, int dist) {
if ((dist &= 7) == 0){
return b;
}
return (byte)((b << dist) | (b >> (8 - dist)));
}
public byte Shift_Right(byte b, int dist) {
if ((dist &= 7) == 0){
return b;
}
return (byte)((b >> dist) | (b << (8 - dist)));
}
public void Encrypt(string key) { Encrypt(key, 1, this.Data.Length - 1); }
public void Encrypt(string key, int startpos) { Encrypt(key, startpos, this.Data.Length - startpos); }
public void Encrypt(string key, int startpos, int length) {
key = MrAG.Networking.MD5(key);
int keynumber = 0;
for (int i = 0; i < key.Length; i++) {
if (char.IsNumber(key[i])) {
keynumber += int.Parse(key[i].ToString());
}
}
Encrypt(keynumber, startpos, length);
}
public void Encrypt(int key) { Encrypt(key, 1, this.Data.Length - 1); }
public void Encrypt(int key, int startpos) { Encrypt(key, startpos, this.Data.Length - startpos); }
public void Encrypt(int key, int startpos, int length) {
if (key % 8 == 0)
key++;
for (int i = startpos; i < startpos + length; i++ ) {
this.Data[i] = Shift_Left(this.Data[i], key);
}
}
public void Decrypt(string key, int LengthToDecrypt) {
CheckBuffer(LengthToDecrypt);
key = MrAG.Networking.MD5(key);
int keynumber = 0;
for (int i = 0; i < key.Length; i++) {
if (char.IsNumber(key[i])) {
keynumber += int.Parse(key[i].ToString());
}
}
Decrypt(keynumber, LengthToDecrypt);
}
public void Decrypt(int key, int LengthToDecrypt) {
if (key % 8 == 0)
key++;
CheckBuffer(LengthToDecrypt);
for (int i = this.recpos; i < this.Buffer.Length; i++ ) {
this.Buffer[i] = Shift_Right(this.Buffer[i], key);
}
this.Rewind_Recieve(LengthToDecrypt);
}
#region Writer
/// <summary>
/// Sends an packet whit the ID and infinite arguments
/// </summary>
public void Send(byte packetID, int size, params object[] args) {
Start_Send();
AddByte(packetID);
if (args != null) {
foreach (object obj in args) {
Type t = obj.GetType();
// texts
if (t == typeof(string)) AddText((string)obj);
// numbers
else if (t == typeof(short)) AddShort((short)obj);
else if (t == typeof(int)) AddInt((int)obj);
else if (t == typeof(float)) AddFloat((float)obj);
else if (t == typeof(double)) AddDouble((double)obj);
else if (t == typeof(long)) AddLong((long)obj);
// single
else if (t == typeof(byte)) AddByte((byte)obj);
else if (t == typeof(bool)) AddBool((bool)obj);
// other
else if (t == typeof(byte[])) AddBytes((byte[])obj);
}
}
Finish_Send();
}
public void SendEncrypted(string encryptionkey, byte packetID, int size, params object[] args) {
Start_Send();
AddByte(packetID);
if (args != null) {
foreach (object obj in args) {
Type t = obj.GetType();
// texts
if (t == typeof(string)) AddText((string)obj);
// numbers
else if (t == typeof(short)) AddShort((short)obj);
else if (t == typeof(int)) AddInt((int)obj);
else if (t == typeof(float)) AddFloat((float)obj);
else if (t == typeof(double)) AddDouble((double)obj);
else if (t == typeof(long)) AddLong((long)obj);
// single
else if (t == typeof(byte)) AddByte((byte)obj);
else if (t == typeof(bool)) AddBool((bool)obj);
// other
else if (t == typeof(byte[])) AddBytes((byte[])obj);
}
}
Encrypt(encryptionkey);
Finish_Send();
}
/// <summary>
/// Create instance of networking packet
/// </summary>
public void Start_Send(){
while(this.sending){}
this.sending = true;
}
/// <summary>
/// Çreate an instance of an networked packet, whit an sendbuffer size, use this to speed up sending by estemating the size in bytes of the packet
/// </summary>
public void Start_Send(int sendbuffer){
while(this.sending){}
this.Data = new byte[sendbuffer];
this.curpos = 0;
this.sending = true;
}
/// <summary>
/// Çreate an instance of an networked packet, whit an sendbuffer size, use this to speed up sending by estemating the size in bytes of the packet
/// </summary>
public void Start_Send(long sendbuffer){
while(this.sending){}
this.Data = new byte[sendbuffer];
this.curpos = 0;
this.sending = true;
}
/// <summary>
/// Sends the created packet, and then flushes the current data.
/// </summary>
public void Finish_Send(){
if (this.curpos != this.Data.Length - 1){
byte[] tempb = new byte[this.curpos];
for (int i = 0; i < this.curpos; i++)tempb[i] = Data[i];
Data = tempb;
}
try{
this.Client.GetStream().Write(this.Data, 0, this.Data.Length);
}catch{
forcestreamclose = true;
this.Client.Close();
}
this.Data = new byte[0];
this.curpos = 0;
this.sending = false;
}
private void CheckSize(int count)
{
if (Data.Length - curpos < count)
{
byte[] tempb = new byte[Data.Length + count];
Data.CopyTo(tempb, 0);
Data = tempb;
}
}
public void AddByte(byte b)
{
this.CheckSize(1);
Data[curpos] = b;
curpos += 1;
}
public void AddByte(int b)
{
this.CheckSize(1);
Data[curpos] = (byte)b;
curpos += 1;
}
public void AddBytes(byte[] b)
{
this.CheckSize(b.Length + 4);
this.AddInt(b.Length);
for (int i = 0; i < b.Length; i++) Data[curpos + i] = b[i];
curpos += b.Length;
}
public void AddBytes(byte[] b, int start, int count)
{
this.CheckSize(b.Length + 4);
this.AddInt(count);
for (int i = start; i < start + count; i++) Data[curpos + i] = b[i];
curpos += b.Length;
}
public void AddBytesNoLength(byte[] b)
{
this.CheckSize(b.Length);
for (int i = 0; i < b.Length; i++) Data[curpos + i] = b[i];
curpos += b.Length;
}
public void AddBytesNoLength(byte[] b, int start, int count)
{
this.CheckSize(b.Length);
for (int i = start; i < start + count; i++) Data[curpos + i] = b[i];
curpos += b.Length;
}
public void AddShort(short number)
{
this.CheckSize(2);
number = this.ShouldSwapEndian ? this.SwapEndian(number) : number;
Data[curpos + 1] = (byte)((number & 0xff00) >> 8);
Data[curpos + 0] = (byte)(number & 0x00ff);
curpos += 2;
}
public void AddInt16(short number){this.AddShort(number);}
public void AddInt(int number){
this.CheckSize(4);
number = this.ShouldSwapEndian ? this.SwapEndian(number) : number;
this.Data[curpos + 3] = (byte)((number & 0xff000000) >> 24);
this.Data[curpos + 2] = (byte)((number & 0x00ff0000) >> 16);
this.Data[curpos + 1] = (byte)((number & 0x0000ff00) >> 8);
this.Data[curpos + 0] = (byte)(number & 0x000000ff);
this.curpos += 4;
}
public void AddInt32(int number){this.AddInt(number);}
public void AddDouble(double number)
{
this.CheckSize(8);
number = this.ShouldSwapEndian ? this.SwapEndian(number) : number;
byte[] tmpb = BitConverter.GetBytes(number);
Array.Reverse(tmpb);
Data[curpos + 7] = (byte)tmpb[0];
Data[curpos + 6] = (byte)tmpb[1];
Data[curpos + 5] = (byte)tmpb[2];
Data[curpos + 4] = (byte)tmpb[3];
Data[curpos + 3] = (byte)tmpb[4];
Data[curpos + 2] = (byte)tmpb[5];
Data[curpos + 1] = (byte)tmpb[6];
Data[curpos + 0] = (byte)tmpb[7];
curpos += 8;
}
public void AddFloat(float number)
{
this.CheckSize(4);
number = this.ShouldSwapEndian ? this.SwapEndian(number) : number;
byte[] tmpb = BitConverter.GetBytes(number);
Array.Reverse(tmpb);
Data[curpos + 3] = (byte)tmpb[0];
Data[curpos + 2] = (byte)tmpb[1];
Data[curpos + 1] = (byte)tmpb[2];
Data[curpos + 0] = (byte)tmpb[3];
curpos += 4;
}
public void AddSingle(float number){this.AddFloat(number);}
public void AddBool(bool bul)
{
this.CheckSize(1);
if (bul)
Data[curpos] = (byte)1;
else
Data[curpos] = (byte)0;
curpos += 1;
}
public void AddLong(long number)
{
this.CheckSize(8);
number = this.ShouldSwapEndian ? this.SwapEndian(number) : number;
byte[] b = System.BitConverter.GetBytes(number);
for (int i = 0; i < b.Length; i++) Data[i + curpos] = b[i];
curpos += 8;
}
public void AddInt64(long number){this.AddLong(number);}
public void AddString(string text){
int len = Encoding.UTF8.GetByteCount(text);
this.CheckSize(len + 4);
this.AddInt(len);
this.curpos += Encoding.UTF8.GetBytes(text, 0, text.Length, this.Data, this.curpos);
}
public void AddText(string text){this.AddString(text);}
public void AddString_ASCII(string text){
int len = Encoding.ASCII.GetByteCount(text);
this.CheckSize(len + 4);
this.AddInt(len);
this.curpos += Encoding.ASCII.GetBytes(text, 0, text.Length, this.Data, this.curpos);
}
public void AddString_Unicode(string text){
int len = Encoding.Unicode.GetByteCount(text);
this.CheckSize(len + 4);
this.AddInt(len);
this.curpos += Encoding.Unicode.GetBytes(text, 0, text.Length, this.Data, this.curpos);
}
public void AddStringShort(string text){
int len = Encoding.UTF8.GetByteCount(text);
this.CheckSize(len + 2);
this.AddShort((short)len);
this.curpos += Encoding.UTF8.GetBytes(text, 0, text.Length, this.Data, this.curpos);
}
public void AddStringByte(string text){
int len = Encoding.UTF8.GetByteCount(text);
this.CheckSize(len + 1);
this.AddByte((byte)len);
this.curpos += Encoding.UTF8.GetBytes(text, 0, text.Length, this.Data, this.curpos);
}
public void AddStringNullTerminated(string text) {
int len = Encoding.UTF8.GetByteCount(text);
this.CheckSize(len + 1);
this.Data[this.curpos + len] = 0;
this.curpos += Encoding.UTF8.GetBytes(text, 0, text.Length, this.Data, this.curpos);
}
public void AddLine(string text){
byte[] tmpb = Encoding.UTF8.GetBytes(text + "\r\n");
this.CheckSize(tmpb.Length);
for (int i = 0; i < tmpb.Length; i++) this.Data[i + curpos] = tmpb[i];
this.curpos += tmpb.Length;
}
#endregion
#region Reader
public void Flush(){
this.Buffer = new byte[0];
this.recpos = 0;
}
public void Start_Recieve(){
while(this.recieving){}
this.recieving = true;
}
public void Start_Recieve(int buffersize){
while(this.recieving){}
this.Buffer = new byte[buffersize];
this.recpos = 0;
this.recieving = true;
}
public void Start_Recieve(long buffersize){
while(this.recieving){}
this.Buffer = new byte[buffersize];
this.recpos = 0;
this.recieving = true;
}
public void Finish_Recieve(){
this.Buffer = new byte[0];
this.recpos = 0;
this.recieving = false;
}
private void CheckBuffer(int size){
if (this.Buffer.Length < this.recpos + size) {
int oldlen = this.Buffer.Length;
byte[] tempb = new byte[this.Buffer.Length + size];
this.Buffer.CopyTo(tempb, 0);
this.Buffer = tempb;
} else
return;
this.Client.GetStream().Read(this.Buffer, recpos, size);
}
public string ReadLine(){
List<byte> tmpb = new List<byte>();
while(true){
CheckBuffer(1);
tmpb.Add(this.Buffer[this.recpos]);
this.recpos++;
if (tmpb.Count > 1 && tmpb[tmpb.Count - 2] == '\r' && tmpb[tmpb.Count - 1] == '\n'){
tmpb.RemoveAt(tmpb.Count - 1);
tmpb.RemoveAt(tmpb.Count - 1);
return Encoding.UTF8.GetString(tmpb.ToArray());
}
}
}
public byte ReadByte(){
this.CheckBuffer(1);
recpos += 1;
return this.Buffer[recpos - 1];
}
public byte[] ReadBytes(){
int size = this.ReadInt();
this.CheckBuffer(size);
byte[] tmp = new byte[size];
for (int i = 0; i < size; i++)tmp[i] = this.Buffer[recpos + i];
recpos += size;
return tmp;
}
public byte[] ReadBytes(int size){
this.CheckBuffer(size);
byte[] tmp = new byte[size];
for (int i = 0; i < size; i++)tmp[i] = this.Buffer[recpos + i];
//this.Buffer.CopyTo(tmp, recpos);
recpos += size;
return tmp;
}
public bool ReadBool(){
this.CheckBuffer(1);
recpos += 1;
return this.Buffer[recpos - 1] == (byte)1;
}
public short ReadShort(){
this.CheckBuffer(2);
recpos += 2;
short res = System.BitConverter.ToInt16(this.Buffer, recpos - 2);
return this.ShouldSwapEndian ? this.SwapEndian(res) : res;
}
public int ReadInt(){
this.CheckBuffer(4);
recpos += 4;
int res = System.BitConverter.ToInt32(this.Buffer, recpos - 4);
return this.ShouldSwapEndian ? this.SwapEndian(res) : res;
}
public float ReadFloat(){
this.CheckBuffer(4);
recpos += 4;
float res = System.BitConverter.ToSingle(this.Buffer, recpos - 4);
return this.ShouldSwapEndian ? this.SwapEndian(res) : res;
}
public double ReadDouble(){
this.CheckBuffer(8);
recpos += 8;
double res = System.BitConverter.ToDouble(this.Buffer, recpos - 8);
return this.ShouldSwapEndian ? this.SwapEndian(res) : res;
}
public long ReadLong(){
this.CheckBuffer(8);
recpos += 8;
long res = System.BitConverter.ToInt64(this.Buffer, recpos - 8);
return this.ShouldSwapEndian ? this.SwapEndian(res) : res;
}
public string ReadString(){
return this.ReadString(int.MaxValue);
}
public string ReadString(int maxlen){
int stringlen = this.ReadInt();
if (stringlen > maxlen)
return "";
if (stringlen > 0) {
this.CheckBuffer(stringlen);
recpos += stringlen;
return Encoding.UTF8.GetString(this.Buffer, recpos - stringlen, stringlen);
} else return "";
}
public string ReadStringShort(){
return this.ReadStringShort(short.MaxValue);
}
public string ReadStringShort(short maxlen){
int stringlen = this.ReadShort();
if (stringlen > maxlen)
return "";
if (stringlen > 0) {
this.CheckBuffer(stringlen);
recpos += stringlen;
return Encoding.UTF8.GetString(this.Buffer, recpos - stringlen, stringlen);
} else return "";
}
public string ReadStringByte(){
return this.ReadStringByte(byte.MaxValue);
}
public string ReadStringByte(byte maxlen){
byte stringlen = this.ReadByte();
if (stringlen > maxlen)
return "";
if (stringlen > 0) {
this.CheckBuffer(stringlen);
recpos += stringlen;
return Encoding.UTF8.GetString(this.Buffer, recpos - stringlen, stringlen);
} else return "";
}
public string ReadStringNullTerminated(){
StringBuilder sb = new StringBuilder();
while(true){
CheckBuffer(1);
this.recpos++;
if (this.Buffer[this.recpos - 1] != 0) {
sb.Append(Encoding.UTF8.GetString(this.Buffer, this.recpos - 1, 1));
} else {
return sb.ToString();
}
}
}
public int GetBufferSize(){
return this.Buffer.Length;
}
#endregion
#region Endian Swapping
public short SwapEndian(short num)
{
return (short)((num & 0x00FF) << 8 | (num & 0xFF00) >> 8);
}
public Int32 SwapEndian(Int32 num)
{
return (Int32)((num & 0x000000FF) << 24 | (num & 0x0000FF00) << 8 | (num & 0x00FF0000) >> 8 | (num & 0xFF000000) >> 24);
}
public float SwapEndian(float num)
{
return BitConverter.ToSingle(BitConverter.GetBytes(SwapEndian(BitConverter.ToInt32(BitConverter.GetBytes(num),0))),0);
}
public double SwapEndian(double num)
{
byte[] dblBytes = BitConverter.GetBytes(num);
byte[] swappedBytes = new byte[8];
for (int i = 0; i < 8; i++) swappedBytes[i] = dblBytes[7 - i];
return BitConverter.ToDouble(swappedBytes, 0);
}
public long SwapEndian(long num)
{
byte[] lngBytes = BitConverter.GetBytes(num);
byte[] swappedBytes = new byte[8];
for (int i = 0; i < 8; i++) swappedBytes[i] = lngBytes[7 - i];
return BitConverter.ToInt64(swappedBytes, 0);
}
#endregion
#endregion
}
public class IncomingConnection{
public string Username;
public TCPClient Connection;
public int Ping;
public string IP;
public uint Port;
public bool FinishedConnecting;
public string _KickReason;
public void Kick(string reason) {
_KickReason = reason;
if (this.FinishedConnecting && this.Connection != null) {
this.Connection.Close();
//throw new MrAG.Networking.GamerServicesNetworkingException("Cannot kick an finished connection handle, call Connection.Close() instead!");
}
}
}
public class TCPClient{
public Packet Connection;
public Action<byte, Packet> OnRecieve;
public Action OnDisconnect;
public Action<Packet>[] Packets;
public bool DebugMode;
public bool Connected = true;
public TCPClient(string ip, int port) {
TcpClient c = new TcpClient();
IAsyncResult ar = c.BeginConnect(ip, port, null, null);
if (!ar.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(1), false)) {
c.Close();
throw new TimeoutException();
}
c.EndConnect(ar);
Packets = new Action<Packet>[256];
Connection = new Packet(c);
}
public TCPClient(Packet connection){
Packets = new Action<Packet>[256];
Connection = connection;
}
public TCPClient(System.Net.Sockets.TcpClient connection){
Packets = new Action<Packet>[256];
Connection = new Packet(connection);
}
public TCPClient(){
Packets = new Action<Packet>[256];
this.Connected = false;
}
public bool Connect(string ip, int port) {
if (this.Connected)
this.Close();
TcpClient c = new TcpClient();
IAsyncResult ar = c.BeginConnect(ip, port, null, null);
if (!ar.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(1), false)) {
c.Close();
return false;
}
c.EndConnect(ar);
Packets = new Action<Packet>[256];
Connection = new Packet(c);
return true;
}
public bool Alive() {
return Connection.GetClient().Client.RemoteEndPoint == null;
}
public void Send(byte packetID, int size, params object[] args) {
Connection.Start_Send(size);
Connection.AddByte(packetID);
if (args != null) {
foreach (object obj in args) {
Type t = obj.GetType();
// texts
if (t == typeof(string)) Connection.AddText((string)obj);
// numbers
else if (t == typeof(short)) Connection.AddShort((short)obj);
else if (t == typeof(int)) Connection.AddInt((int)obj);
else if (t == typeof(float)) Connection.AddFloat((float)obj);
else if (t == typeof(double)) Connection.AddDouble((double)obj);
else if (t == typeof(long)) Connection.AddLong((long)obj);
// single
else if (t == typeof(byte)) Connection.AddByte((byte)obj);
else if (t == typeof(bool)) Connection.AddBool((bool)obj);
// other
else if (t == typeof(byte[])) Connection.AddBytes((byte[])obj);
else throw new MrAG.Networking.GamerServicesNetworkingException("Unsupported type: " + t.Name + ", value: " + obj.ToString());
}
}
Connection.Finish_Send();
}
public void SendEncrypted(string encryptionkey, byte packetID, int size, params object[] args) {
this.Connection.Start_Send(size);
this.Connection.AddByte(packetID);
if (args != null) {
foreach (object obj in args) {
Type t = obj.GetType();
System.Diagnostics.Debug.Print("Data type " + t.FullName + ", value: " + obj.ToString());
// texts
if (t == typeof(string)) Connection.AddText((string)obj);
// numbers
else if (t == typeof(short)) Connection.AddShort((short)obj);
else if (t == typeof(int)) Connection.AddInt((int)obj);
else if (t == typeof(float)) Connection.AddFloat((float)obj);
else if (t == typeof(double)) Connection.AddDouble((double)obj);
else if (t == typeof(long)) Connection.AddLong((long)obj);
// single
else if (t == typeof(byte)) Connection.AddByte((byte)obj);
else if (t == typeof(bool)) Connection.AddBool((bool)obj);
// other
else if (t == typeof(byte[])) Connection.AddBytes((byte[])obj);
else throw new MrAG.Networking.GamerServicesNetworkingException("Unsupported type: " + t.Name + ", value: " + obj.ToString());
}
}
this.Connection.Encrypt(encryptionkey);
this.Connection.Finish_Send();
}
public void Update(){
if (this.Connected && !this.Connection.IsStillConnected()) {
this.Connected = false;
if (this.OnDisconnect != null)
this.OnDisconnect.DynamicInvoke();
}
if (this.Connected && this.Connection.Pending()) {
while (this.Connected && this.Connection.Pending()) {
this.Connection.Start_Recieve();
byte PacketID = this.Connection.ReadByte();
if (this.DebugMode) Console.WriteLine("Packet: " + PacketID);
if (this.Packets[PacketID] != null) {
this.Packets[PacketID](this.Connection);
} else {
if (this.OnRecieve != null) {
this.OnRecieve(PacketID, this.Connection);
} else {
while (this.Connection.GetClient().GetStream().DataAvailable) {
this.Connection.GetClient().GetStream().ReadByte();
}
List<byte> remainingcrap = new List<byte>();
string remainingdata = "";
while (this.Connection.Pending()) {
remainingdata += ", " + this.Connection.ReadByte().ToString();
}
if (remainingdata.Length > 0) remainingdata = remainingdata.Substring(1);
this.Connection.Finish_Recieve();
throw new GamerServicesNetworkingException("Unhandled packetID: " + PacketID + "\n" + remainingdata);
}
}
if (this.Connection != null)
this.Connection.Finish_Recieve();
}
}
}
public void Close() {
if (this.Connection != null)
this.Connection.Close();
this.Connected = false;
this.DebugMode = false;
this.Packets = null;
this.OnRecieve = null;
this.OnDisconnect = null;
this.Connection = null;
}
}
public static string[] PostData(string action, string data){
Hashtable hashtbl = new Hashtable();
foreach (string line in data.Split('&')){
if (data.Length > 0){
string[] dat = line.Split('=');
hashtbl[dat[0]] = dat[1];
}
}
return PostData(action, hashtbl);
}
public static string MD5(string input) {
System.Security.Cryptography.MD5CryptoServiceProvider x = new System.Security.Cryptography.MD5CryptoServiceProvider();
byte[] bs = System.Text.Encoding.UTF8.GetBytes(input);
bs = x.ComputeHash(bs);
System.Text.StringBuilder s = new System.Text.StringBuilder();
foreach (byte b in bs)
{
s.Append(b.ToString("x2"));
}
return s.ToString().ToLower();
}
private static string[] PostData(string action, Hashtable values){
try{
Networking.WebPostRequest c = new Networking.WebPostRequest("http://gs.mrag.nl/api");
c.Add("action", action);
string SessID = Gamerservices.GetSessID();
if (SessID != null && SessID.Length > 0) c.Add("sess", SessID);
foreach (DictionaryEntry entry in values){
c.Add((string)entry.Key, (string)entry.Value);
}
string[] res = c.GetResponse().Split('\n');
if (Gamerservices.GetDebug()){
string[] keys = new string[res.Length + values.Count + 2];
string[] vals = new string[res.Length + values.Count + 2];
int id = 0;
foreach (DictionaryEntry entry in values){
keys[id] = (string)entry.Key;
vals[id] = (string)entry.Value;
id++;
}
keys[id + 1] = "Responses";
vals[id + 1] = res.Length.ToString();
for (int i = 0; i < res.Length; i++){
keys[id + 2 + i] = i.ToString();
vals[id + 2 + i] = res[i];
}
Gamerservices.Print("WebPost", keys, vals);
}
if (res[0] == "no"){
throw new GamerServicesNetworkingException(res[1]);
}else{
string[] arr = new string[res.Length - 1];
for (int i = 1; i < res.Length; i++){
arr[i - 1] = res[i];
}
return arr;
}
}catch{
string[] keys = new string[values.Count];
string[] vals = new string[values.Count];
int id = 0;
foreach (DictionaryEntry entry in values){
keys[id] = (string)entry.Key;
vals[id] = (string)entry.Value;
id++;
}
Gamerservices.Print("FATALERROR AT WEBPOST", keys, vals);
return new string[0];
}
}
public class WebPostRequest
{
public bool broken = false;
public StreamReader sr;
public ArrayList theQueryData;
public WebRequest theRequest;
public HttpWebResponse theResponse;
public WebPostRequest(string url)
{
try{
this.theRequest = WebRequest.Create(url);
this.theRequest.Method = "POST";
}catch{
System.Diagnostics.Debug.Print("Server uri in properties is invalid!");
this.broken = true;
}
this.theQueryData = new ArrayList();
}
public WebPostRequest(string url, bool a)
{
try{
this.theRequest = WebRequest.Create(url);
}catch{
System.Diagnostics.Debug.Print("Server uri in properties is invalid!");
this.broken = true;
}
this.theQueryData = new ArrayList();
}
public void Add(string key, string value)
{
if (!this.broken){
this.theQueryData.Add(string.Format("{0}={1}", key, value));
}else{
System.Diagnostics.Debug.Print("Server uri in properties is invalid!");
}
}
public string GetResponse()
{
if (!this.broken)
{
this.theRequest.ContentType = "application/x-www-form-urlencoded";
string str = string.Join("&", (string[])this.theQueryData.ToArray(typeof(string)));
this.theRequest.ContentLength = str.Length;
this.theRequest.Proxy = null;
try{
StreamWriter writer = new StreamWriter(this.theRequest.GetRequestStream());
writer.Write(str);
writer.Close();
}catch{
return "";
}
try{
this.theResponse = (HttpWebResponse)this.theRequest.GetResponse();
this.sr = new StreamReader(this.theResponse.GetResponseStream());
}catch (Exception e){
System.Diagnostics.Debug.Print(e.Message);
return "";
}
try{
return this.sr.ReadToEnd();
}catch{
return "";
}
}
throw new MrAG.Networking.GamerServicesNetworkingException("Server uri in properties is invalid!");
}
}
}
}