/// <summary>
/// Receiveds the message.
/// </summary>
private void ReceivedMessage()
{
EventHandler <MessageBlockArgs> temp = OnReceivedMessageBlock;
if (temp != null)
{
temp(this, new MessageBlockArgs(Message));
}
//开始接收下一次的数据
messageBlock = new MessageBlock();
base.Buffer = Message.Head;
}
/// <summary>
/// Sends the specified mb.
/// </summary>
/// <param name="mb">The mb.</param>
public override void Send(MessageBlock mb)
{
if (!Session.IsBuildSecureConnection)
{
throw new NotBuildSecureConnectionException();
}
if (mb.Body != null && mb.BodyLength != 0) //对数据部分进行加密后再传输
{
byte[] cryptData = Session.SymmetricCryptService.Encrypt(mb.Body.ArraySegment);
mb = new MessageBlock(mb.Type, mb.Parameter, new DataBlock(cryptData));
}
base.Send(mb);
}
/// <summary>
/// 检查心跳的回调函数
/// </summary>
/// <param name="o">参数（未使用）</param>
protected override void CheckHeartBeatCallBack(object o)
{
//If client is on line, go on send heart Beat singal
if (IsConnected)
{
base.CheckHeartBeatCallBack(o);
}
if (IsConnected)//如果没有掉线，继续发送心跳信号
{
MessageBlock heartBeatMB = new MessageBlock(MessageBlockType.HeartBeat);
Send(heartBeatMB);
NetDebuger.PrintDebugMessage(Session, "Send Heart Beat");
}
}
/// <summary>
/// 发送消息，消息的内容会被加密传输
/// </summary>
/// <param name="session"></param>
/// <param name="msg"></param>
public override void Send(TSession session, MessageBlock msg)
{
if (!session.IsBuildSecureConnection)
{
throw new NotBuildSecureConnectionException();
}
if (msg.Body != null & msg.BodyLength != 0) //加密非空的消息数据
{
byte[] cryptData = session.SymmetricCryptService.Encrypt(msg.Body.ArraySegment);
msg = new MessageBlock(msg.Type, msg.Parameter, new DataBlock(cryptData));
}
base.Send(session, msg);
}
/// <summary>
/// Called when [received message block].
/// </summary>
/// <param name="session">The session.</param>
/// <param name="mb">The mb.</param>
protected override void OnReceivedMessageBlock(TSession session, MessageBlock mb)
{
switch (mb.Type)
{
case MessageBlockType.AppData:
{
if (!session.IsBuildSecureConnection)
{
throw new NotBuildSecureConnectionException();
}
byte[] data = session.SymmetricCryptService.Decrypt(mb.Body.ArraySegment);
OnReceivedData(session, new DataBlock(data));
break;
}
case MessageBlockType.Handshake:
{
HandleHandshake(session, (HandshakeType)mb.Parameter, mb);
break;
}
case MessageBlockType.CloseNotify:
{
session.Close();
break;
}
case MessageBlockType.Alert:
{
break;
}
case MessageBlockType.HeartBeat:
{
Debug.Assert(false); //已经在MessageServer中处理了，不会出现在这里
break;
}
}
}
/// <summary>
/// Called when [received message block].
/// </summary>
/// <param name="mb">The mb.</param>
protected override void OnReceivedMessageBlock(MessageBlock mb)
{
switch (mb.Type)
{
case MessageBlockType.Handshake:
HandleHandshakeType((HandshakeType)mb.Parameter, mb);
break;
case MessageBlockType.AppData:
if (!Session.IsBuildSecureConnection)
{
throw new NotBuildSecureConnectionException();
}
byte[] recvData = Session.SymmetricCryptService.Decrypt(mb.Body.ArraySegment);
OnReceivedData(new DataBlock(recvData));
break;
case MessageBlockType.HeartBeat:
Debug.Assert(false);
break;
}
}
/// <summary>
/// Sends the specified session.
/// </summary>
/// <param name="session">The session.</param>
/// <param name="mb">The mb.</param>
public virtual void Send(TSession session, MessageBlock mb)
{
base.Send(session, mb.ToDataBlock());
}
/// <summary>
/// Called when [received message block].
/// </summary>
/// <param name="session">The session.</param>
/// <param name="mb">The mb.</param>
protected virtual void OnReceivedMessageBlock(TSession session, MessageBlock mb)
{
OnReceivedData(session, mb.Body);
}
private void HandleHandshakeType(HandshakeType type, MessageBlock mb)
{
switch (type)
{
case HandshakeType.ServerHello:
{
NetDebuger.PrintDebugMessage(Session, "RECV ServerHello");
Session.CheckPrePhase(HandshakeType.ClientHello);
MessageBlock mb1 = new MessageBlock(MessageBlockType.Handshake,
(int)HandshakeType.ClientKeyExchange,
new DataBlock(Encoding.Unicode.GetBytes(key.PublicKey)));
base.Send(mb1);
Session.Handshake = HandshakeType.ClientKeyExchange;
NetDebuger.PrintDebugMessage(Session, "SEND ClientKeyExchange");
}
break;
case HandshakeType.ServerKeyExchange:
{
NetDebuger.PrintDebugMessage(Session, "RECV ServerKeyExchange");
Session.CheckPrePhase(HandshakeType.ClientKeyExchange);
Session.RemotePublicKey = Encoding.Unicode.GetString(mb.Body.Buffer);
//Get Crypt key data
byte[] keyData = Singleton <RSACryptServiceBase> .Instance.Encrypt
(Session.SymmetricCryptService.SA.Key, Session.RemotePublicKey);
//Send Client Symmetric key
MessageBlock skmb = new MessageBlock(MessageBlockType.Handshake,
(int)HandshakeType.ClientSymmetricKey,
new DataBlock(keyData));
base.Send(skmb);
Session.Handshake = HandshakeType.ClientSymmetricKey;
NetDebuger.PrintDebugMessage(Session, "SEND ClientSymmetricKey");
}
break;
case HandshakeType.ServerGetSymmetricKey:
{
NetDebuger.PrintDebugMessage(Session, "RECV ServerGetSymmetrickey");
Session.CheckPrePhase(HandshakeType.ClientSymmetricKey);
//Get crypt iv data
byte[] ivData = Singleton <RSACryptServiceBase> .Instance.Encrypt(
Session.SymmetricCryptService.SA.IV, Session.RemotePublicKey);
//Send Client Symmetric IV
MessageBlock ivmb = new MessageBlock(MessageBlockType.Handshake,
(int)HandshakeType.ClientSymmetricIV,
new DataBlock(ivData));
base.Send(ivmb);
Session.Handshake = HandshakeType.ClientSymmetricIV;
NetDebuger.PrintDebugMessage(Session, "SEND ClientSymmetricIV");
}
break;
case HandshakeType.ServerGetSymmetricIV:
{
NetDebuger.PrintDebugMessage(Session, "RECV ServerGetSymmetricIV");
Session.CheckPrePhase(HandshakeType.ClientSymmetricIV);
MessageBlock mb2 = new MessageBlock(MessageBlockType.Handshake,
(int)HandshakeType.ClientFinished);
base.Send(mb2);
Session.Handshake = HandshakeType.ClientFinished;
NetDebuger.PrintDebugMessage(Session, "SEND ClientFinished");
break;
}
case HandshakeType.ServerFinished:
{
Session.CheckPrePhase(HandshakeType.ClientFinished);
Session.Handshake = HandshakeType.OK;
NetDebuger.PrintDebugMessage(Session, "RECV ServerFinished. OK!");
isConnected = true;
StartHeartBeat();
//为了继续接收新数据，需要立刻返回，
//所以需要从新进程中调用OnBuildDataConnection();
buildConnThread = new Thread(OnBuildDataConnection);
buildConnThread.Start();
}
break;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageBlockArgs"/> class.
/// </summary>
/// <param name="messageBlock">The message block.</param>
public MessageBlockArgs(MessageBlock messageBlock)
{
this.messageBlock = messageBlock;
}
/// <summary>
/// Receiveds the message.
/// </summary>
private void ReceivedMessage()
{
EventHandler<MessageBlockArgs> temp = OnReceivedMessageBlock;
if (temp != null)
{
temp(this, new MessageBlockArgs(Message));
}
//��ʼ������һ�ε�����
messageBlock = new MessageBlock();
base.Buffer = Message.Head;
}
/// <summary>
/// Called when [received message block].
/// </summary>
/// <param name="mb">The mb.</param>
protected virtual void OnReceivedMessageBlock(MessageBlock mb)
{
OnReceivedData(mb.Body);
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageBlockArgs"/> class.
/// </summary>
/// <param name="messageBlock">The message block.</param>
public MessageBlockArgs(MessageBlock messageBlock)
{
this.messageBlock = messageBlock;
}
private void HandleHandshake(TSession session, HandshakeType handshakeType, MessageBlock mb)
{
switch (handshakeType)
{
case HandshakeType.ClientHello:
{
MessageBlock mb1 = new MessageBlock(MessageBlockType.Handshake,
(int)HandshakeType.ServerHello);
base.Send(session, mb1);
session.Handshake = HandshakeType.ServerHello;
NetDebuger.PrintDebugMessage(session, "ClientHello");
break;
}
case HandshakeType.ClientKeyExchange:
{
session.CheckPrePhase(HandshakeType.ServerHello);
session.RemotePublicKey = Encoding.Unicode.GetString(mb.Body.Buffer);
NetDebuger.PrintDebugMessage(session, "Client Public Key:" + session.RemotePublicKey);
MessageBlock mb2 = new MessageBlock(
MessageBlockType.Handshake,
(int)HandshakeType.ServerKeyExchange,
new DataBlock(Encoding.Unicode.GetBytes(key.PublicKey)));
base.Send(session, mb2);
session.Handshake = HandshakeType.ServerKeyExchange;
NetDebuger.PrintDebugMessage(session, "ClientKeyExchange");
break;
}
case HandshakeType.ClientSymmetricKey:
{
session.CheckPrePhase(HandshakeType.ServerKeyExchange);
byte[] key = Singleton <RSACryptServiceBase> .Instance.Decrypt(
mb.Body.Buffer, this.key.XmlString);
session.SymmetricCryptService.SA.Key = key;
NetDebuger.PrintDebugMessage(session, "Client SA Key:" + Convert.ToBase64String(key));
MessageBlock getKeymb = new MessageBlock(MessageBlockType.Handshake,
(int)HandshakeType.ServerGetSymmetricKey);
base.Send(session, getKeymb);
session.Handshake = HandshakeType.ServerGetSymmetricKey;
NetDebuger.PrintDebugMessage(session, "ClientSymmetrickey");
break;
}
case HandshakeType.ClientSymmetricIV:
{
session.CheckPrePhase(HandshakeType.ServerGetSymmetricKey);
byte[] iv = Singleton <RSACryptServiceBase> .Instance.Decrypt(
mb.Body.Buffer, this.key.XmlString);
session.SymmetricCryptService.SA.IV = iv;
NetDebuger.PrintDebugMessage(session, "Client SA IV:" + Convert.ToBase64String(iv));
MessageBlock getIVmb = new MessageBlock(MessageBlockType.Handshake,
(int)HandshakeType.ServerGetSymmetricIV);
base.Send(session, getIVmb);
session.Handshake = HandshakeType.ServerGetSymmetricIV;
NetDebuger.PrintDebugMessage(session, "ClientSymmetricIV");
break;
}
case HandshakeType.ClientFinished:
{
session.CheckPrePhase(HandshakeType.ServerGetSymmetricIV);
MessageBlock mb3 = new MessageBlock(MessageBlockType.Handshake,
(int)HandshakeType.ServerFinished);
base.Send(session, mb3);
session.Handshake = HandshakeType.OK;
NetDebuger.PrintDebugMessage(session, "Client Handshake Finished");
OnBuildDataConnection(session);
NetDebuger.PrintDebugMessage(session, "Build security community channel");
break;
}
}
}
/// <summary>
/// Sends the specified mb.
/// </summary>
/// <param name="mb">The mb.</param>
public virtual void Send(MessageBlock mb)
{
base.Send(mb.ToDataBlock());
}
/// <summary>
/// 修改Base类的定义。
/// </summary>
protected override void OnCreate()
{
messageBlock = new MessageBlock();
base.Buffer = messageBlock.Head;
}
/// <summary>
/// ��Base��Ķ��塣
/// </summary>
protected override void OnCreate()
{
messageBlock = new MessageBlock();
base.Buffer = messageBlock.Head;
}
