public void Accept()
{
IntPtr bytePointer = Marshal.UnsafeAddrOfPinnedArrayElement(
_byteBuffer.Array, _byteBuffer.End);
if (null == _socket)
{
_socket = _acceptor.CreateSocket(_listenSocket.AddressFamily
, _listenSocket.SocketType, _listenSocket.ProtocolType);
}
int bytesTransferred;
if (_listenSocket.AcceptEx(_socket, bytePointer
, 0 //_byteBuffer.Space - (HazelAddress.MaxSize + 4) * 2
//必须为0,否则会有大量的连接处于accept中，因为客户端只
//建立连接，没有发送数据。
, HazelAddress.MaxSize + 4
, HazelAddress.MaxSize + 4
, out bytesTransferred
, NativeOverlapped))
{
return;
}
if ((int)SocketError.IOPending == Marshal.GetLastWin32Error())
{
return;
}
throw new AcceptError(_acceptor.BindPoint, new SocketException());
}
public AcceptRequest(Acceptor listeningPort, HazelSocket listenSocket, HazelSocket socket)//, int dataLength)
: base(null)
{
_acceptor = listeningPort;
_listenSocket = listenSocket;
_socket = socket;
_byteBuffer = new ByteBuffer((HazelAddress.MaxSize + 4) * 2 + 100); //dataLength);
PinObject(_byteBuffer.Array);
}
public override void internalDispose()
{
base.internalDispose();
if (null == _socket)
{
return;
}
try
{
_core.ReleaseSocket(_socket, false);
}
catch
{ }
_socket = null;
}
public ConnectRequest(ILog logger
, Connector connector
, BuildProtocol <T> buildProtocol
, OnConnectError <T> throwError
, T context
, ByteBuffer byteBuffer)
: base(null)
{
_logger = logger;
_socket = null;
_connector = connector;
_buildProtocol = buildProtocol;
_throwError = throwError;
_context = context;
_byteBuffer = byteBuffer;
if (null != _byteBuffer)
{
PinObject(_byteBuffer.Array);
}
}
public void Connect()
{
_core = _connector.Core.GetNextCore();
if (null == _socket)
{
_socket = _core.CreateSocket(_connector.AddressFamily
, _connector.SocketType, _connector.ProtocolType);
}
if (!_core.Bind(_socket))
{
throw new SocketException();
}
int bytesTransferred;
if (null != _byteBuffer && 0 < _byteBuffer.Count)
{
IntPtr bytePointer = Marshal.UnsafeAddrOfPinnedArrayElement(
_byteBuffer.Array, _byteBuffer.Begin);
if (_socket.ConnectEx(_connector.ConnectTo, bytePointer, _byteBuffer.Count, out bytesTransferred, this.NativeOverlapped, _core))
{
return;
}
}
else
{
if (_socket.ConnectEx(_connector.ConnectTo, IntPtr.Zero, 0, out bytesTransferred, this.NativeOverlapped, _core))
{
return;
}
}
if ((int)SocketError.IOPending == Marshal.GetLastWin32Error())
{
return;
}
throw new SocketException();
}
public void Complete(int bytes_transferred, bool success, int error, object context)
{
if (!success)
{
try
{
_core.ReleaseSocket(_socket, false);
_socket = null;
}
catch { }
_connector.OnError(_throwError, _context, new ConnectError(_connector.ConnectTo, new SocketException(error)));
return;
}
Exception exception = null;
try
{
if (null != _byteBuffer && 0 < bytes_transferred)
{
_byteBuffer.Begin += bytes_transferred;
}
_logger.InfoFormat("连接到[{0}]成功，开始初始化!", _connector.ConnectTo);
_socket.SetRemote(_connector.ConnectTo, null);
_socket.SetSockOpt(SocketOptionLevel.Socket
, SocketOptionName.UpdateConnectContext
, _socket.Handle);
ConnectedSocket connectedSocket = new ConnectedSocket(_core, _socket, new ProtocolContext(null, _connector.Config));
_socket = null;
try
{
IProtocol protocol = _buildProtocol(connectedSocket, _context);
_core.InitializeConnection(connectedSocket, protocol);
//FIXME: 将在连接时没有发送完的数据，再发送（不能放在）
///if (null != _byteBuffer && 0 < _byteBuffer.Count)
/// connectedSocket.Write(_byteBuffer);
_logger.InfoFormat("连接到[{0}]成功，初始化成功!", _connector.ConnectTo);
return;
}
catch (Exception)
{
_socket = connectedSocket.ReleaseSocket();
}
}
catch (Exception e)
{
exception = new InitializeError(_connector.ConnectTo,
string.Format("初始化连接到[{0}]通道，发生错误！", _connector.ConnectTo), e);
}
try
{
_core.ReleaseSocket(_socket, false);
_socket = null;
}
catch { }
_connector.OnError(_throwError, _context, exception);
}
void InitializeConnection(int bytes_transferred, object context)
{
IntPtr bytePointer = Marshal.UnsafeAddrOfPinnedArrayElement(
_byteBuffer.Array, _byteBuffer.End);
HazelAddress localAddr = null;
HazelAddress remoteAddr = null;
HazelSocket.GetAcceptExSockaddrs(bytePointer
, 0
, HazelAddress.MaxSize + 4
, HazelAddress.MaxSize + 4
, out localAddr
, out remoteAddr);
_byteBuffer.End += bytes_transferred;
_byteBuffer.Begin += (2 * (HazelAddress.MaxSize + 4));
_socket.SetLocalAddress(localAddr);
_socket.SetRemoteAddress(remoteAddr);
_socket.SetSockOpt(SocketOptionLevel.Socket, SocketOptionName.UpdateAcceptContext, _socket.Handle);
_acceptor.Logger.InfoFormat("获取到来自[{0}]的连接,开始初始化!", _socket.RemoteEndPoint);
IOCPCore core = _acceptor.Core.GetNextCore();
if (!core.Bind(_socket))
{
Win32Exception err = new Win32Exception();
_acceptor.OnError(new InitializeError(_acceptor.BindPoint, string.Format("初始化来自[{0}]的连接时，绑定到iocp发生错误 - {0}", _socket.RemoteEndPoint, err.Message), err));
return;
}
InitializeError initializeError = null;
ConnectedSocket connectedSocket = null;
try
{
IDictionary <string, object> misc = (null == _acceptor.ProtocolFactory) ? null : _acceptor.ProtocolFactory.Misc;
connectedSocket = new ConnectedSocket(core, _socket, new ProtocolContext(null, misc));
IProtocol protocol = _acceptor.CreateProtocol(connectedSocket);
core.InitializeConnection(connectedSocket, protocol);
_acceptor.Logger.InfoFormat("初始化来自[{0}]的连接成功!", _socket.RemoteEndPoint);
_socket = null;
}
catch (InitializeError e)
{
initializeError = e;
}
catch (Exception e)
{
initializeError = new InitializeError(_socket.RemoteEndPoint, "在处理新连接时发生异常!", e);
}
if (null != initializeError)
{
if (null != connectedSocket)
{
connectedSocket.ReleaseSocket();
}
_acceptor.OnError(initializeError);
}
}
