private bool Acknowledge(
SocketService socketService,
SendOption sendOption,
PacketHead packetHead,
IWriteStream writeStream = null)
{
if (socketService == null)
{
Logger.Error($"{nameof(socketService)} 为 null ！");
return(false);
}
var fragment = writeStream?.ToByteFragment();
packetHead.Length = fragment.HasValue ? (ushort)(PacketHead.GetSize() + fragment?.Count) : (ushort)PacketHead.GetSize();
packetHead.SendOption = sendOption;
var ws = PoolAllocator <IWriteStream> .GetObject();
if (writeStream != null)
{
ws.ShiftRight(writeStream.ToByteFragment());
}
Packet.ToBytes(packetHead, ws);
var byteSegment = ws.ToByteFragment();
var result = StartWrite(socketService, byteSegment.Buffer, byteSegment.Offset, byteSegment.Count, ws, true);
SocketStatistics.LogUnreliableSend();
SocketStatistics.LogTotalBytesSent(packetHead.Length);
return(true);
}
/// <summary>
/// Tcp客户端连接断开，通知业务层
/// </summary>
/// <param name="sender"></param>
/// <param name="clientPoint"></param>
public void OnTcpClientClosed(object sender, EndPoint clientPoint)
{
var token = ClientConnectManager.GetToken(clientPoint.ToString());
PacketHead head = new PacketHead(ConnectType.Tcp, PacketMsgType.Closed);
head.GameId = token.GameId;
head.ServerId = token.ServerId;
head.Uid = token.Uid;
var session = GameSessionManager.GetSession(head.GameId, head.ServerId);
if (session == null)
{
return;
}
head.Address = session.GameAddress;
head.EnableGzip = false;
PacketMessage packet = new PacketMessage();
packet.Head = head;
packet.Content = new byte[0];
if (CheckConnected(head.Address))
{
OnSendToGame(head.Address, packet.ToByte());
}
}
private void AcknowledgeConnect(IPEndPoint endPoint, IReadStream readStream,
PacketHead packetHead)
{
if (_connections.ContainsKey(endPoint))
{
Logger.Warn($"{endPoint}已经连接，无需重复连接！");
return;
}
var service = new SocketService();
service.Connection.RemoteAddress = endPoint;
service.Connection.LocalAddress = _writer.Client.LocalEndPoint as IPEndPoint;
if (_connections.TryAdd(endPoint, service))
{
_autoResetEvent.Set();
UdpKeepAlive.AddConnection(service,
() => HandleReconnect?.Invoke(service, true),
() => {
HandleReconnect?.Invoke(service, false);
OnDisconnect(service);
});
HandleConnect?.Invoke(service, readStream);
Logger.Info($"{endPoint}连接成功！");
}
else
{
Logger.Error($"添加连接{endPoint}失败!");
}
}
private void ResponseConnect(EndPoint endPoint, IReadStream readStream, PacketHead packetHead)
{
if (_connections.TryGetValue(endPoint, out var socketService))
{
Logger.Warn($"已经存在连接{endPoint}!无需重复连接");
Acknowledge(socketService, SendOption.Acknowledge | SendOption.Connect, packetHead);
return;
}
var service = PoolAllocator <SocketService> .GetObject();
service.Connection.RemoteAddress = endPoint;
if (_connections.TryAdd(endPoint, service))
{
using (var writeStream = PoolAllocator <IWriteStream> .GetObject()) {
HandleAccept?.Invoke(service, readStream, writeStream);
var byteSegment = writeStream.ToByteFragment();
Acknowledge(service, SendOption.Acknowledge | SendOption.Connect, packetHead, writeStream);
SocketStatistics.LogAcknowledgementSend();
SocketStatistics.LogUnreliableReceive();
SocketStatistics.LogDataBytesReceived(byteSegment.Count);
SocketStatistics.LogTotalBytesReceived(writeStream.ToByteFragment().Count);
}
Logger.Info($"创建{endPoint}连接心跳包！");
}
else
{
Logger.Error($"添加连接{endPoint}失败!");
}
}
/// <summary>
/// 转发常规数据包
/// </summary>
/// <param name="packetInfo"></param>
/// <returns></returns>
public static void TranNormalPacket(PacketInfo packetInfo)
{
byte[] packetByte = packetInfo.GetPacketByte();
PacketEntity packetEntity = (PacketEntity)Util.BytesToObject(packetByte);
string srcIP = packetEntity.GetHead().strSrcIP;
string desIP = packetEntity.GetHead().strDesIP;
Const.EN_RET_CODE retVal = Const.EN_RET_CODE.EN_RET_INIT;
int tranPort = Const.INVALID_NUM;
//流表中存在转发选项，直接转发
if (FlowTable.GetInstance().TryGetItem(desIP, out tranPort))
{
retVal = Transmitter.SendViaPhyPort(tranPort, packetByte);
if (Const.EN_RET_CODE.EN_RET_SUCC != retVal)
{
Util.Log(Util.EN_LOG_LEVEL.EN_LOG_INFO, "数据包转发失败");
}
}
//流表中不存在转发选项，将数据包暂存缓冲区，上报控制器
else
{
Program.BufferQueue.Enqueue(packetInfo);
PacketHead head = new PacketHead(srcIP, desIP, PacketHead.EN_PACKET_TYPE.EN_PACKET_IN);
PacketEntity packetIn = new PacketEntity(head, "");
retVal = Transmitter.SendViaPhyPort(0, Util.ObjectToBytes(packetIn));
if (retVal != Const.EN_RET_CODE.EN_RET_SUCC)
{
Util.Log(Util.EN_LOG_LEVEL.EN_LOG_INFO, "packet_in发送失败");
}
}
}
protected PacketMessage ParsePacketMessage(string clientAddress, string paramString, ConnectType connectType)
{
ParamGeter paramGeter = new ParamGeter(paramString);
PacketHead head = new PacketHead(connectType, PacketMsgType.Request);
head.Address = clientAddress;
head.MsgId = paramGeter.GetInt("msgid");
head.Uid = paramGeter.GetInt("uid");
head.ActionId = paramGeter.GetInt("actionId");
string[] sidArray = paramGeter.GetString("sid").Split('|');
if (sidArray.Length > 2)
{
head.GameId = sidArray[1].ToInt();
head.ServerId = sidArray[2].ToInt();
}
else
{
head.GameId = paramGeter.GetInt("gametype");
head.ServerId = paramGeter.GetInt("serverid");
}
head.EnableGzip = false;
PacketMessage packet = new PacketMessage();
packet.Head = head;
packet.Content = BufferUtils.GetBytes(paramString);
return(packet);
}
/// <summary>
/// 反序列化字节序为消息头结构信息，该消息必需为原始数据包(不需要反转义和校验的数据包)
/// </summary>
/// <param name="buffer"></param>
/// <param name="pos">解析的位置,初始化为1开始</param>
/// <returns></returns>
public PacketHead DecodeRawHead(byte[] buffer, ref int pos)
{
PacketHead headInfo = new PacketHead();
//获取消息ID
headInfo.phMessageId = buffer.ToUInt16(pos);
//获取消息体属性
UInt16 attr = buffer.ToUInt16(pos += 2);
headInfo.phPacketHeadAttribute = PakcetAttributeDecode(attr);
//获取电话号码
buffer.CopyTo(pos += 2, headInfo.hSimNumber, 0, 6);
//获取消息流水号
headInfo.phSerialnumber = buffer.ToUInt16(pos += 6);
//消息包封装项
if (headInfo.phPacketHeadAttribute.paSubFlag == 1)
{
headInfo.phPackeHeadTag = new PacketTag()
{
ptTotal = buffer.ToUInt16(pos += 2),
ptSerialnumber = buffer.ToUInt16(pos += 2)
};
}
pos += 2;
return(headInfo);
}
private void AcknowledgeConnect(EndPoint endPoint, IReadStream readStream, PacketHead packetHead)
{
if (_connections.ContainsKey(endPoint))
{
Logger.Warn($"{endPoint}已经连接，无需重复连接！");
return;
}
var service = PoolAllocator <SocketService> .GetObject();
service.Connection.RemoteAddress = endPoint;
service.Connection.LocalAddress = _readSocket.LocalEndPoint as IPEndPoint;
if (_connections.TryAdd(endPoint, service))
{
CreateAck(service);
HandleConnect?.Invoke(service, readStream);
SocketStatistics.LogUnreliableReceive();
SocketStatistics.LogAcknowledgementReceive();
SocketStatistics.LogDataBytesReceived(packetHead.TotalBytes);
SocketStatistics.LogTotalBytesReceived(packetHead.Length);
Logger.Info($"{endPoint}连接成功！");
}
else
{
Logger.Error($"添加连接{endPoint}失败!");
}
}
/// <summary>
/// 交换机程序启动
/// </summary>
public static void Start()
{
////测试
//if (Program.iCurSwitchID == 0)
//{
// int temp = 0;
// while (++temp < 10)
// {
// PacketEntity packet = new PacketEntity(new PacketHead("1.1.1.1", "2.2.2.2", PacketHead.EN_PACKET_TYPE.EN_NORMAL_PACKET), "Lancer");
// byte[] buffer = Util.ObjectToBytes(packet);
// Transmitter.SendViaPhyPort(1, buffer);
// Transmitter.SendViaPhyPort(2, buffer);
// Transmitter.SendViaPhyPort(0, buffer);
// Console.WriteLine("发送完成");
// Thread.Sleep(1000);
// }
//}
PacketInfo packetInfo = null;
bool firstLoop = true;
Const.EN_RET_CODE retVal = Const.EN_RET_CODE.EN_RET_INIT;
while (true)
{
if (firstLoop)
{
//发送初始化完成信息给控制器
PacketHead head = new PacketHead("", "", PacketHead.EN_PACKET_TYPE.EN_SWITCH_ONLINE);
PacketEntity packet = new PacketEntity(head, "");
retVal = Transmitter.SendViaPhyPort(0, Util.ObjectToBytes(packet));
if (Const.EN_RET_CODE.EN_RET_SUCC != retVal)
{
//TODO
Util.Log(Util.EN_LOG_LEVEL.EN_LOG_FATAL, "初始化完成信息发送失败");
}
firstLoop = false;
}
packetInfo = null;
//P操作
Program.PktQueueMutex.WaitOne();
//消息队列为空，进行V操作之后继续循环读队列
if (Program.PacketQueue.Count == 0)
{
Program.PktQueueMutex.ReleaseMutex();
continue;
}
//消息队列不为空，消息包出队后进行V操作
packetInfo = Program.PacketQueue.Dequeue();
Program.PktQueueMutex.ReleaseMutex();
//处理接收到的消息
DealReceivePacket(packetInfo);
}
}
private void AcknowledgeDisconnect(IPEndPoint endPoint, IReadStream readStream,
PacketHead packetHead)
{
if (!_connections.TryGetValue(endPoint, out var socketService))
{
Logger.Error($"{endPoint}连接没有添加！");
return;
}
OnDisconnect(socketService);
Logger.Info($"应答{endPoint}主动断开连接！");
}
private void ResponseDisconnect(IPEndPoint endPoint, IReadStream readStream,
PacketHead packetHead)
{
if (!_connections.TryGetValue(endPoint, out var socketService))
{
Logger.Warn("断开没有记录的连接？");
return;
}
Logger.Info($"{endPoint}主动断开！");
Acknowledge(socketService, SendOption.Acknowledge | SendOption.Disconnect, packetHead);
OnDisconnect(socketService);
}
private void AcknowledgeDisonnect(EndPoint endPoint, IReadStream readStream, PacketHead packetHead)
{
if (!_connections.TryGetValue(endPoint, out var socketService))
{
Logger.Error($"{endPoint}连接没有添加！");
return;
}
OnDisconnect(socketService);
SocketStatistics.LogUnreliableReceive();
SocketStatistics.LogAcknowledgementReceive();
SocketStatistics.LogDataBytesReceived(packetHead.TotalBytes);
SocketStatistics.LogTotalBytesReceived(packetHead.Length);
Logger.Info($"应答{endPoint}主动断开连接！");
}
private void ResponseAck(EndPoint endPoint, IReadStream readStream, PacketHead packetHead)
{
if (!_connections.TryGetValue(endPoint, out var socketService))
{
Logger.Error($"{endPoint}连接没有添加！");
return;
}
Logger.Info($"接收到{endPoint}心跳包！");
Acknowledge(socketService, SendOption.Acknowledge | SendOption.Ack, packetHead);
SocketStatistics.LogAcknowledgementSend();
SocketStatistics.LogUnreliableReceive();
SocketStatistics.LogAcknowledgementSend();
SocketStatistics.LogAckReceive();
SocketStatistics.LogTotalBytesReceived(PacketHead.GetSize());
}
private void ResponseDisconnect(EndPoint endPoint, IReadStream readStream, PacketHead packetHead)
{
if (!_connections.TryGetValue(endPoint, out var socketService))
{
Logger.Warn("断开没有记录的连接？");
return;
}
Logger.Info($"{endPoint}主动断开！");
Acknowledge(socketService, SendOption.Acknowledge | SendOption.Disconnect, packetHead);
SocketStatistics.LogAcknowledgementSend();
SocketStatistics.LogUnreliableReceive();
SocketStatistics.LogTotalBytesReceived(PacketHead.GetSize());
OnDisconnect(socketService);
}
private void Send1_Click(object sender, EventArgs e)
{
try
{
this.CreateClientSocket();
string sServerIP = tbServerIP.Text;
int iServerPort = Convert.ToInt32(tbServerPort.Text);
_ClientSocket.Connect(sServerIP, iServerPort, _logClient);
if (!_ClientSocket.IsConnected())
{
MessageBox.Show("Cannot connect to server 127.0.0.1:6000");
return;
}
// Command 1
cltCommandSendData.DecodePackage(tbcPackage1.Text);
PacketHead ph = cltCommandSendData.PacketHead;
ph.SourceIP = _ClientSocket.LocalIP;
ph.SourcePort = _ClientSocket.LocalPort;
cltCommandSendData.PacketHead = ph;
string result = _ClientSocket.SendMsg(cltCommandSendData.EncodePackage());
if (result == null)
{
MessageBox.Show("Cannot receive any response data!");
}
else
{
cpkg2 = result;
}
_ClientSocket.DisConnect(false);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private void AcknowledgeFragment(IPEndPoint endPoint, IReadStream readStream,
PacketHead packetHead)
{
if (!_connections.TryGetValue(endPoint, out var socketService))
{
Logger.Error($"{endPoint}连接没有添加！");
return;
}
var id = BuildID(packetHead);
if (!(_fragmentsTimer.Remove(id) && socketService.PacketIds.Remove(id)))
{
return;
}
socketService.OnAcknowledge(true, readStream);
Logger.Info($"{endPoint}：{packetHead.PacketId}消息发送完成！");
}
private string OnDataReceived(string package)
{
try
{
if (svrCommandSendData.DecodePackage(package))
{
//tbsPackage1.Text = System.Text.Encoding.UTF8.GetString(package);
spkg1 = package;
_logServer.Write(LogType.Debug, "spkg1=" + spkg1, true);
//byte[] respSend = System.Text.Encoding.UTF8.GetBytes(tbsPackage2.Text);
//result = new byte[CommandBase.PackageHeadLength + respSend.Length];
svrCommandRespSendData.CommandGUID = svrCommandSendData.CommandGUID;
PacketHead ph = svrCommandSendData.PacketHead;;
ph.PacketType = CommandRespSendData.PacketType;
svrCommandRespSendData.PacketHead = ph;
svrCommandRespSendData.SendResult = "1";
return(svrCommandRespSendData.EncodePackage());
}
if (svrCommandGetResult.DecodePackage(package))
{
//tbsPackage4.Text = System.Text.Encoding.UTF8.GetString(package);
spkg4 = package;
//byte[] respSend = System.Text.Encoding.UTF8.GetBytes(tbsPackage2.Text);
//result = new byte[CommandBase.PackageHeadLength + respSend.Length];
svrCommandRespGetResult.CommandGUID = svrCommandGetResult.CommandGUID;
PacketHead ph = svrCommandGetResult.PacketHead;
ph.PacketType = CommandGetResult.PacketType;
svrCommandRespGetResult.PacketHead = ph;
svrCommandRespGetResult.Result = "3";
return(svrCommandRespGetResult.EncodePackage());
}
return(null);
}
catch (Exception ex)
{
_logServer.Write(ex);
return(null);
}
}
/// <summary>
/// 处理命令字符串
/// </summary>
/// <param name="cmdStr"></param>
/// <returns></returns>
public static Const.EN_RET_CODE DealCommandStr(string cmdStr)
{
//分割命令
string[] cmdArry = System.Text.RegularExpressions.Regex.Split(cmdStr, @"[ ]+");
//foreach (string i in cmdStrArry)
//{
// Console.WriteLine(i);
//}
switch (cmdArry[0])
{
case "send":
//命令参数个数不正确
if (cmdArry.Length != 3)
{
Util.Log(Util.EN_LOG_LEVEL.EN_LOG_INFO, "命令参数个数不正确");
return(Const.EN_RET_CODE.EN_RET_CMD_PARA_INVALID);
}
try
{
IPAddress.Parse(cmdArry[1]);
}
catch (Exception)
{
Util.Log(Util.EN_LOG_LEVEL.EN_LOG_INFO, "不是有效的IP地址");
return(Const.EN_RET_CODE.EN_RET_CMD_IP_INVALID);
}
PacketHead packetHead = new PacketHead(Program.strCurHostIP, cmdArry[1], PacketHead.EN_PACKET_TYPE.EN_NORMAL_PACKET);
PacketEntity packetEntity = new PacketEntity(packetHead, cmdArry[2]);
Transmitter.Send(Util.ObjectToBytes(packetEntity));
break;
//命令不正确
default:
Util.Log(Util.EN_LOG_LEVEL.EN_LOG_INFO, "无效命令" + "\"" + cmdArry[0] + "\"");
return(Const.EN_RET_CODE.EN_RET_CMD_INVALID);
}
return(Const.EN_RET_CODE.EN_RET_SUCC);
}
private void ResponseAck(IPEndPoint endPoint, IReadStream readStream,
PacketHead packetHead)
{
if (!_connections.TryGetValue(endPoint, out var socketService))
{
Logger.Error($"{endPoint}连接没有添加！");
return;
}
Logger.Info($"接收到{endPoint}心跳包！");
Acknowledge(socketService, SendOption.Acknowledge | SendOption.Ack, packetHead);
if (socketService.ReconnectCount > 0)
{
Logger.Debug("关闭重连：" + socketService.ReconnectCount);
HandleReconnect?.Invoke(socketService, false);
}
UdpKeepAlive.Reset(socketService);
}
public byte[] CoalitionInfo()
{
//PacketHead
PacketHead pPacketHead = new PacketHead(this.eCategory, this._eService);
byte[] pHeadBuffer = pPacketHead.CoalitionInfo();
//Result
if (PacketConstant.MAX_PACKETHEAD_SIZE != pHeadBuffer.Length)
{
throw new ArgumentException("报头长度与定义不符合！");
}
//PacketData
byte[] pDataBuffer = this._pSocketData.CoalitionInfo(0);
byte[] pResultBuffer = new byte[pHeadBuffer.Length + pDataBuffer.Length];
Array.Copy(pHeadBuffer, 0, pResultBuffer, 0, PacketConstant.MAX_PACKETHEAD_SIZE);
Array.Copy(pDataBuffer, 0, pResultBuffer, PacketConstant.MAX_PACKETHEAD_SIZE, pDataBuffer.Length);
return(pResultBuffer);
}
/// <summary>
/// 发送数据
/// </summary>
private bool Write(SocketService socketService, ulong messageId, SendOption sendOption)
{
using (var writeStream = PoolAllocator <IWriteStream> .GetObject()) {
var packetHead = new PacketHead {
Length = (ushort)PacketHead.GetSize(),
PacketId = messageId,
SendOption = sendOption,
TotalBytes = 0,
FragmentId = 0,
TotalFragments = 1
};
Packet.ToBytes(packetHead, writeStream);
var byteFragment = writeStream.ToByteFragment();
var result = _writer.Client.SendTo(byteFragment.Buffer, byteFragment.Offset, byteFragment.Count, SocketFlags.None,
socketService.Connection.RemoteAddress);
socketService.OnWrite(result == byteFragment.Count);
return(result == byteFragment.Count);
}
}
private string SendMsgToServer(CommandSendData csd)
{
try
{
_ClientSocket.Connect();
PacketHead ph = csd.PacketHead;
//ph.SourceIP = _ClientSocket.LocalIP;
//ph.SourcePort = _ClientSocket.LocalPort;
csd.PacketHead = ph;
string result = _ClientSocket.SendMsg(csd.EncodePackage());
_ClientSocket.DisConnect(false);
return(result);
}
catch (Exception ex)
{
Program.Log.Write(ex);
return(null);
}
}
/// <summary>
/// 处理交换机上线消息
/// </summary>
/// <param name=""></param>
public static void DealSwitchOnlinePacket(PacketInfo packetInfo)
{
byte[] packetByte = packetInfo.GetPacketByte();
int iPhyPortNo = packetInfo.GetPhyPort();
PacketEntity packet = (PacketEntity)Util.BytesToObject(packetByte);
string content = packet.GetStrContent();
string srcIP = packet.GetHead().strSrcIP;
string desIP = packet.GetHead().strDesIP;
Const.EN_RET_CODE retVal = Const.EN_RET_CODE.EN_RET_INIT;
Util.Log(Util.EN_LOG_LEVEL.EN_LOG_INFO, "交换机" + iPhyPortNo + "上线");
//回复上线消息
PacketHead head = new PacketHead("", "", PacketHead.EN_PACKET_TYPE.EN_ACK_SWITCH_ONLINE);
PacketEntity ackPakcet = new PacketEntity(head, "");
retVal = Transmitter.SendViaPhyPort(iPhyPortNo, Util.ObjectToBytes(ackPakcet));
if (Const.EN_RET_CODE.EN_RET_SUCC != retVal)
{
Util.Log(Util.EN_LOG_LEVEL.EN_LOG_FATAL, "交换机上线ACK发送失败");
}
}
private bool Acknowledge(
SocketService socketService,
SendOption sendOption,
PacketHead packetHead,
IWriteStream writeStream = null)
{
var fragment = writeStream?.ToByteFragment();
packetHead.Length = fragment.HasValue ? (ushort)(PacketHead.GetSize() + fragment?.Count) : (ushort)PacketHead.GetSize();
packetHead.SendOption = sendOption;
using (var ws = PoolAllocator <IWriteStream> .GetObject()) {
if (writeStream != null)
{
ws.ShiftRight(writeStream.ToByteFragment());
}
Packet.ToBytes(packetHead, ws);
var bf = ws.ToByteFragment();
var result = _writer.Client.SendTo(bf.Buffer, bf.Offset, bf.Count,
SocketFlags.None, socketService.Connection.RemoteAddress);
socketService.OnWrite(result == bf.Count);
return(result == bf.Count);
}
}
private bool Write(SocketService socketService, IWriteStream writeStream, SendOption sendOption)
{
var fragment = writeStream?.ToByteFragment();
var packetHead = new PacketHead {
Length = fragment.HasValue?(ushort)(PacketHead.GetSize() + fragment?.Count):(ushort)PacketHead.GetSize(),
PacketId = socketService.SendCounter,
SendOption = sendOption,
TotalBytes = fragment.HasValue?(ushort)fragment?.Count:(ushort)0
};
var ws = PoolAllocator <IWriteStream> .GetObject();
if (fragment.HasValue)
{
ws.ShiftRight((ByteFragment)fragment);
}
Packet.ToBytes(packetHead, ws);
var byteFragment = ws.ToByteFragment();
var result = _writer.Client.SendTo(byteFragment.Buffer, byteFragment.Offset, byteFragment.Count, SocketFlags.None,
socketService.Connection.RemoteAddress);
socketService.OnWrite(result == byteFragment.Count);
return(result == byteFragment.Count);
}
protected override bool WriteMessage(
SocketService socketService,
SendOption sendOption,
ulong messageId,
IWriteStream writeStream)
{
if (socketService == null)
{
Logger.Error($"{nameof(socketService)} 为 null ！");
return(false);
}
var fragment = writeStream?.ToByteFragment();
var packetHead = new PacketHead {
Length = fragment.HasValue ? (ushort)(PacketHead.GetSize() + fragment?.Count) : (ushort)PacketHead.GetSize(),
PacketId = messageId,
SendOption = sendOption,
TotalBytes = fragment.HasValue ? (ushort)fragment?.Count : (ushort)0,
FragmentId = 0,
TotalFragments = 1
};
var ws = PoolAllocator <IWriteStream> .GetObject();
if (fragment.HasValue)
{
ws.ShiftRight((ByteFragment)fragment);
}
Packet.ToBytes(packetHead, ws);
var byteSegment = ws.ToByteFragment();
var result = StartWrite(socketService, byteSegment.Buffer, byteSegment.Offset, byteSegment.Count, ws, true);
SocketStatistics.LogUnreliableSend();
SocketStatistics.LogTotalBytesSent(packetHead.Length);
return(result);
}
private void AcknowledgeFragment(EndPoint endPoint, IReadStream readStream, PacketHead packetHead)
{
if (!_connections.TryGetValue(endPoint, out var socketService))
{
Logger.Error($"{endPoint}连接没有添加！");
return;
}
var id = BuildID(packetHead);
_fragmentTimer?.Remove(id);
if (!socketService.PacketIds.Remove(id))
{
return;
}
socketService.OnAcknowledge(true, readStream);
SocketStatistics.LogUnreliableReceive();
SocketStatistics.LogAcknowledgementReceive();
SocketStatistics.LogDataBytesReceived(packetHead.TotalBytes);
SocketStatistics.LogTotalBytesReceived(packetHead.Length);
Logger.Info($"{endPoint}：{packetHead.PacketId}消息发送完成！");
}
/// <summary>
/// 发送数据到游戏服
/// </summary>
/// <param name="clientAddress">客户端的地址</param>
/// <param name="data"></param>
public override void Send(string clientAddress, byte[] data)
{
PacketHead head = null;
try
{
PacketMessage packet = PacketMessage.Parse(data);
head = packet.Head;
switch (head.MsgType)
{
case PacketMsgType.Request:
var session = GameSessionManager.GetSession(head.GameId, head.ServerId);
if (session != null)
{
string gameAddress = session.GameAddress;
OnSendToGame(gameAddress, data);
}
else
{
var error = PacketMessage.CreateError(head, MessageError.NotFound, LanguageHelper.GetLang().ServerMaintain);
OnSendToClient(clientAddress, error.ToByte());
TraceLog.WriteError("Can not find the game:{0} server:{1}", head.GameId, head.ServerId);
}
break;
default:
throw new Exception(string.Format("The message type:{0} is not supported.", head.MsgType));
}
}
catch (Exception ex)
{
TraceLog.WriteError("Send game to {0} error:{1}", clientAddress, ex);
var error = PacketMessage.CreateError(head, MessageError.SystemError, LanguageHelper.GetLang().ServerBusy);
OnSendToClient(clientAddress, error.ToByte());
}
}
private void SendCommand2Server(SocketOutChannel ch, DataSet ds)
{
CommandSendData csd = new CommandSendData();
PacketHead ph = new PacketHead();
ph.PacketType = CommandSendData.PacketType;
ph.DestinationIP = SocketOutboundAdapterConfigMgt.SocketOutAdapterConfig.ClientSocketParams.ServerIP;
ph.DestinationPort = SocketOutboundAdapterConfigMgt.SocketOutAdapterConfig.ClientSocketParams.ServerPort;
ph.SourceIP = SocketOutboundAdapterConfigMgt.SocketOutAdapterConfig.ClientSocketParams.CallbackIP;
ph.SourcePort = SocketOutboundAdapterConfigMgt.SocketOutAdapterConfig.ClientSocketParams.CallbackPort;
csd.PacketHead = ph;
foreach (DataRow dr in ds.Tables[0].Rows)
{
csd.Params.Clear();
csd.CommandGUID = "";
foreach (SocketOutQueryResultItem item in ch.Rule.QueryResult.MappingList)
{
//string TargetField = item.ThirdPartyDBPatamter.FieldName.Trim();
string TargetField = item.TargetField.Trim();
if (TargetField == "")
{
continue;
}
if (TargetField.ToUpper() == ("CommandGUID").ToUpper())
{
csd.CommandGUID = dr[TargetField].ToString();
continue;
}
if (TargetField.ToUpper().ToUpper() == ("Commandtype").ToUpper())
{
csd.CommandType = (CommandBase.CommandTypeEnum)Convert.ToInt32(dr[TargetField].ToString());
continue;
}
if (ds.Tables[0].Columns.IndexOf(TargetField) < 0)
{
Program.Log.Write(LogType.Error, TargetField + " is not exist in dataset!\r\n");
}
else
{
csd.Params.Add(TargetField, dr[TargetField].ToString());
}
}
if (csd.CommandGUID == null || csd.CommandGUID.Trim() == "")
{
csd.CommandGUID = Guid.NewGuid().ToString();
}
//byte[] result = _ClientSocket.SendMsg(csd.EncodePackage());
string result = this.SendMsgToServer(csd);
if (result != null)
{
CommandRespSendData crsd = new CommandRespSendData();
crsd.DecodePackagea(result);
if (OnDataDischarge != null)
{
OnDataDischarge(new string[] { dr["Data_ID"].ToString() });
}
Program.Log.Write(LogType.Error, "SendMsg Success! SendResult= " + crsd.SendResult + "\r\n");
//if (crsd.SendResult == "1")
//{
// if (OnDataDischarge != null)
// OnDataDischarge(new string[] { dr["Data_ID"].ToString() });
// Program.Log.Write(LogType.Debug, "SendMsg Success! SendResult=1\r\n");
//}
//else //2007-3-9 Add: Send success, Set Processflag =1, and write a log
//{
// if (OnDataDischarge != null)
// OnDataDischarge(new string[] { dr["Data_ID"].ToString() });
// Program.Log.Write(LogType.Error, "SendMsg Success! SendResult= " + crsd.SendResult + "\r\n");
//}
}
else
{
Program.Log.Write(LogType.Error, "SendMsg Failure!\r\n");
}
}
}
protected Packet(byte[] Data)
{
this.Reader = new BinaryReader(new MemoryStream(Data));
this.Head = this.Reader.FromBinaryReader <PacketHead>();
}
