//Send chunked response
private static void WriteResponseBodyChunked(CustomBinaryReader inStreamReader, Stream outStream)
{
while (true)
{
var chuchkHead = inStreamReader.ReadLine();
var chunkSize = int.Parse(chuchkHead, NumberStyles.HexNumber);
if (chunkSize != 0)
{
var buffer = inStreamReader.ReadBytes(chunkSize);
var chunkHead = Encoding.ASCII.GetBytes(chunkSize.ToString("x2"));
outStream.Write(chunkHead, 0, chunkHead.Length);
outStream.Write(NewLineBytes, 0, NewLineBytes.Length);
outStream.Write(buffer, 0, chunkSize);
outStream.Write(NewLineBytes, 0, NewLineBytes.Length);
inStreamReader.ReadLine();
}
else
{
inStreamReader.ReadLine();
outStream.Write(ChunkEnd, 0, ChunkEnd.Length);
break;
}
}
}
public void Read(CustomBinaryReader reader)
{
Size = reader.ReadUInt32();
_startPosition = reader.Position;
ID = reader.ReadUInt32();
ReadData(reader);
}
private void DoResponse(ushort code, byte[] postbytes, IProtocol data)
{
object[] args = new object[] { code, data.GetType().FullName };
Debugger.Log(Utils.FormatString("静默处理 code:{0} class:{1}", args));
switch (code)
{
case 7:
{
Debugger.Log("宝箱开启缓存请求 静默处理");
CustomBinaryReader reader = new CustomBinaryReader(new MemoryStream(postbytes));
byte num = reader.ReadByte();
ushort num2 = reader.ReadUInt16();
ushort num3 = reader.ReadUInt16();
if (num2 == code)
{
IProtocol protocol = this.CreateProtocol(code, reader);
if (protocol != null)
{
protocol.ReadFromStream(reader);
CReqItemPacket packet = protocol as CReqItemPacket;
object[] objArray2 = new object[] { packet.m_nCoinAmount, packet.m_nExperince, packet.arrayEquipItems.Length };
Debugger.Log(Utils.FormatString("金币:{0} 经验:{1} 装备数量:{2}", objArray2));
for (int i = 0; i < packet.arrayEquipItems.Length; i++)
{
object[] objArray3 = new object[] { i, packet.arrayEquipItems[i].m_nEquipID, packet.arrayEquipItems[i].m_nFragment };
Debugger.Log(Utils.FormatString("装备[{0}] id:{1} count:{2}", objArray3));
}
}
}
break;
}
}
}
private IProtocol CreateProtocol(ushort code, CustomBinaryReader reader)
{
switch (code)
{
case 4:
return(new CRespMailList());
case 7:
case 11:
case 0x12:
return(new CRespItemPacket());
case 8:
return(new CRespUserLoginPacket());
case 10:
return(new CRespDimaonToCoin());
case 15:
return(new CRespInAppPurchase());
case 0x11:
return(new CRespFirstRewardInfo());
}
return(null);
}
/// <summary>
/// copies the specified bytes to the stream from the input stream
/// </summary>
/// <param name="streamReader"></param>
/// <param name="stream"></param>
/// <param name="totalBytesToRead"></param>
/// <returns></returns>
internal static async Task CopyBytesToStream(this CustomBinaryReader streamReader, Stream stream, long totalBytesToRead)
{
var buffer = streamReader.Buffer;
long remainingBytes = totalBytesToRead;
while (remainingBytes > 0)
{
int bytesToRead = buffer.Length;
if (remainingBytes < bytesToRead)
{
bytesToRead = (int)remainingBytes;
}
int bytesRead = await streamReader.ReadBytesAsync(buffer, bytesToRead);
if (bytesRead == 0)
{
break;
}
remainingBytes -= bytesRead;
await stream.WriteAsync(buffer, 0, bytesRead);
}
}
internal static async Task CopyBytesToStream(this CustomBinaryReader streamReader, Stream stream, long totalBytesToRead)
{
var totalbytesRead = 0;
long bytesToRead;
if (totalBytesToRead < Constants.BUFFER_SIZE)
{
bytesToRead = totalBytesToRead;
}
else
{
bytesToRead = Constants.BUFFER_SIZE;
}
while (totalbytesRead < totalBytesToRead)
{
var buffer = await streamReader.ReadBytesAsync(bytesToRead);
if (buffer.Length == 0)
{
break;
}
totalbytesRead += buffer.Length;
var remainingBytes = totalBytesToRead - totalbytesRead;
if (remainingBytes < bytesToRead)
{
bytesToRead = remainingBytes;
}
await stream.WriteAsync(buffer, 0, buffer.Length);
}
}
/// <summary>
/// copies the specified bytes to the stream from the input stream
/// </summary>
/// <param name="streamReader"></param>
/// <param name="bufferSize"></param>
/// <param name="stream"></param>
/// <param name="totalBytesToRead"></param>
/// <returns></returns>
internal static async Task CopyBytesToStream(this CustomBinaryReader streamReader, int bufferSize, Stream stream, long totalBytesToRead)
{
var totalbytesRead = 0;
long bytesToRead = totalBytesToRead < bufferSize ? totalBytesToRead : bufferSize;
while (totalbytesRead < totalBytesToRead)
{
var buffer = await streamReader.ReadBytesAsync(bufferSize, bytesToRead);
if (buffer.Length == 0)
{
break;
}
totalbytesRead += buffer.Length;
var remainingBytes = totalBytesToRead - totalbytesRead;
if (remainingBytes < bytesToRead)
{
bytesToRead = remainingBytes;
}
await stream.WriteAsync(buffer, 0, buffer.Length);
}
}
//Send chunked response
private static async Task WriteResponseBodyChunked(CustomBinaryReader inStreamReader, Stream outStream)
{
while (true)
{
var chunkHead = await inStreamReader.ReadLineAsync().ConfigureAwait(false);
var chunkSize = int.Parse(chunkHead, NumberStyles.HexNumber);
if (chunkSize != 0)
{
var buffer = await inStreamReader.ReadBytesAsync(chunkSize).ConfigureAwait(false);
var chunkHeadBytes = Encoding.ASCII.GetBytes(chunkSize.ToString("x2"));
await outStream.WriteAsync(chunkHeadBytes, 0, chunkHeadBytes.Length).ConfigureAwait(false);
await outStream.WriteAsync(Constants.NewLineBytes, 0, Constants.NewLineBytes.Length).ConfigureAwait(false);
await outStream.WriteAsync(buffer, 0, chunkSize).ConfigureAwait(false);
await outStream.WriteAsync(Constants.NewLineBytes, 0, Constants.NewLineBytes.Length).ConfigureAwait(false);
await inStreamReader.ReadLineAsync().ConfigureAwait(false);
}
else
{
await inStreamReader.ReadLineAsync().ConfigureAwait(false);
await outStream.WriteAsync(Constants.ChunkEnd, 0, Constants.ChunkEnd.Length).ConfigureAwait(false);
break;
}
}
}
internal static async Task CopyBytesToStreamChunked(this CustomBinaryReader clientStreamReader, Stream stream)
{
while (true)
{
var chuchkHead = await clientStreamReader.ReadLineAsync().ConfigureAwait(false);
var chunkSize = int.Parse(chuchkHead, NumberStyles.HexNumber);
if (chunkSize != 0)
{
var buffer = await clientStreamReader.ReadBytesAsync(chunkSize);
await stream.WriteAsync(buffer, 0, buffer.Length);
//chunk trail
await clientStreamReader.ReadLineAsync().ConfigureAwait(false);
}
else
{
await clientStreamReader.ReadLineAsync().ConfigureAwait(false);
break;
}
}
}
/// <summary>
/// Handle dispose of a client/server session
/// </summary>
/// <param name="tcpClient"></param>
/// <param name="clientStream"></param>
/// <param name="clientStreamReader"></param>
/// <param name="clientStreamWriter"></param>
/// <param name="args"></param>
private void Dispose(Stream clientStream, CustomBinaryReader clientStreamReader,
StreamWriter clientStreamWriter, IDisposable args)
{
if (clientStream != null)
{
clientStream.Close();
clientStream.Dispose();
}
if (args != null)
{
args.Dispose();
}
if (clientStreamReader != null)
{
clientStreamReader.Dispose();
}
if (clientStreamWriter != null)
{
clientStreamWriter.Close();
clientStreamWriter.Dispose();
}
}
public void Read(CustomBinaryReader reader)
{
id = reader.ReadUInt32();
changeOccursWhen = reader.ReadByte();
numberOfStates = reader.ReadUInt16();
states = reader.ReadMany((r) => new CustomSettingsState(r), numberOfStates);
}
/// <summary>
/// Copies the streams chunked
/// </summary>
/// <param name="inStreamReader"></param>
/// <param name="outStream"></param>
/// <returns></returns>
internal static async Task WriteResponseBodyChunked(this CustomBinaryReader inStreamReader, Stream outStream)
{
while (true)
{
var chunkHead = await inStreamReader.ReadLineAsync();
var chunkSize = int.Parse(chunkHead, NumberStyles.HexNumber);
if (chunkSize != 0)
{
var chunkHeadBytes = Encoding.ASCII.GetBytes(chunkSize.ToString("x2"));
await outStream.WriteAsync(chunkHeadBytes, 0, chunkHeadBytes.Length);
await outStream.WriteAsync(ProxyConstants.NewLineBytes, 0, ProxyConstants.NewLineBytes.Length);
await CopyBytesToStream(inStreamReader, outStream, chunkSize);
await outStream.WriteAsync(ProxyConstants.NewLineBytes, 0, ProxyConstants.NewLineBytes.Length);
await inStreamReader.ReadLineAsync();
}
else
{
await inStreamReader.ReadLineAsync();
await outStream.WriteAsync(ProxyConstants.ChunkEnd, 0, ProxyConstants.ChunkEnd.Length);
break;
}
}
}
protected override void DoOpen()
{
using (CustomBinaryReader reader = new CustomBinaryReader(new FileStream(ArchivePath, FileMode.Open, FileAccess.Read)))
{
uint signature = reader.ReadUInt32();
if (signature != 0x58445442)
{
throw new InvalidDataException("File is not BA2");
}
version = reader.ReadUInt32();
if (version > 1)
{
throw new InvalidDataException("Unsupported archive file version: " + version);
}
type = (ArchiveType)reader.ReadUInt32();
if (type != ArchiveType.General)
{
Log.Fine("Skipping archive file which is not the general purpose type.");
return;
}
long baseOffset = reader.BaseStream.Position;
uint fileCount = reader.ReadUInt32();
long fileNameTableOffset = reader.ReadInt64();
FileInfo[] files = new FileInfo[fileCount];
for (int i = 0; i < fileCount; i++)
{
files[i] = new FileInfo()
{
NameHash = reader.ReadUInt32(),
Type = reader.ReadUInt32(),
DirectoryNameHash = reader.ReadUInt32(),
Unknown1 = reader.ReadUInt32(),
DataOffset = reader.ReadInt64(),
DataCompressedSize = reader.ReadUInt32(),
DataUncompressedSize = reader.ReadUInt32(),
Unknown2 = reader.ReadUInt32()
};
}
reader.BaseStream.Position = fileNameTableOffset;
for (int i = 0; i < fileCount; i++)
{
ushort length = reader.ReadUInt16();
string path = reader.ReadStringFixedLength(length).ToLower();
string dir = Path.GetDirectoryName(path).ToLower();
string filename = Path.GetFileName(path).ToLower();
if (!sorted.ContainsKey(dir))
{
sorted.Add(dir, new SortedDictionary <string, FileInfo>());
}
sorted[dir].Add(filename, files[i]);
}
}
}
/// <summary>
/// Десериализует процесс
/// </summary>
/// <param name="br">Читатель из потока</param>
protected virtual void DeserializeInternal(CustomBinaryReader br)
{
this.CompleteExecution = br.ReadBoolean();
this.Id = br.ReadGuid();
this.PopulateExceptions = br.ReadBoolean();
this.Stage = (BpStage)br.ReadByte();
this.StartedOnServer = br.ReadNullableBoolean();
this._status = (BpStatus)br.ReadByte();
this.TrackMode = (BpTrackMode)br.ReadByte();
this.StartTime = br.ReadDateTime();
this.FinishTime = br.ReadDateTime();
if (br.ReadBoolean())
{
this._contextData = new ContextData();
this._contextData.DeserializeInternal(br);
}
int count = br.Read7BitEncodedInt();
List <string> paramNames = new List <string>(count);
this.Parameters = new Dictionary <string, object>(count);
for (int i = 0; i < count; i++)
{
paramNames.Add(br.ReadString());
}
for (int i = 0; i < count; i++)
{
this.Parameters.Add(paramNames[i], br.ReadObject());
}
//this.Progress = (BpProgressData)br.ReadObject();
//this.Result = (BpResultData)br.ReadObject();
if (br.ReadBoolean())
{
this.Progress = this.GetProgressInstance();
((ICustomSerializable)this.Progress).DeserializeInternal(br);
}
if (br.ReadBoolean())
{
this.Result = this.GetResultInstance();
((ICustomSerializable)this.Result).DeserializeInternal(br);
}
count = br.Read7BitEncodedInt();
this.ChildProcesses = new List <BizProcess>(count);
for (int i = 0; i < count; i++)
{
BizProcess process = this.ReadChildProcess(br);
this.AddChild(process);
}
BpRunningNode.Type brnType = (BpRunningNode.Type)br.ReadByte();
string brnName = br.ReadString();
this.Node = new BpRunningNode(brnType, brnName);
}
public override void Read(CustomBinaryReader reader, bool readData = true)
{
base.Read(reader, false);
if (readData)
{
ReadData(reader);
}
}
//This is called when this proxy acts as a reverse proxy (like a real http server)
//So for HTTPS requests we would start SSL negotiation right away without expecting a CONNECT request from client
private async Task HandleClient(TransparentProxyEndPoint endPoint, TcpClient tcpClient)
{
Stream clientStream = tcpClient.GetStream();
clientStream.ReadTimeout = ConnectionTimeOutSeconds * 1000;
clientStream.WriteTimeout = ConnectionTimeOutSeconds * 1000;
CustomBinaryReader clientStreamReader = null;
StreamWriter clientStreamWriter = null;
X509Certificate2 certificate = null;
if (endPoint.EnableSsl)
{
var sslStream = new SslStream(clientStream, true);
//implement in future once SNI supported by SSL stream, for now use the same certificate
certificate = certificateCacheManager.CreateCertificate(endPoint.GenericCertificateName, false);
try
{
//Successfully managed to authenticate the client using the fake certificate
await sslStream.AuthenticateAsServerAsync(certificate, false,
SslProtocols.Tls, false);
clientStreamReader = new CustomBinaryReader(sslStream);
clientStreamWriter = new StreamWriter(sslStream)
{
NewLine = ProxyConstants.NewLine
};
//HTTPS server created - we can now decrypt the client's traffic
}
catch (Exception)
{
sslStream.Dispose();
Dispose(sslStream, clientStreamReader, clientStreamWriter, null);
return;
}
clientStream = sslStream;
}
else
{
clientStreamReader = new CustomBinaryReader(clientStream);
clientStreamWriter = new StreamWriter(clientStream)
{
NewLine = ProxyConstants.NewLine
};
}
//now read the request line
var httpCmd = await clientStreamReader.ReadLineAsync();
//Now create the request
await HandleHttpSessionRequest(tcpClient, httpCmd, clientStream, clientStreamReader, clientStreamWriter,
endPoint.EnableSsl?endPoint.GenericCertificateName : null, endPoint, null);
}
public void Read(CustomBinaryReader reader)
{
gameParameterID = reader.ReadUInt32();
yType = reader.ReadUInt32();
unknownID = reader.ReadUInt32();
//_unknown = reader.ReadByte();
numPoints = reader.ReadByte();
_unknown2 = reader.ReadByte();
points = reader.ReadMany((r) => new Point(r), (ulong)numPoints);
}
internal static async Task ReadHeaders(CustomBinaryReader reader, HeaderCollection headerCollection)
{
string tmpLine;
while (!string.IsNullOrEmpty(tmpLine = await reader.ReadLineAsync()))
{
var header = tmpLine.Split(ProxyConstants.ColonSplit, 2);
headerCollection.AddHeader(header[0], header[1]);
}
}
/// <summary>
/// Десериализует процесс
/// </summary>
protected BizProcess(SerializationInfo info, StreamingContext context)
{
using (MemoryStream ms = new MemoryStream((byte[])info.GetValue("_", typeof(byte[]))))
{
using (CustomBinaryReader br = new CustomBinaryReader(ms))
{
this.DeserializeInternal(br);
}
}
}
// TODO: Populate Offset
public virtual void Read(CustomBinaryReader reader, bool readData = true)
{
Size = reader.ReadUInt32();
_startPosition = reader.Position;
ID = reader.ReadUInt32();
if (readData)
{
ReadData(reader);
}
}
public void Read(CustomBinaryReader reader)
{
header = reader.ReadBytes(4);
headerName = Encoding.UTF8.GetString(header);
size = reader.ReadUInt32();
long _startPosition = reader.Position;
count = reader.ReadInt32();
objects = new List <HIRCObject>();
long offset = reader.Position;
for (int i = 0; i < count; i++)
{
byte objType = reader.ReadByte();
HIRCObject tmp;
switch (objType)
{
case HIRCObject.TYPE_SOUNDSFXVOICE:
tmp = new SFXHIRCObject(reader, objType);
break;
case HIRCObject.TYPE_EVENT:
tmp = new EventHIRCObject(reader, objType);
break;
case HIRCObject.TYPE_MUSICSEGMENT:
tmp = new MusicSegmentHIRCObject(reader, objType);
break;
case HIRCObject.TYPE_MUSICTRACK:
tmp = new MusicTrackHIRCObject(reader, objType);
break;
case HIRCObject.TYPE_MUSICSWITCHCONTAINER:
tmp = new MusicSwitchContainerHIRCObject(reader, objType);
//tmp = new HIRCObject(reader, objType);
//File.WriteAllBytes("tempSwitchContainer.dat", tmp.Data);
break;
default:
tmp = new HIRCObject(reader, objType);
break;
}
tmp.Offset = offset.ToString("X");
offset = reader.Position;
objects.Add(tmp);
}
// Double check!
if (size - (reader.Position - _startPosition) != 0)
{
Console.WriteLine("Incorrect IO!");
}
}
/// <summary>
/// Handle dispose of a client/server session
/// </summary>
/// <param name="clientStream"></param>
/// <param name="clientStreamReader"></param>
/// <param name="clientStreamWriter"></param>
/// <param name="serverConnection"></param>
private void Dispose(CustomBufferedStream clientStream, CustomBinaryReader clientStreamReader, HttpResponseWriter clientStreamWriter, TcpConnection serverConnection)
{
clientStream?.Dispose();
clientStreamReader?.Dispose();
clientStreamWriter?.Dispose();
if (serverConnection != null)
{
serverConnection.Dispose();
UpdateServerConnectionCount(false);
}
}
public override void Read(CustomBinaryReader reader, bool readData = true)
{
base.Read(reader, false);
_unknown = reader.ReadUInt32();
State = reader.ReadUInt32();
IDAudio = reader.ReadUInt32();
IDSource = reader.ReadUInt32();
SoundType = reader.ReadByte();
if (readData)
{
ReadData(reader);
}
}
//This is called when requests are routed through router to this endpoint
//For ssl requests
private static void HandleClient(TransparentProxyEndPoint endPoint, TcpClient tcpClient)
{
Stream clientStream = tcpClient.GetStream();
CustomBinaryReader clientStreamReader = null;
StreamWriter clientStreamWriter = null;
X509Certificate2 certificate = null;
if (endPoint.EnableSsl)
{
var sslStream = new SslStream(clientStream, true);
//if(endPoint.UseServerNameIndication)
//{
// //implement in future once SNI supported by SSL stream
// certificate = CertManager.CreateCertificate(endPoint.GenericCertificateName);
//}
//else
certificate = CertManager.CreateCertificate(endPoint.GenericCertificateName);
try
{
//Successfully managed to authenticate the client using the fake certificate
sslStream.AuthenticateAsServer(certificate, false,
SslProtocols.Tls, false);
clientStreamReader = new CustomBinaryReader(sslStream, Encoding.ASCII);
clientStreamWriter = new StreamWriter(sslStream);
//HTTPS server created - we can now decrypt the client's traffic
}
catch (Exception)
{
if (sslStream != null)
{
sslStream.Dispose();
}
Dispose(tcpClient, sslStream, clientStreamReader, clientStreamWriter, null);
return;
}
clientStream = sslStream;
}
else
{
clientStreamReader = new CustomBinaryReader(clientStream, Encoding.ASCII);
}
var httpCmd = clientStreamReader.ReadLine();
//Now create the request
HandleHttpSessionRequest(tcpClient, httpCmd, clientStream, clientStreamReader, clientStreamWriter,
true);
}
public override void Read(CustomBinaryReader reader, bool readData = true)
{
base.Read(reader, false);
//EventCount = reader.ReadInt32();
//EventIDs = new List<int>();
//for (int i = 0; i < EventCount; i++)
//{
// EventIDs.Add(reader.ReadInt32());
//}
if (readData)
{
ReadData(reader);
}
}
/// <summary>
/// This is called when this proxy acts as a reverse proxy (like a real http server)
/// So for HTTPS requests we would start SSL negotiation right away without expecting a CONNECT request from client
/// </summary>
/// <param name="endPoint"></param>
/// <param name="tcpClient"></param>
/// <returns></returns>
private async Task HandleClient(TransparentProxyEndPoint endPoint, TcpClient tcpClient)
{
bool disposed = false;
var clientStream = new CustomBufferedStream(tcpClient.GetStream(), BufferSize);
CustomBinaryReader clientStreamReader = null;
HttpResponseWriter clientStreamWriter = null;
try
{
if (endPoint.EnableSsl)
{
var clientHelloInfo = await SslTools.PeekClientHello(clientStream);
if (clientHelloInfo != null)
{
var sslStream = new SslStream(clientStream);
clientStream = new CustomBufferedStream(sslStream, BufferSize);
string sniHostName = clientHelloInfo.GetServerName();
string certName = HttpHelper.GetWildCardDomainName(sniHostName ?? endPoint.GenericCertificateName);
var certificate = CertificateManager.CreateCertificate(certName, false);
//Successfully managed to authenticate the client using the fake certificate
await sslStream.AuthenticateAsServerAsync(certificate, false, SslProtocols.Tls, false);
}
//HTTPS server created - we can now decrypt the client's traffic
}
clientStreamReader = new CustomBinaryReader(clientStream, BufferSize);
clientStreamWriter = new HttpResponseWriter(clientStream, BufferSize);
//now read the request line
string httpCmd = await clientStreamReader.ReadLineAsync();
//Now create the request
disposed = await HandleHttpSessionRequest(tcpClient, httpCmd, clientStream, clientStreamReader, clientStreamWriter,
endPoint.EnableSsl?endPoint.GenericCertificateName : null, endPoint, null, true);
}
finally
{
if (!disposed)
{
Dispose(clientStream, clientStreamReader, clientStreamWriter, null);
}
}
}
/// <summary>
/// This is called when this proxy acts as a reverse proxy (like a real http server)
/// So for HTTPS requests we would start SSL negotiation right away without expecting a CONNECT request from client
/// </summary>
/// <param name="endPoint"></param>
/// <param name="tcpClient"></param>
/// <returns></returns>
private async Task HandleClient(TransparentProxyEndPoint endPoint, TcpClient tcpClient)
{
var clientStream = new CustomBufferedStream(tcpClient.GetStream(), BufferSize);
var clientStreamReader = new CustomBinaryReader(clientStream, BufferSize);
var clientStreamWriter = new HttpResponseWriter(clientStream, BufferSize);
try
{
if (endPoint.EnableSsl)
{
var clientHelloInfo = await SslTools.PeekClientHello(clientStream);
if (clientHelloInfo != null)
{
var sslStream = new SslStream(clientStream);
clientStream = new CustomBufferedStream(sslStream, BufferSize);
string sniHostName = clientHelloInfo.GetServerName() ?? endPoint.GenericCertificateName;
string certName = HttpHelper.GetWildCardDomainName(sniHostName);
var certificate = await CertificateManager.CreateCertificateAsync(certName);
try
{
//Successfully managed to authenticate the client using the fake certificate
await sslStream.AuthenticateAsServerAsync(certificate, false, SslProtocols.Tls, false);
}
catch (Exception e)
{
ExceptionFunc(new Exception($"Could'nt authenticate client '{sniHostName}' with fake certificate.", e));
return;
}
}
//HTTPS server created - we can now decrypt the client's traffic
}
//Now create the request
await HandleHttpSessionRequest(tcpClient, clientStream, clientStreamReader, clientStreamWriter,
endPoint.EnableSsl?endPoint.GenericCertificateName : null, endPoint, null, true);
}
finally
{
clientStreamReader.Dispose();
clientStream.Dispose();
}
}
public StringTableReader(Stream stream)
{
reader = new CustomBinaryReader(stream);
uint count = reader.ReadUInt32();
uint dataSize = reader.ReadUInt32();
long dataPosition = 8 + count * 8;
for (int i = 0; i < count; i++)
{
uint index = reader.ReadUInt32();
uint offset = reader.ReadUInt32();
table.Add(index, dataPosition + offset);
}
}
/// <summary>
/// This is called when this proxy acts as a reverse proxy (like a real http server)
/// So for HTTPS requests we would start SSL negotiation right away without expecting a CONNECT request from client
/// </summary>
/// <param name="endPoint"></param>
/// <param name="tcpClient"></param>
/// <returns></returns>
private async Task HandleClient(TransparentProxyEndPoint endPoint, TcpClient tcpClient)
{
bool disposed = false;
var clientStream = new CustomBufferedStream(tcpClient.GetStream(), BufferSize);
CustomBinaryReader clientStreamReader = null;
StreamWriter clientStreamWriter = null;
try
{
if (endPoint.EnableSsl)
{
var sslStream = new SslStream(clientStream);
clientStream = new CustomBufferedStream(sslStream, BufferSize);
//implement in future once SNI supported by SSL stream, for now use the same certificate
var certificate = CertificateManager.CreateCertificate(endPoint.GenericCertificateName, false);
//Successfully managed to authenticate the client using the fake certificate
await sslStream.AuthenticateAsServerAsync(certificate, false,
SslProtocols.Tls, false);
//HTTPS server created - we can now decrypt the client's traffic
}
clientStreamReader = new CustomBinaryReader(clientStream, BufferSize);
clientStreamWriter = new StreamWriter(clientStream)
{
NewLine = ProxyConstants.NewLine
};
//now read the request line
var httpCmd = await clientStreamReader.ReadLineAsync();
//Now create the request
disposed = await HandleHttpSessionRequest(tcpClient, httpCmd, clientStream, clientStreamReader, clientStreamWriter,
endPoint.EnableSsl?endPoint.GenericCertificateName : null, endPoint, null);
}
finally
{
if (!disposed)
{
Dispose(clientStream, clientStreamReader, clientStreamWriter, null);
}
}
}
/// <summary/>
protected BizProcess ReadChildProcess(CustomBinaryReader br)
{
bool optimized = br.ReadBoolean();
if (optimized)
{
string typeId = br.ReadString();
Type type = BizProcessHolder.Instance.GetType(typeId);
BizProcess childProcess = (BizProcess)Activator.CreateInstance(type, true);
childProcess.DeserializeInternal(br);
return(childProcess);
}
else
{
return(br.ReadObject <BizProcess>());
}
}
