public void Connect()
{
status.text = "Error connecting to that ip";
TcpClient clientSocket = new TcpClient();
clientSocket.Connect(ipAddress.text, 1273);
ConnectedSocket connectedServer = new ConnectedSocket(clientSocket, null);
GameSettings.connectedServer = connectedServer;
//setup threads
Thread disconnectThread = new Thread(new ThreadStart(() => connectedServer.WaitForDisconnect()));
disconnectThread.Start();
connectedServer.playerDisconnectThread = disconnectThread;
Thread messageThread = new Thread(connectedServer.WaitForMessages);
messageThread.Start();
connectedServer.playerMessageThread = messageThread;
status.text = "Connected!";
status.color = new Color(0, 1, 0);
}
private void ReceiveMessageCallback(IAsyncResult Result)
{
ConnectedSocket.EndReceive(Result);
WebSocketFrame CurrentFrame = new WebSocketFrame(ReceiveBuffer, ConnectedSocket);
CurrentFrame.ReceivePayload(ConnectedSocket);
if (CurrentFrame.PayloadOpCode == WebSocketOpCode.ConnectionCloseFrame)
{
ConnectedServer.DisconnectUser(this);
return;
}
if (CurrentPacket == null)
{
CurrentPacket = new WebSocketPacket(CurrentFrame);
}
CurrentPacket.AddFrame(CurrentFrame);
if (CurrentFrame.HeaderFrame.FinalPacket)
{
ConnectedServer.Receive(this, CurrentPacket.Payload, CurrentPacket.PayloadOpCode);
CurrentPacket = null;
GC.Collect();
}
Array.Clear(ReceiveBuffer, 0, ReceiveBuffer.Length);
ConnectedSocket.BeginReceive(ReceiveBuffer, 0, 2, SocketFlags.None, ReceiveMessageCallback, null);
}
private void DisconnectClient(ConnectedSocket client)
{
client.Socket.AsSafeDisposable().Dispose();
ConnectedSocket unused;
_Clients.TryRemove(client, out unused);
}
public bool SendFile(string path)
{
if (ConnectedSocket != null && ConnectedSocket.Connected)
{
try
{
FileInfo fi = new FileInfo(path);
byte[] len = BitConverter.GetBytes(fi.Length);
byte[] name = UTF8.GetBytes(fi.Name);
byte[] nameLen = BitConverter.GetBytes(name.Length);
byte[] head = new byte[1 + len.Length + nameLen.Length + name.Length];
head[0] = (byte)ChatType.File;
Array.Copy(len, 0, head, 1, len.Length);
Array.Copy(nameLen, 0, head, 1 + len.Length, nameLen.Length);
Array.Copy(name, 0, head, 1 + len.Length + nameLen.Length, name.Length);
ConnectedSocket.SendFile(
path,
head,
null,
TransmitFileOptions.UseDefaultWorkerThread
);
return(true);
}
catch (Exception e)
{
// 连接断开了
Console.WriteLine("send file exception : " + e.Message);
}
}
return(false);
}
public void RemovePlayerFromList(ConnectedSocket client)
{
playerAmount--;
unitAmountChooser.playerAmount = playerAmount;
int index = GameSettings.connectedPlayers.IndexOf(client);
GameObject playerText = null;
if (playerTexts.Count <= index)
{
playersToSpawn--;
}
else
{
playerText = playerTexts[index];
for (int i = index; i < playerTexts.Count; i++)
{
playerTexts[i].GetComponent <RectTransform>().anchoredPosition += new Vector2(0, 30);
playerTexts[i].GetComponent <Text>().text = "Player " + (i + 1); //plus one instead because the first player isn't in the array (it's the this computer)
}
Destroy(playerText);
playerTexts.RemoveAt(index);
}
GameSettings.connectedPlayers.Remove(client);
}
private async Task StartAsync <TContext>(Socket socket, IHttpApplication <TContext> application)
{
try
{
while (true)
{
var client = await socket.AcceptAsync(_Stopped.Token).ConfigureAwait(false);
var connectedSocket = new ConnectedSocket(client);
_Clients.TryAdd(connectedSocket, connectedSocket);
if (Options.MaxConnections < _Clients.Count)
{
await EvictAsync().ConfigureAwait(false);
}
var unused = ListenClient(connectedSocket, application);
_Stopped.Token.ThrowIfCancellationRequested();
}
}
catch (OperationCanceledException)
{
if (!_Stopped.IsCancellationRequested)
{
throw;
}
}
finally
{
_AcceptLoopStopped.Set();
}
}
public Common.ServiceStatus SetMoney(List<Efectivo> val)
{
Common.ServiceStatus response = new Common.ServiceStatus();
response.error.HasError = true;
response.error.Message = "Error recibido del PaymentDevice";
ComClass clase = new ComClass();
clase.funciones = ComClass.function.set_money;
clase.Inventario = val;
string Test = JsonConvert.SerializeObject(clase);
using (var socket = new ConnectedSocket("127.0.0.1", 1337)) // Connects to 127.0.0.1 on port 1337
{
socket.Send(Test); // Sends some data
var data = socket.Receive(); // Receives some data back (blocks execution)
ComClass deserializedProduct = JsonConvert.DeserializeObject<ComClass>(data);
if(deserializedProduct.result== ComClass.status_cash.ok)
{
response.IsDone = true;
response.error.HasError = false;
return response;
}
}
return response;
}
public ReadFileOp(ConnectedSocket transport
, ByteBuffer byteBuffer)
: base(byteBuffer.Array)
{
_transport = transport;
_byteBuffer = byteBuffer;
}
public void Start(string configPath)
{
AddLog("Starting a node...", LogType.Information);
try
{
Config = NetworkNodeConfig.ParseConfig(configPath);
}
catch (Exception e)
{
AddLog($"Exception: {e.Message}", LogType.Error);
return;
}
networkNodeRoutingTables.LoadTablesFromConfig(Config, Window);
networkNodeRoutingTables.StartManagementAgent();
ConnectToCloud();
while (true)
{
while (ConnectedSocket == null || !ConnectedSocket.Connected)
{
AddLog("Retrying connection to cable cloud...", LogType.Information);
ConnectToCloud();
}
try
{
var package = ConnectedSocket.Receive();
AddLog($"Received package: {package} at port {package.Port}", LogType.Received);
Task.Run(() => HandlePackage(package));
}
catch (InvalidMPLSPackageException)
{
AddLog("Received package was not a valid package.", LogType.Error);
}
catch (SocketException e)
{
// ignore timeout exceptions
if (e.SocketErrorCode != SocketError.TimedOut)
{
if (e.SocketErrorCode == SocketError.Shutdown || e.SocketErrorCode == SocketError.ConnectionReset)
{
AddLog("Connection to Cloud broken!", LogType.Error);
continue;
}
else
{
AddLog($"{e.Source}: {e.SocketErrorCode}", LogType.Error);
}
}
}
}
}
public void SendFrame(string Data, WebSocketOpCode OpCode, bool LastFrame)
{
if (ConnectedSocket.Connected)
{
WebSocketFrame Frame = new WebSocketFrame(Data, OpCode);
byte[] FrameBuffer = Frame.GetRawBuffer(LastFrame);
ConnectedSocket.BeginSend(FrameBuffer, 0, FrameBuffer.Length, SocketFlags.None, SendMessageCallback, null);
}
}
public ProcessingRequest(ConnectedSocket connectedSocket)
{
this.connectedSocket = connectedSocket;
if (connectedSocket.IsProcessing)
{
throw new InvalidOperationException("Already processing request");
}
connectedSocket.IsProcessing = true;
}
private void BeginReceive()
{
SocketFlags socketFlags;
int offset;
Logger.WriteEntry("BeginReceive() entry");
offset = 0;
socketFlags = SocketFlags.None;
ConnectedSocket.BeginReceive(ReceiveState.ReceiveBuffer, offset, ReceiveState.SizeTcpByteArray, socketFlags,
new AsyncCallback(ReceiveCallback), ReceiveState);
}
/**
* Functions
**/
//if hosting the server
public static void SendToAllExcept(string message, ConnectedSocket except)
{
foreach (ConnectedSocket connectedPlayer in connectedPlayers)
{
if (connectedPlayer == except)
{
continue;
}
connectedPlayer.SendMessage(message);
}
}
public void HandlePaymentCash(int quantity)
{
ComClass clase = new ComClass();
clase.funciones = ComClass.function.cash_handling;
clase.Value = quantity;
string Test = JsonConvert.SerializeObject(clase);
using (var socket = new ConnectedSocket("127.0.0.1", 1337)) // Connects to 127.0.0.1 on port 1337
{
socket.Send(Test); // Sends some data
var data = socket.Receive(); // Receives some data back (blocks execution)
}
}
private void button1_Click(object sender, EventArgs e)
{
ComClass clase = new ComClass();
clase.funciones = ComClass.function.cash_handling;
clase.Value = 4500;
string Test = JsonConvert.SerializeObject(clase);
using (var socket = new ConnectedSocket("127.0.0.1", 1337)) // Connects to 127.0.0.1 on port 1337
{
socket.Send(Test); // Sends some data
var data = socket.Receive(); // Receives some data back (blocks execution)
}
}
public static Mod CheckForUpdate() // https://download2.survival-machines.fr/vrcmodloader/VRCModLoaderHashCheck.php?localhash=b9a34bb327390008c235cefe8d8f4ada
{
var mod = GetMod(Setup.Mods.VRCModLoaderDLL().FullName);
using (var socket = new ConnectedSocket("vrchat.survival-machines.fr", 26341))
{
var request = new VRCTRequest(Type.GETINSTALLERVERSION, "");
socket.Send(request.toJSON());
//var data = socket.Receive();
//var response = new VRCTResponse(data);
// Logger.Log("recieved:", data);
}
return(mod);
}
public void Start()
{
while (true)
{
AddLog("Management agent starting...", LogType.Information);
ConnectToMS();
if (ConnectedSocket == null)
{
// connection failed
// start over
continue;
}
while (true)
{
try
{
byte[] buffer = new byte[512];
int bytes = ConnectedSocket.Receive(buffer);
var message = Encoding.ASCII.GetString(buffer, 0, bytes);
Task.Run(() => HandleMessage(message));
}
catch (SocketException e)
{
// ignore timeout exceptions
if (e.SocketErrorCode != SocketError.TimedOut)
{
if (e.SocketErrorCode == SocketError.Shutdown || e.SocketErrorCode == SocketError.ConnectionReset)
{
AddLog("Connection to MS broken!", LogType.Error);
break;
}
else
{
AddLog($"{e.Source}: {e.SocketErrorCode}", LogType.Error);
}
}
}
}
}
}
public void Send(String sendText)
{
// Convert the text to byte data using ASCII encoding.
byte[] byteData = Encoding.ASCII.GetBytes(sendText);
// Begin sending the data to the remote device.
SocketFlags socketFlags;
int offset;
offset = 0;
socketFlags = SocketFlags.None;
ConnectedSocket.BeginSend(byteData, offset, byteData.Length, socketFlags,
new AsyncCallback(SendCallback), ConnectedSocket);
// Wait for the completion signal.
SendDoneEvent.WaitOne();
}
public string StartClient(string whatToSend)
{
// Connect to a remote device.
try
{
// Establish the remote endpoint for the socket.
IPAddress ipAddress = IPAddress.Parse(_serverIp);
//IPAddress ipAddress = IPAddress.Parse("2.109.10.231");
IPEndPoint remoteEP = new IPEndPoint(ipAddress, 11000);
// Create a TCP/IP socket.
var sender = new ConnectedSocket(remoteEP);
// Connect the socket to the remote endpoint. Catch any errors.
try
{
// Send the data through the socket.
sender.Send(whatToSend);
// Receive the response from the remote device.
var received = "";
do {
received += sender.Receive(1024);
Thread.Sleep(20);
}
while (sender.AnythingToReceive);
Console.WriteLine(received);
return received;
}
catch (Exception)
{
return JsonConvert.SerializeObject(new LoginResponseMsg("", false) { MessageInfo = "Error - Server did not respond\nMake sure server is started and Emil isn't nearby" }, _jsonSettings);
}
}
catch (Exception)
{
return JsonConvert.SerializeObject(new LoginResponseMsg("", false) {MessageInfo = "Error - Server did not respond\nMake sure server is started and Emil isn't nearby"}, _jsonSettings);
}
}
private void ConnectToCloud()
{
AddLog($"Connecting to cable cloud at {Config.CloudAddress}:{Config.CloudPort}", LogType.Information);
try
{
MPLSSocket socket = new MPLSSocket(Config.ManagementSystemAddress.AddressFamily, SocketType.Stream,
ProtocolType.Tcp);
socket.Connect(new IPEndPoint(Config.CloudAddress, Config.CloudPort));
socket.Send(Encoding.ASCII.GetBytes($"{ManagementActions.HELLO} {Config.NodeName}"));
AddLog("Estabilished connection with cable cloud", LogType.Information);
ConnectedSocket = socket;
Task.Run(async() =>
{
while (true)
{
var connectionGood = ConnectedSocket != null && ConnectedSocket.Connected;
if (connectionGood)
{
ConnectedSocket.Send(Encoding.ASCII.GetBytes("KEEPALIVE"));
await Task.Delay(5000);
}
else
{
AddLog("Connection to cable cloud broken!", LogType.Error);
break;
}
}
});
}
catch (Exception)
{
AddLog("Failed to connect to cable cloud", LogType.Error);
}
}
private void HandlePackage(MPLSPackage package)
{
MPLSPackage routedPackage = null;
routedPackage = packageSwitch.RouteMPLSPackage(package, networkNodeRoutingTables, Window);
if (routedPackage == null)
{
return;
}
try
{
ConnectedSocket.Send(routedPackage);
AddLog(
$"Package {package} routed to port {routedPackage.Port} with label {routedPackage.PeekTopLabel()?.Number.ToString() ?? "None"}",
LogType.Sent);
}
catch (Exception e)
{
AddLog($"Package {routedPackage} not sent correctly: {e.Message}", LogType.Error);
}
}
public List<Efectivo> GetInventario()
{
ComClass clase = new ComClass();
clase.funciones = ComClass.function.get_money;
string Test = JsonConvert.SerializeObject(clase);
using (var socket = new ConnectedSocket("127.0.0.1", 1337)) // Connects to 127.0.0.1 on port 1337
{
socket.Send(Test); // Sends some data
var data = socket.Receive(); // Receives some data back (blocks execution)
ComClass deserializedProduct = JsonConvert.DeserializeObject<ComClass>(data);
return deserializedProduct.Inventario;
}
}
private void ReceiveCallback(IAsyncResult asyncResult)
{
try
{
// Retrieve the state object and the clientSocket socket from the asynchronous state object.
CallbackReceiveState callbackReceiveState = ( CallbackReceiveState )asyncResult.AsyncState;
// Read data from the remote device.
int bytesRead = ConnectedSocket.EndReceive(asyncResult);
if (bytesRead > 0)
{
Logger.WriteEntry("ReceiveCallBack() Received " + bytesRead.ToString());
// Accumulate the received text.
string receivedText = Encoding.ASCII.GetString(callbackReceiveState.ReceiveBuffer, 0, bytesRead);
callbackReceiveState.Sb.Append(receivedText);
// Recursively get the rest of the data.
BeginReceive();
}
else
{
Logger.WriteEntry("ReceiveCallBack() Received 0 bytes. Should be done. ");
// All the text has arrived.
if (callbackReceiveState.Sb.Length > 1)
{
this.ReceivedText = callbackReceiveState.Sb.ToString();
}
Logger.WriteEntry("ReceiveDoneEvent.Set() to signal completion.");
// Signal the completion of the message.
ReceiveDoneEvent.Set();
}
}
catch (Exception e)
{
Logger.WriteEntry(e.ToString());
}
}
public List<Common.ServiceStatus> GetDevicesStatus()
{
try
{
ComClass clase = new ComClass();
clase.funciones = ComClass.function.get_devices_status;
string Test = JsonConvert.SerializeObject(clase);
using (var socket = new ConnectedSocket("127.0.0.1", 1337)) // Connects to 127.0.0.1 on port 1337
{
socket.Send(Test); // Sends some data
var data = socket.Receive(); // Receives some data back (blocks execution)
ComClass deserializedProduct = JsonConvert.DeserializeObject<ComClass>(data);
Helpers.Utilities.WriteLocalLog("[GetDevicesStatus] Devices loaded ok");
return deserializedProduct.DeviceStatus;
}
}catch(Exception e)
{
Helpers.Utilities.WriteLocalLog("[GetDevicesStatus] " + e.Message);
}
return null;
}
public bool Send(string msg)
{
if (ConnectedSocket != null && ConnectedSocket.Connected)
{
byte[] buffer = UTF8.GetBytes(msg);
byte[] len = BitConverter.GetBytes((long)buffer.Length);
byte[] content = new byte[1 + len.Length + buffer.Length];
content[0] = (byte)ChatType.Str;
Array.Copy(len, 0, content, 1, len.Length);
Array.Copy(buffer, 0, content, 1 + len.Length, buffer.Length);
try
{
ConnectedSocket.Send(content);
return(true);
}
catch (Exception e)
{
Console.WriteLine(e.Message + " ooo");
}
}
return(false);
}
public void WaitForConnection()
{
TcpListener serverSocket = GameSettings.serverSocket;
TcpClient clientSocket = serverSocket.AcceptTcpClient();
print("connected");
//NetworkStream networkStream = clientSocket.GetStream();
//byte[] bytesFrom = new byte[50];
//networkStream.Read(bytesFrom, 0, bytesFrom.Length);
//print(System.Text.Encoding.ASCII.GetString(bytesFrom));
ConnectedSocket connectedPlayer = new ConnectedSocket(clientSocket, null);
GameSettings.connectedPlayers.Add(connectedPlayer);
//this will make the main thread spawn a new player text
playersToSpawn++;
t = new Thread(new ThreadStart(WaitForConnection));
t.Start();
Thread disconnectThread = new Thread(new ThreadStart(() => connectedPlayer.WaitForDisconnect(playersToRemove)));
disconnectThread.Start();
connectedPlayer.playerDisconnectThread = disconnectThread;
Thread messageThread = new Thread(connectedPlayer.WaitForMessages);
messageThread.Start();
connectedPlayer.playerMessageThread = messageThread;
}
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);
}
private void ConnectToMS()
{
AddLog($"Connecting to MS at {Config.ManagementSystemAddress}:{Config.ManagementSystemPort}", LogType.Information);
while (true)
{
Socket socket = new Socket(Config.ManagementSystemAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
socket.ReceiveTimeout = 20000;
try
{
var result = socket.BeginConnect(new IPEndPoint(Config.ManagementSystemAddress, Config.ManagementSystemPort), null, null);
bool success = result.AsyncWaitHandle.WaitOne(5000, true);
if (success)
{
socket.EndConnect(result);
}
else
{
socket.Close();
AddLog("Connection to MS not established - timeout...", LogType.Error);
continue;
}
}
catch (Exception)
{
AddLog("Retrying...", LogType.Information);
}
try
{
AddLog($"Sending hello to MS...", LogType.Information);
socket.Send(Encoding.ASCII.GetBytes($"{ManagementActions.HELLO} {Config.NodeName}"));
byte[] buffer = new byte[256];
int bytes = socket.Receive(buffer);
var message = Encoding.ASCII.GetString(buffer, 0, bytes);
if (message.Contains(ManagementActions.HELLO))
{
AddLog("Estabilished connection with MS", LogType.Information);
ConnectedSocket = socket;
break;
}
}
catch (Exception)
{
AddLog("Couldn't connect to MS!", LogType.Error);
}
}
Task.Run(async() =>
{
while (true)
{
var connectionGood = ConnectedSocket != null && ConnectedSocket.Connected;
if (connectionGood)
{
ConnectedSocket.Send(Encoding.ASCII.GetBytes("KEEPALIVE"));
await Task.Delay(5000);
}
else
{
AddLog("Connection to MS broken!", LogType.Error);
break;
}
}
});
}
private async Task ListenClient <TContext>(ConnectedSocket connectedSocket, IHttpApplication <TContext> application)
{
try
{
var client = connectedSocket.Socket;
var networkStream = new NetworkStream(client, false);
while (true)
{
using (var disposables = new CompositeDisposable())
{
var stream = new TCPStream(networkStream)
{
ArrayPool = Options.ArrayPool,
Cancellation = _Stopped.Token,
MaxArrayLength = Options.MaxBytesArrayLength,
MaxMessageSize = Options.MaxMessageSize
};
disposables.Children.Add(stream);
var idleTimeout = new CancellationTokenSource();
idleTimeout.CancelAfter(Options.IdleTimeout);
disposables.Children.Add(idleTimeout);
var linked = CancellationTokenSource.CreateLinkedTokenSource(stream.Cancellation, idleTimeout.Token);
disposables.Children.Add(linked);
stream.Cancellation = linked.Token;
var request = await TCPRequest.Parse(stream, Options.IncludeHeaders).ConfigureAwait(false);
disposables.Children.Add(connectedSocket.MarkProcessingRequest());
var context = (HostingApplication.Context)(object) application.CreateContext(Features);
context.HttpContext = new TCPContext(request, Features, new TCPConnectionInfo(client, _ListeningEndPoint));
await application.ProcessRequestAsync((TContext)(object)context);
CancellationTokenSource sendTimeout = new CancellationTokenSource();
sendTimeout.CancelAfter(Options.SendTimeout);
disposables.Children.Add(sendTimeout);
linked = CancellationTokenSource.CreateLinkedTokenSource(stream.Cancellation, sendTimeout.Token);
disposables.Children.Add(linked);
stream.Cancellation = linked.Token;
var response = (TCPResponse)context.HttpContext.Response;
try
{
response.OnStarting();
await stream.WriteVarIntAsync((ulong)response.StatusCode).ConfigureAwait(false);
if (Options.IncludeHeaders)
{
await stream.WriteVarIntAsync((ulong)response.Headers.Count).ConfigureAwait(false);
foreach (var header in response.Headers)
{
await stream.WriteStringAsync(header.Key).ConfigureAwait(false);
await stream.WriteStringAsync(header.Value).ConfigureAwait(false);
}
}
await stream.WriteVarIntAsync((ulong)response.Body.Length);
response.Body.Position = 0;
await response.Body.CopyToAsync(networkStream, 81920, stream.Cancellation).ConfigureAwait(false);
await networkStream.FlushAsync(stream.Cancellation).ConfigureAwait(false);
}
finally
{
response.OnCompleted();
connectedSocket.LastReceivedMessage = DateTimeOffset.UtcNow;
}
}
}
}
catch (OperationCanceledException)
{
if (!_Stopped.IsCancellationRequested)
{
throw;
}
}
finally
{
DisconnectClient(connectedSocket);
}
}
public DisconnectRequest(ConnectedSocket connectedSocket, Exception error)
: base(null)
{
_connectedSocket = connectedSocket;
_exception = error;
}
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);
}
}
