void client_Conn(ConClient conClient, bool conn)
{
if (conClient != null && conn)
{
LogOut.LogIn(string.Format("连接到:{0} ---->OK", conClient.Sock.Sock.RemoteEndPoint.ToString()), ActionType.Message);
if (!ConnUserList.ContainsKey(conClient.Key))
{
if (ConnUserList.TryAdd(conClient.Key, conClient))
{
conClient.Sock.StartRead();
if (ClientConnToMe != null)
{
ClientConnToMe(conClient);
}
}
}
else
{
conClient.Sock.Close();
}
}
else
{
LogOut.LogIn(string.Format("无法连接到指定地址端口 {0}:{1}", conClient.Host, conClient.Port), ActionType.Message);
conClient.Sock.Close();
}
}
/// <summary>
/// 释放用户
/// </summary>
/// <param name="key"></param>
public void DropConnUser(string key)
{
lock (ConnUserList)
{
if (ConnUserList.ContainsKey(key))
{
ConnUserList[key].Sock.Close();
ConClient client;
ConnUserList.TryRemove(key, out client);
}
}
}
/// <summary>
/// 释放所有用户
/// </summary>
public void DropConnUserList()
{
lock (ConnUserList)
{
foreach (KeyValuePair <string, ConClient> user in ConnUserList)
{
user.Value.Sock.Close();
}
ConnUserList.Clear();
}
}
void client_ExpOUtPut(ConClient conClient, string Message)
{
if (ConnUserList.ContainsKey(conClient.Key))
{
ConnUserList.TryRemove(conClient.Key, out conClient);
}
LogOut.LogIn(string.Format("客户连接断开 {0}:{1}", conClient.Host + ":" + conClient.Port, conClient.Key), ActionType.Message);
if (ClientDiscon != null)
{
ClientDiscon(conClient, string.Format("客户连接断开 {0}:{1}", conClient.Host + ":" + conClient.Port, conClient.Key));
}
}
/// <summary>
/// 发送数据到指定的客户端
/// </summary>
/// <param name="key"></param>
/// <param name="data"></param>
public void SendData(string key, byte[] data)
{
if (ConnUserList.ContainsKey(key))
{
ConnUserList[key].SendData(data);
}
else
{
BufferFormatV2 tmp = new BufferFormatV2((int)PCMD.ProxyData);
tmp.AddItem(key);
tmp.AddItem(data);
Mainclient.Send(tmp.Finish());
}
}
/// <summary>
/// 释放所有用户
/// </summary>
public void DropConnUserList()
{
lock (ConnUserList)
{
foreach (var user in ConnUserList)
{
if (user.Value.IsConnect && user.Value.Client != null)
{
user.Value.Client.Sock.Close();
}
}
ConnUserList.Clear();
}
}
void client_ExpOUtPut(ConClient conClient, string Message)
{
SessionObj session = null;
if (ConnUserList.ContainsKey(conClient.Key))
{
session = ConnUserList[conClient.Key];
session.IsConnect = false;
}
LLOG(string.Format("客户连接断开 {0}:{1}", conClient.Host + ":" + conClient.Port, conClient.Key), ActionType.None);
if (SessionDisconnect != null)
{
SessionDisconnect(conClient.Key, string.Format("客户连接断开 {0}:{1}", conClient.Host + ":" + conClient.Port, conClient.Key));
}
}
void client_Conn(ConClient conClient, bool conn)
{
if (conClient != null && conn)
{
LLOG(string.Format("连接到:{0} ---->OK", conClient.Sock.Sock.RemoteEndPoint.ToString()), ActionType.None);
if (ConnUserList.ContainsKey(conClient.Key))
{
lock (lockObj)
{
if (!ConnUserList[conClient.Key].IsConnect)
{
conClient.DataOutPut += new DataOutPutHandlerFiler(client_DataOutPut);
conClient.ExpOUtPut += new ExpOutPutHandlerFiler(client_ExpOUtPut);
var session = ConnUserList[conClient.Key];
session.IsConnect = true;
session.Client = conClient;
conClient.Sock.StartRead();
if (ConnectToMe != null)
{
ConnectToMe(conClient.Key);
}
}
else
{
conClient.Sock.Close();
}
}
}
else
{
conClient.Sock.Close();
}
}
else
{
LLOG(string.Format("无法连接到指定地址端口 {0}:{1}", conClient.Host, conClient.Port), ActionType.None);
conClient.Sock.Close();
}
}
/// <summary>
/// 释放用户
/// </summary>
/// <param name="key"></param>
private void DropConnUser(long key)
{
lock (ConnUserList)
{
if (ConnUserList.ContainsKey(key))
{
var session = ConnUserList[key];
if (session.IsConnect && session.Client != null)
{
session.Client.Sock.Close();
}
session.IsConnect = false;
ConnUserList.TryRemove(key, out session);
}
}
}
public void SendData(long Id, byte[] data)
{
if (ConnUserList.ContainsKey(Id))
{
var session = ConnUserList[Id];
if (session.IsConnect && session.Client != null)
{
session.Client.SendData(data);
}
else
{
ProxyData tmp = new ProxyData();
tmp.Source = this.Id;
tmp.Data = data;
tmp.Ids = new List <long>();
tmp.Ids.Add(Id);
MainClient.BeginSendData(BufferFormat.FormatFCA(tmp));
}
}
}
/// <summary>
/// 数据包处理
/// </summary>
/// <param name="data"></param>
private void BufferIn(byte[] data)
{
ReadBytes read = new ReadBytes(data);
int length;
int cmd;
if (read.ReadInt32(out length) && length == read.Length && read.ReadInt32(out cmd))
{
switch (cmd)
{
case -1000:
{
RegSession session;
if (read.ReadObject <RegSession>(out session))
{
if (session.IsSuccess)
{
this.Id = session.Id;
this.RegPort = session.Port;
LLOG("MY ID:" + this.Id, ActionType.Message);
GetAllUserSession();
}
else
{
LLOG(session.Msg, ActionType.Error);
MainClient.Close();
}
}
}
break;
case -1001:
{
GetAllSession allsession;
if (read.ReadObject <GetAllSession>(out allsession))
{
if (allsession.IsSuccess && allsession.UserIds != null)
{
CheckDroupConnect(allsession);
foreach (var Id in allsession.UserIds)
{
if (!ConnUserList.ContainsKey(Id))
{
SessionObj tmp = new SessionObj()
{
Id = Id
};
ConnUserList.AddOrUpdate(Id, tmp, (a, b) => tmp);
UserMaskList.Enqueue(Id);
}
}
RunQueueList();
}
}
}
break;
case -1002:
{
ConnectTo connto;
if (read.ReadObject <ConnectTo>(out connto))
{
if (connto.IsSuccess)
{
RegConnectTo(connto.Host, connto.Port, connto.Id);
}
}
}
break;
case -1003:
{
LEFTConnect leftconnto;
if (read.ReadObject <LEFTConnect>(out leftconnto))
{
if (leftconnto.IsSuccess)
{
RunConnToMe(leftconnto.Host, leftconnto.Port, leftconnto.Id);
}
}
}
break;
case -1004:
{
AddSession addsession;
if (read.ReadObject <AddSession>(out addsession))
{
if (addsession.Id != this.Id)
{
if (!ConnUserList.ContainsKey(addsession.Id))
{
SessionObj tmp = new SessionObj()
{
Id = addsession.Id
};
ConnUserList.AddOrUpdate(addsession.Id, tmp, (a, b) => tmp);
LLOG("Add Session:" + addsession.Id, ActionType.Message);
}
}
}
}
break;
case -1005:
{
RemoveSession remove;
if (read.ReadObject <RemoveSession>(out remove))
{
if (ConnUserList.ContainsKey(remove.Id))
{
DropConnUser(remove.Id);
LLOG("Remove Session:" + remove.Id, ActionType.Message);
}
}
}
break;
case -2000:
{
ProxyData proxydata;
if (read.ReadObject <ProxyData>(out proxydata))
{
if (DataInput != null)
{
DataInput(proxydata.Source, proxydata.Data);
}
}
}
break;
}
}
}
