/// <summary>
/// 建立连接
/// </summary>
/// <param name="dns">对方的IP End Point</param>
/// <param name="id">对方节点的ID号</param>
public void StartConnect(IPEndPoint dns, byte[] id)
{
//如果本地连接数大于最大连接数，则返回
if (connections.Count >= maxInitiate)
{
return;
}
//如果ID号相同，则表明是本地发送的网络信息，则返回
if (Globals.IsArrayEqual(id, myID, 20))
{
return;
}
//如果该ID号已经存在，则返回
foreach (IEncryptedConnection item in connections.Values)
{
if (Globals.IsArrayEqual(id, item.ID, 20))
{
return;
}
}
//开始建立连接
try
{
ISingleSocket singleSocket = rawServer.StartConnect(dns, null);
connections[singleSocket] = new EncryptedConnection(this, singleSocket, id);
}
catch
{
return;
}
}
/// <summary>
/// 写入数据
/// </summary>
/// <param name="singleSocket">待写入的单套接字</param>
public void FlushConnection(ISingleSocket singleSocket)
{
IEncryptedConnection encryptedConnection = connections[singleSocket];
if (encryptedConnection.Completed)
{
connecter.FlushConnection(encryptedConnection);
}
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="encrypter">封装连接类</param>
/// <param name="connection">单套接字</param>
/// <param name="id">对方下载工具的ID号</param>
public EncryptedConnection(IEncrypter encrypter, ISingleSocket connection, byte[] id)
{
this.encrypter = encrypter;
this.connection = connection;
this.id = id;
this.isLocallyInitiated = (id != null);
this.completed = false;
this.closed = false;
this.buffer = new MemoryStream();
BuildReadFunctionChain();
SendHandshakeMessage();
}
/// <summary>
/// 关闭单套接字
/// </summary>
/// <param name="singleSocket">待关闭的单套接字</param>
private void CloseSocket(ISingleSocket singleSocket)
{
//在poll注销Socket
poll.Unregister(singleSocket.Socket);
//在字典中移除singleSocket
singleSocketDictionary.Remove(singleSocket.Socket.Handle);
//关闭套接字
singleSocket.Socket.Close();
singleSocket.Socket = null;
//关闭singleSocket的连接
singleSocket.Handler.CloseConnection(singleSocket);
}
/// <summary>
/// 处理客户端套接字
/// </summary>
/// <param name="item">待处理的PollItem</param>
private void HandleClientSocket(PollItem item)
{
if (!singleSocketDictionary.ContainsKey(item.Socket.Handle))
{
return;
}
ISingleSocket singleSocket = singleSocketDictionary[item.Socket.Handle];
singleSocket.IsConnected = true;
//如果出错或者挂起，则关闭连接
if ((item.Mode & (PollMode.PollError | PollMode.PollHangUp)) != 0)
{
this.CloseSocket(singleSocket);
return;
}
//如果有数据可读，则读数据
if ((item.Mode & PollMode.PollIn) != 0)
{
try
{
singleSocket.LastHit = DateTime.Now;
int available = singleSocket.Socket.Available;
if (available == 0)
{
this.CloseSocket(singleSocket);
}
else
{
//把数据读到一个缓冲区
byte[] data = new byte[available];
singleSocket.Socket.Receive(data, 0, SocketFlags.None);
//调用封装连接管理类的DataCameIn进行处理
singleSocket.Handler.DataCameIn(singleSocket, data);
}
}
catch (SocketException socketEx)
{
if (socketEx.ErrorCode != 10035) //WSAE WOULD BLOCK
{
this.CloseSocket(singleSocket);
return;
}
}
}
//如果有数据可写，则写数据
if (((item.Mode & PollMode.PollOut) != 0) && (singleSocket.Socket != null) && (!singleSocket.IsFlushed))
{
singleSocket.TryWrite();
//最后检查是否数据都已经真的发出去了(IsFlushed)，如果是，
//则调用封装连接管理类中提供的FlushConnection函数进行处理。
if (singleSocket.IsFlushed)
{
singleSocket.Handler.FlushConnection(singleSocket);
}
}
}
/// <summary>
/// 增加死连接
/// </summary>
/// <param name="item"></param>
public void AddToDeadFromWrite(ISingleSocket item)
{
deadFromWrite.Add(item);
}
public void Remove(ISingleSocket keySocket)
{
throw new Exception("The method or operation is not implemented.");
}
public void MakeExternalConnection(ISingleSocket singleSocket)
{
externalDummySockets.Add(singleSocket);
}
public void FlushConnection(ISingleSocket singleSocket)
{
}
public void DataCameIn(ISingleSocket singleSocket, byte[] data)
{
dataIn.Add(new object[] { singleSocket, data });
}
public void Test1()
{
Flag fa = new Flag();
Flag fb = new Flag();
try
{
DummyEncrypter da = new DummyEncrypter();
IRawServer sa = new RawServer(fa, 100, 100, false);
TestHelper ta = new TestHelper();
ta.Loop(sa);
ta.sl(sa, da, 6800);
DummyEncrypter db = new DummyEncrypter();
IRawServer sb = new RawServer(fb, 100, 100, false);
TestHelper tb = new TestHelper();
tb.Loop(sb);
tb.sl(sb, db, 6801);
Thread.Sleep(50);
ISingleSocket ca = sa.StartConnect(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 6801), null);
Thread.Sleep(50);
Assert.AreEqual(0, da.externalDummySockets.Count);
Assert.AreEqual(0, da.dataIn.Count);
Assert.AreEqual(0, da.lostDummySockets.Count);
Assert.AreEqual(1, db.externalDummySockets.Count);
ISingleSocket cb = db.externalDummySockets[0];
db.externalDummySockets.Clear();
Assert.AreEqual(0, db.dataIn.Count);
Assert.AreEqual(0, db.lostDummySockets.Count);
ca.Write(new byte[] { (byte)'a', (byte)'a', (byte)'a' });
cb.Write(new byte[] { (byte)'b', (byte)'b', (byte)'b' });
Thread.Sleep(50);
Assert.AreEqual(0, da.externalDummySockets.Count);
//da.data_in = ca, 'bbb'
da.dataIn.Clear();
Assert.AreEqual(0, da.lostDummySockets.Count);
Assert.AreEqual(0, db.externalDummySockets.Count);
//db.data_in = cb, 'aaa'
db.dataIn.Clear();
Assert.AreEqual(0, db.lostDummySockets.Count);
ca.Write(new byte[] { (byte)'c', (byte)'c', (byte)'c' });
cb.Write(new byte[] { (byte)'d', (byte)'d', (byte)'d' });
Thread.Sleep(50);
Assert.AreEqual(0, da.externalDummySockets.Count);
//da.data_in = ca, 'ddd'
da.dataIn.Clear();
Assert.AreEqual(0, da.lostDummySockets.Count);
Assert.AreEqual(0, db.externalDummySockets.Count);
//db.data_in = cb, 'ccc'
db.dataIn.Clear();
Assert.AreEqual(0, db.lostDummySockets.Count);
ca.Close();
Thread.Sleep(50);
Assert.AreEqual(0, da.externalDummySockets.Count);
Assert.AreEqual(0, da.dataIn.Count);
Assert.AreEqual(0, da.lostDummySockets.Count);
Assert.AreEqual(0, db.externalDummySockets.Count);
Assert.AreEqual(0, db.dataIn.Count);
Assert.AreEqual(1, db.lostDummySockets.Count);
db.lostDummySockets.Clear();
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
finally
{
fa.Set();
fb.Set();
}
}
public void LoseConnection(ISingleSocket singleSocket)
{
lostDummySockets.Add(singleSocket);
}
/// <summary>
/// 接受数据
/// </summary>
/// <param name="singleSocket">接受的单套接字</param>
/// <param name="data">接受的数据</param>
public void DataCameIn(ISingleSocket singleSocket, byte[] data)
{
connections[singleSocket].DataCameIn(data);
}
/// <summary>
/// 关闭连接
/// </summary>
/// <param name="singleSocket">待关闭的单套接字</param>
public void CloseConnection(ISingleSocket singleSocket)
{
connections[singleSocket].Server();
}
/// <summary>
/// 增加连接
/// </summary>
/// <param name="singleSocket">待建立的单套接字</param>
public void MakeExternalConnection(ISingleSocket singleSocket)
{
connections[singleSocket] = new EncryptedConnection(this, singleSocket, null);
}
/// <summary>
/// 移除连接
/// </summary>
/// <param name="keySocket">待移除的单套接字</param>
public void Remove(ISingleSocket keySocket)
{
this.connections.Remove(keySocket);
}
public void CloseConnection(ISingleSocket singleSocket)
{
throw new Exception("The method or operation is not implemented.");
}
public void AddToDeadFromWrite(ISingleSocket item)
{
throw new Exception("The method or operation is not implemented.");
}
