private static void ReadUnsignedVarint(
Stream stream,
Bcp.ReadState readState,
ProcessReadVarint processReadVarint,
BcpDelegate.ExceptionHandler exceptionHandler)
{
var buffer = new byte[1];
var i = 0;
uint result = 0U;
AsyncCallback asyncCallback = null;
asyncCallback = asyncResult =>
{
try
{
int numBytesRead = stream.EndRead(asyncResult);
if (numBytesRead != 1)
{
exceptionHandler(new EndOfStreamException());
}
uint b = buffer[0];
if (i < 32)
{
if (b >= 0x80)
{
result |= ((b & 0x7f) << i);
i += 7;
stream.BeginRead(buffer, 0, 1, asyncCallback, readState);
}
else
{
result |= (b << i);
processReadVarint(result);
}
}
else
{
exceptionHandler(new BcpException.VarintTooBig());
}
}
catch (Exception e)
{
exceptionHandler(e);
}
};
try
{
stream.BeginRead(buffer, 0, 1, asyncCallback, readState);
}
catch (Exception e)
{
exceptionHandler(e);
}
}
private static void ReadAll(
Stream stream,
Bcp.ReadState readState,
byte[] buffer,
int offset,
int count,
ProcessReadAll processReadAll,
BcpDelegate.ExceptionHandler exceptionHandler)
{
AsyncCallback asyncCallback = null;
asyncCallback = asyncResult =>
{
try
{
int numBytesRead = stream.EndRead(asyncResult);
if (numBytesRead == 0)
{
exceptionHandler(new EndOfStreamException());
}
else
{
offset += numBytesRead;
if (offset < count)
{
stream.BeginRead(buffer, offset, count, asyncCallback, readState);
}
else
{
processReadAll();
}
}
}
catch (Exception e)
{
exceptionHandler(e);
}
};
try
{
stream.BeginRead(buffer, offset, count, asyncCallback, readState);
}
catch (Exception e)
{
exceptionHandler(e);
}
}
protected void AddIncomingSocket(Stream stream)
{
BcpDelegate.ProcessReadHead processReadHead = delegate(Bcp.ConnectionHead connectionHead)
{
var sessionId = connectionHead.SessionId;
string sessionKey = Convert.ToBase64String(sessionId);
var connectionId = connectionHead.ConnectionId;
Debug.WriteLine("BcpServer add incomming socket, sessionId: " + sessionId + ", connectionId: " + connectionId);
lock (serverLock)
{
BcpServer.Session session;
if (sessions.TryGetValue(sessionKey, out session))
{
}
else
{
session = NewSession(sessionId);
sessions.Add(sessionKey, session);
session.RaiseAccepted();
}
if (connectionHead.IsRenew)
{
session.RenewSession();
}
session.AddStream(connectionId, stream);
Debug.WriteLine("Server added stream!");
}
};
BcpDelegate.ExceptionHandler exceptionHandler = delegate(Exception e)
{
Debug.WriteLine("BcpServer add incomming stream exception: " + e.Message);
};
TimerCallback readTimeoutCallback = delegate(Object source)
{
stream.Dispose();
exceptionHandler(new Exception());
};
Bcp.ReadState readState = new Bcp.ReadState();
readState.readTimeoutTimer = new Timer(readTimeoutCallback, null, Bcp.ReadingTimeoutMilliseconds, Bcp.ReadingTimeoutMilliseconds);
BcpIO.ReadHead(stream, readState, processReadHead, exceptionHandler);
}
public static void ReadHead(Stream stream,
Bcp.ReadState readState,
BcpDelegate.ProcessReadHead processReadHead,
BcpDelegate.ExceptionHandler exceptionHandler)
{
var sessionId = new byte[Bcp.NumBytesSessionId];
ProcessReadAll processReadAll = delegate()
{
ProcessReadVarint processReadIsRenew = delegate(uint isRenew)
{
ProcessReadVarint processReadConnectionId = delegate(uint connectionId)
{
readState.Cancel();
processReadHead(new Bcp.ConnectionHead(sessionId, Convert.ToBoolean(isRenew), connectionId));
};
ReadUnsignedVarint(stream, readState, processReadConnectionId, exceptionHandler);
};
ReadUnsignedVarint(stream, readState, processReadIsRenew, exceptionHandler);
};
ReadAll(stream, readState, sessionId, 0, Bcp.NumBytesSessionId, processReadAll, exceptionHandler);
}
public static void Read(Stream stream, Bcp.ReadState readState, BcpDelegate.ProcessRead processRead, BcpDelegate.ExceptionHandler exceptionHandler)
{
var headBuffer = new byte[1];
AsyncCallback asyncCallback = null;
asyncCallback = asyncResult =>
{
try
{
int numBytesRead = stream.EndRead(asyncResult);
if (numBytesRead != 1)
{
throw new EndOfStreamException();
}
switch (headBuffer[0])
{
case Bcp.Data.HeadByte:
{
ProcessReadVarint processReadLength = delegate(uint length)
{
if (length > Bcp.MaxDataSize)
{
throw new BcpException.DataTooBig();
}
var buffer = new byte[length];
ProcessReadAll processReadAll = delegate()
{
processRead(new Bcp.Data(new[] { (new ArraySegment <byte>(buffer)) }));
};
ReadAll(stream, readState, buffer, 0, (int)length, processReadAll, exceptionHandler);
};
ReadUnsignedVarint(stream, readState, processReadLength, exceptionHandler);
break;
}
case Bcp.RetransmissionData.HeadByte:
{
ProcessReadVarint processReadConnectionId = delegate(uint connectionId)
{
ProcessReadVarint processReadPackId = delegate(uint packId)
{
ProcessReadVarint processReadLength = delegate(uint length)
{
if (length > Bcp.MaxDataSize)
{
throw new BcpException.DataTooBig();
}
var buffer = new byte[length];
ProcessReadAll processReadAll = delegate()
{
processRead(new Bcp.RetransmissionData(connectionId, packId, new[] { (new ArraySegment <byte>(buffer)) }));
};
ReadAll(stream, readState, buffer, 0, (int)length, processReadAll, exceptionHandler);
};
ReadUnsignedVarint(stream, readState, processReadLength, exceptionHandler);
};
ReadUnsignedVarint(stream, readState, processReadPackId, exceptionHandler);
};
ReadUnsignedVarint(stream, readState, processReadConnectionId, exceptionHandler);
break;
}
case Bcp.RetransmissionFinish.HeadByte:
{
ProcessReadVarint processReadConnectionId = delegate(uint connectionId)
{
ProcessReadVarint processReadPackId = delegate(uint packId)
{
processRead(new Bcp.RetransmissionFinish(connectionId, packId));
};
ReadUnsignedVarint(stream, readState, processReadPackId, exceptionHandler);
};
ReadUnsignedVarint(stream, readState, processReadConnectionId, exceptionHandler);
break;
}
case Bcp.Acknowledge.HeadByte:
processRead(new Bcp.Acknowledge());
break;
case Bcp.Finish.HeadByte:
processRead(new Bcp.Finish());
break;
case Bcp.ShutDown.HeadByte:
processRead(new Bcp.ShutDown());
break;
case Bcp.HeartBeat.HeadByte:
processRead(new Bcp.HeartBeat());
break;
default:
throw new BcpException.UnknownHeadByte();
}
}
catch (Exception e)
{
exceptionHandler(e);
}
};
try
{
stream.BeginRead(headBuffer, 0, 1, asyncCallback, readState);
}
catch (Exception e)
{
exceptionHandler(e);
}
}
protected void AddIncomingSocket(Stream stream)
{
BcpDelegate.ProcessReadHead processReadHead = delegate(Bcp.ConnectionHead connectionHead)
{
var sessionId = connectionHead.SessionId;
string sessionKey = Convert.ToBase64String(sessionId);
var connectionId = connectionHead.ConnectionId;
Debug.WriteLine("BcpServer add incomming socket, sessionId: " + sessionId + ", connectionId: " + connectionId);
lock (serverLock)
{
BcpServer.Session session;
if (sessions.TryGetValue(sessionKey, out session))
{
}
else
{
session = NewSession(sessionId);
sessions.Add(sessionKey, session);
session.RaiseAccepted();
}
if (connectionHead.IsRenew)
{
session.RenewSession();
}
session.AddStream(connectionId, stream);
Debug.WriteLine("Server added stream!");
}
};
BcpDelegate.ExceptionHandler exceptionHandler = delegate(Exception e)
{
Debug.WriteLine("BcpServer add incomming stream exception: " + e.Message);
};
TimerCallback readTimeoutCallback = delegate(Object source)
{
stream.Dispose();
exceptionHandler(new Exception());
};
Bcp.ReadState readState = new Bcp.ReadState();
readState.readTimeoutTimer = new Timer(readTimeoutCallback, null, Bcp.ReadingTimeoutMilliseconds, Bcp.ReadingTimeoutMilliseconds);
BcpIO.ReadHead(stream, readState, processReadHead, exceptionHandler);
}