/// <summary>
/// 链接到服务器
/// </summary>
public IAwait Connect()
{
lock (syncRoot)
{
return(socket.Connect());
}
}
public void Connect()
{
if (IsConnected())
{
return;
}
Close();
try
{
_socket = new SocketAdapter(new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
{
NoDelay = true,
ReceiveTimeout = ReceiveTimeout,
SendTimeout = SendTimeout
});
_socket.Connect(Host, Port);
}
catch (Exception ex)
{
throw new GearmanConnectionException("Could not connect", ex);
}
if (!_socket.Connected)
{
throw new GearmanConnectionException("Socket not connected");
}
_isDead = false;
}
private bool ProcessStartPeerMonitoringMessage(IMessage message, ISocket socket)
{
var shouldHandle = message.Equals(KinoMessages.StartPeerMonitoring);
if (shouldHandle)
{
var payload = message.GetPayload <StartPeerMonitoringMessage>();
logger.Debug($"Received {typeof(StartPeerMonitoringMessage).Name} for node {payload.SocketIdentity.GetAnyString()}@{payload.Uri}. "
+ $"HealthUri: {payload.Health.Uri}");
var meta = new ClusterMemberMeta
{
HealthUri = payload.Health.Uri,
HeartBeatInterval = payload.Health.HeartBeatInterval,
ScaleOutUri = payload.Uri
};
meta = connectedPeerRegistry.FindOrAdd(new ReceiverIdentifier(payload.SocketIdentity), meta);
// NOTE: Starting peer monitoring may happen after quite some time after it was first added.
// To avoid immediate node disconnection, as being dead, update LastKnownHeartBeat before setting ConnectionEstablished to TRUE.
meta.LastKnownHeartBeat = DateTime.UtcNow;
meta.ConnectionEstablished = true;
StartDeadPeersCheck(meta.HeartBeatInterval);
socket.Connect(new Uri(meta.HealthUri));
logger.Debug($"Connected to node {payload.SocketIdentity.GetAnyString()}@{meta.HealthUri} for HeartBeat monitoring.");
}
return(shouldHandle);
}
public static void WrappedConnect(this ISocket socket, EndPoint remoteEP)
{
var invalidateInStoreProxy = false;
try
{
socket.Connect(remoteEP);
}
catch (SocketException ex)
{
if (ex.SocketErrorCode == SocketError.ConnectionReset ||
ex.SocketErrorCode == SocketError.TimedOut)
{
invalidateInStoreProxy = true;
}
throw ex;
}
catch (Exception ex) when(ex is ProxyException || ex is ProtocolViolationException)
{
invalidateInStoreProxy = true;
throw ex;
}
finally
{
if (invalidateInStoreProxy)
{
socket.InvalidateInStoreProxy();
}
}
}
private bool ProcessReconnectMessage(IMessage message, ISocket socket)
{
var shouldHandle = message.Equals(ConsensusMessages.ReconnectClusterMember);
if (shouldHandle)
{
var payload = message.GetPayload <ReconnectClusterMemberMessage>();
var healthInfo = nodeHealthInfo.FirstOrDefault(hi => hi.NodeUri == new Uri(payload.NewUri));
if (healthInfo != null)
{
healthInfo.UpdateLastReconnectTime();
socket.SafeDisconnect(new Uri(payload.OldUri));
socket.Connect(new Uri(payload.NewUri));
logger.Info($"Reconnected to node from {payload.OldUri} to {payload.NewUri}");
}
else
{
logger.Warn($"{message.Identity.GetAnyString()} came for unknown node: {payload.NewUri}");
}
}
return(shouldHandle);
}
/// <summary>
/// Opens the socket connection to the FTP server.
/// </summary>
private void OpenSocket()
{
_socket.Connect(hostEndPoint.Address.ToString(), hostEndPoint.Port);
string[] response = ReadFromSocket();
if (GetReturnCodeFromResponse(response) != ReturnCodes.ServiceReady)
{
throw new Exception("Error while connecting to FTP server. Server responded: " + String.Join(" ", response));
}
}
public void Simple_handshake_client_closes_connection()
{
serverDelegate.OnConnectionAction = (server, socket) =>
{
Debug.WriteLine("server OnConnection");
serverSocketDelegate = new SocketDelegate();
serverSocketDelegate.OnEndAction = () =>
{
Debug.WriteLine("serverSocket OnEnd");
socket.End();
};
serverSocketDelegate.OnCloseAction = () =>
{
Debug.WriteLine("serverSocket OnClose");
socket.Dispose();
};
return(serverSocketDelegate);
};
schedulerStartedAction = () =>
{
clientSocketDelegate.OnConnectedAction = () =>
{
Debug.WriteLine("client End");
client.End();
};
clientSocketDelegate.OnCloseAction = () =>
{
Debug.WriteLine("client OnClose");
scheduler.Stop();
};
client.Connect(ep);
};
RunScheduler();
AssertConnectionAndCleanShutdown();
}
private void btnConnect_Click(object sender, EventArgs e)
{
if (_socket.IsConnected)
{
return;
}
_socket.SetConnection(txtIPAddress.Text, 11000);
_socket.Connect();
//SetStatus(_server.IsConnected);
}
public void Connect()
{
lock (this)
{
if (_socket == null)
{
_socket = new RawSocket();
_socket.Connect(Endpoint);
}
}
}
public void Load()
{
//Dimlibs.Instance.Logger.Info("Is chat socket open? " + IsChatOpen());
Dimlibs.Instance.Logger.Info("Chat is initializing");
try
{
if (!Program.LaunchParameters.ContainsKey("-chat"))
{
TcpListener listener = new TcpListener(IPAddress.Any, _port);
listener.Start();
ThreadPool.QueueUserWorkItem(InitializeChatRelay, listener);
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
while (true)
{
if (_socket != null && _socket.IsConnected())
{
break;
}
}
if (Main.netMode == 2)
{
On.Terraria.Net.NetManager.SendToServer += NetManagerOnSendToServer;
_socket = new TcpSocket();
Netplay.SetRemoteIP("127.0.0.1");
_socket.Connect(new Terraria.Net.TcpAddress(Netplay.ServerIP, _port));
connection = new RemoteServer();
connection.Socket = _socket;
connection.ReadBuffer = new byte[ushort.MaxValue];
}
else
{
On.Terraria.Net.NetManager.SendToClient += NetManagerOnSendToClient;
_socket = new TcpSocket();
Netplay.SetRemoteIP("127.0.0.1");
_socket.Connect(new Terraria.Net.TcpAddress(Netplay.ServerIP, _port));
connection = new RemoteServer();
connection.Socket = _socket;
connection.ReadBuffer = new byte[ushort.MaxValue];
}
Dimlibs.Instance.Logger.Info("Chat is initialized and ready to go");
}
public void Connect(string ip, int port)
{
_keys = Ssui.Security.CreateAesKey();
var publicKey = _keys.PublicKey;
Task.Factory.StartNew(() => {
using (var writeStream = PoolAllocator <IWriteStream> .GetObject()) {
writeStream.ShiftRight(publicKey);
_socket.Connect(ip, port, writeStream);
}
});
}
private static void TcpConnectThread(ISocket connectSocket, EndPoint remoteEndpont, Func <ISocket, Exception, Socket> callback)
{
try
{
connectSocket.Connect(remoteEndpont);
}
catch (Exception ex)
{
callback(null, ex);
}
callback(connectSocket, null);
}
public bool StartMonitor(ref string reStr)
{
if (this.mySocket != null)
{
this.mySocket.Disconnect();
}
this.mySocket = new STcpClient();
this.mySocket.ReceiveCompleted += ReciveEventHandler;
this.mySocket.LostLink += LostLinkEventHandler;
return(mySocket.Connect(this.DevIP, this.DevPort, ref reStr));
}
public void Connect(IPEndPoint endpoint)
{
lock (this)
{
Endpoint = endpoint;
if (_socket == null)
{
_socket = new RawSocket();
_socket.Connect(endpoint);
}
}
}
public virtual void Connect(CancellationToken token)
{
Debug.Assert(currentWriteCopier == null);
Debug.Assert(inprogressResponse == null);
Debug.Assert(readQueue.Count == 0);
LogTo.Info($"Connecting node to {name}");
socket.Connect(endpoint, token);
mustReconnect = false;
IsAlive = true;
}
// Use this for initialization
private void Start()
{
Debug.LogError("start");
IPackage iPackage = new Package();
socket = new TcpConnection(iPackage);
socket.StateChangeHandler = OnStateChange;
socket.Connect("127.0.0.1", 5077);
//_register.Regist(100, OnMsg);
//socket.DisConnect();
}
/// <summary>
/// Send to server request to connect
/// </summary>
/// <param name="ep">server endpoint</param>
/// <returns></returns>
public bool BeginConnect(IPEndPoint ep)
{
try {
_client.Connect(ep);
}
catch {
return(false);
}
var buffer = Message.Handshake;
var p = new Packet(buffer);
_client.Send(p.Serialize());
return(true);
}
/// <summary>
/// Connects the socket to the specified port. This is used to connect the python script to Unity.
/// </summary>
/// <returns>true if connected.</returns>
public bool Connect()
{
try
{
socket.Connect("localhost", PORT);
Debug.Log("Established tcpSocket Connection with Python");
return(true);
}
catch (Exception e)
{
Debug.Log(e);
}
return(false);
}
public string LookupDotComDomain(string domainName, int port, string whoisServer,
string whoisServerLookupQueryPrefix, int responseBufferSizeInBytes)
{
Guard.WhenArgument(domainName, "DomainName").IsNullOrEmpty().Throw();
if (domainName.StartsWith(WhoisConstants.ForbiddenDomainStartSymbol))
{
throw new ArgumentException("Domain name cannot start with hyphen.");
}
if (!domainName.ToLower().EndsWith(WhoisConstants.DomainEndPattern))
{
throw new ArgumentException("Domain name should be a .com domain.");
}
var regex = new Regex(WhoisConstants.RegexDomainPattern);
// remove ".com"
if (!regex.IsMatch(domainName.ToLower().Substring(0, domainName.Length - 4)))
{
throw new ArgumentException("Domain should only contain letters, numbers or hyphen.");
}
Guard.WhenArgument(domainName.Length, "DomainName").IsLessThan(WhoisConstants.MinimumDomainNameLength).Throw();
Guard.WhenArgument(domainName.Length, "DomainName").IsGreaterThan(WhoisConstants.MaximumDomainNameLength).Throw();
Guard.WhenArgument(port, "Port").IsLessThan(WhoisConstants.TcpMinPort).Throw();
Guard.WhenArgument(port, "Port").IsGreaterThan(WhoisConstants.TcpMaxPort).Throw();
Guard.WhenArgument(whoisServer, "WhoisServer").IsNullOrEmpty().Throw();
Guard.WhenArgument(whoisServerLookupQueryPrefix, "WhoisServerLookupQueryPrefix").IsNullOrEmpty().Throw();
Guard.WhenArgument(responseBufferSizeInBytes, "ResponseBufferSizeInBytes").IsLessThan(WhoisConstants.MinimumResponseBufferSizeInBytes).Throw();
Guard.WhenArgument(responseBufferSizeInBytes, "ResponseBufferSizeInBytes").IsGreaterThan(WhoisConstants.MaximumResponseBufferSizeInBytes).Throw();
socket.Connect(whoisServer, port);
byte[] query = Encoding.ASCII.GetBytes(whoisServerLookupQueryPrefix + domainName + Environment.NewLine);
socket.Send(query);
byte[] responseBytes = new byte[responseBufferSizeInBytes];
socket.Receive(responseBytes);
socket.Dispose();
string humanReadableResponse = Encoding.UTF8.GetString(responseBytes);
return(humanReadableResponse);
}
public virtual void Connect(CancellationToken token)
{
Debug.Assert(currentWriteCopier == null);
Debug.Assert(inprogressResponse == null);
Debug.Assert(readQueue.Count == 0);
if (LogDebugEnabled)
{
log.Debug("Connecting node to " + endpoint);
}
socket.Connect(endpoint, token);
mustReconnect = false;
IsAlive = true;
}
public void InitSocketManager(ISocketManager socketManager)
{
Socket = socketManager.Create("http://192.168.1.3:3000/");
Socket.OnConnect = () =>
{
Socket.Emit("shoes2", new { F**k = "Yopu" });
};
Socket.On <Boo>("shoes", a =>
{
});
Socket.On <Boo>("shoes3", a =>
{
});
Socket.Connect();
}
private bool ForwardMessageAway(ExternalRouteLookupRequest lookupRequest, Message message, ISocket scaleOutBackend)
{
var routes = message.Distribution == DistributionPattern.Broadcast && !MessageCameFromLocalActor(message)
? Enumerable.Empty <PeerConnection>()
: externalRoutingTable.FindRoutes(lookupRequest);
foreach (var route in routes)
{
try
{
if (!route.Connected)
{
scaleOutBackend.Connect(route.Node.Uri, waitUntilConnected: true);
route.Connected = true;
clusterServices.GetClusterHealthMonitor()
.StartPeerMonitoring(new Node(route.Node.Uri, route.Node.SocketIdentity), route.Health);
}
message.SetSocketIdentity(route.Node.SocketIdentity);
message.AddHop();
message.PushRouterAddress(scaleOutConfigurationProvider.GetScaleOutAddress());
message.SignMessage(securityProvider);
scaleOutBackend.SendMessage(message);
ForwardedToOtherNode(message);
}
catch (TimeoutException err)
{
clusterServices.GetClusterHealthMonitor()
.ScheduleConnectivityCheck(new ReceiverIdentifier(route.Node.SocketIdentity));
logger.Error(err);
}
catch (HostUnreachableException err)
{
var unregMessage = new UnregisterUnreachableNodeMessage {
ReceiverNodeIdentity = route.Node.SocketIdentity
};
TryHandleServiceMessage(Message.Create(unregMessage).As <Message>(), scaleOutBackend);
logger.Error(err);
}
}
return(routes.Any());
}
// Connect(u32 socket, buffer<nn::socket::sockaddr_in, 0x21, 0x10>) -> (i32 ret, u32 bsd_errno)
public ResultCode Connect(ServiceCtx context)
{
int socketFd = context.RequestData.ReadInt32();
(ulong bufferPosition, ulong bufferSize) = context.Request.GetBufferType0x21();
LinuxError errno = LinuxError.EBADF;
ISocket socket = _context.RetrieveSocket(socketFd);
if (socket != null)
{
IPEndPoint endPoint = context.Memory.Read <BsdSockAddr>(bufferPosition).ToIPEndPoint();
errno = socket.Connect(endPoint);
}
return(WriteBsdResult(context, 0, errno));
}
public IConnection Connect(EndPoint endPoint)
{
if (active)
{
throw new InvalidOperationException("Peer is already active");
}
active = true;
socket.Connect(endPoint);
Connection connection = CreateNewConnection(endPoint);
connection.State = ConnectionState.Connecting;
// update now to send connectRequest command
connection.Update();
return(connection);
}
private bool SendMessageAway(IEnumerable <PeerConnection> routes, Message message, ISocket scaleOutBackend)
{
foreach (var route in routes)
{
try
{
if (!route.Connected)
{
scaleOutBackend.Connect(route.Node.Uri, waitUntilConnected: true);
route.Connected = true;
clusterServices.GetClusterHealthMonitor()
.StartPeerMonitoring(new Node(route.Node.Uri, route.Node.SocketIdentity), route.Health);
}
message.SetSocketIdentity(route.Node.SocketIdentity);
message.AddHop();
message.PushRouterAddress(scaleOutConfigurationProvider.GetScaleOutAddress());
message.SignMessage(securityProvider);
scaleOutBackend.SendMessage(message);
ForwardedToOtherNode(message);
}
catch (TimeoutException err)
{
clusterServices.GetClusterHealthMonitor()
.ScheduleConnectivityCheck(new ReceiverIdentifier(route.Node.SocketIdentity));
logger.Error(err);
}
catch (HostUnreachableException err)
{
var unregMessage = new UnregisterUnreachableNodeMessage {
ReceiverNodeIdentity = route.Node.SocketIdentity
};
TryHandleServiceMessage(Message.Create(unregMessage).As <Message>(), scaleOutBackend);
logger.Error(err);
}
}
return(routes.Any());
}
public IConnection Connect(IEndPoint endPoint)
{
if (_active)
{
throw new InvalidOperationException("Peer is already active");
}
if (endPoint == null)
{
throw new ArgumentNullException(nameof(endPoint));
}
_active = true;
_socket.Connect(endPoint);
var connection = CreateNewConnection(endPoint);
connection.State = ConnectionState.Connecting;
// update now to send connectRequest command
connection.Update();
return(connection);
}
/// <summary>
/// Expect a call of the Connect method and simulate a correct response by the FTP server.
/// </summary>
/// <param name="mockSocket">The fake socket.</param>
private void ExpectConnect(ISocket mockSocket)
{
mockSocket.Connect(TCP_HOST, TCP_PORT);
ExpectReceive(mockSocket, "220 This is a fake FTP server");
}
public void Connect()
{
lock (SyncObject)
{
if (IsConnected())
return;
Close();
try
{
_socket = new SocketAdapter(new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
{
NoDelay = true,
ReceiveTimeout = ReceiveTimeout,
SendTimeout = SendTimeout
});
_socket.Connect(Host, Port);
}
catch (Exception ex)
{
throw new GearmanConnectionException("Could not connect", ex);
}
if (!_socket.Connected)
{
throw new GearmanConnectionException("Socket not connected");
}
_isDead = false;
}
}
private static void TcpConnectThread(ISocket connectSocket, EndPoint remoteEndpont, Func<ISocket, Exception, Socket> callback)
{
try
{
connectSocket.Connect(remoteEndpont);
}
catch (Exception ex)
{
callback(null, ex);
}
callback(connectSocket, null);
}
public Task Connect() => _socket.Connect();
private bool RegisterExternalRoutes(IMessage message, ISocket scaleOutBackend)
{
var shouldHandle = IsExternalRouteRegistration(message);
if (shouldHandle)
{
var payload = message.GetPayload<RegisterExternalMessageRouteMessage>();
var handlerSocketIdentifier = new SocketIdentifier(payload.SocketIdentity);
var uri = new Uri(payload.Uri);
foreach (var registration in payload.MessageContracts)
{
try
{
var messageHandlerIdentifier = new MessageIdentifier(registration.Version, registration.Identity);
externalRoutingTable.AddMessageRoute(messageHandlerIdentifier, handlerSocketIdentifier, uri);
scaleOutBackend.Connect(uri);
}
catch (Exception err)
{
logger.Error(err);
}
}
}
return shouldHandle;
}
private void ProxyThis(ISocket instream, ISocket outstream, AutoResetEvent readyToConnect)
{
Logger.Debug("Starting Proxy from " + instream + " to " + outstream);
int read = 1;
Closed = false;
try
{
var inBuffer = new byte[_bufferSize];
// listen for incoming connection
if (!instream.Connected)
{
readyToConnect.Set();
Logger.Debug("Listening for incoming connections");
instream.ListenOnce();
Logger.Debug("Connected incoming");
}
// connect to outgoing endpoint and start the reverse proxy
if (!outstream.Connected)
{
outstream.Connect();
Logger.Debug("Connected outgoing");
_outRunner.Start();
Logger.Debug("Started Reverse Proxy");
}
while (read > 0)
{
// Read from instream
if (read > 0)
{
try
{
read = instream.Read(inBuffer, _bufferSize);
#if DEBUG
// Logger.Debug("Read " + read + " bytes from " + instream);
#endif
}
catch (Exception ex)
{
Logger.Error("Failed to read data from stream (" + instream + "), closing proxy : " + ex.Message);
break;
}
if (read > 0)
{
try
{
outstream.Send(inBuffer, read);
#if DEBUG
//Logger.Debug("Wrote " + read + " bytes to " + outstream);
#endif
}
catch (Exception ex)
{
Logger.Error("Failed to send data through stream (" + instream + ") , closing proxy : " + ex.Message);
break;
}
}
}
else
{
Logger.Warn("Read no data from (" + instream + "), closing proxy");
}
}
}
catch (Exception ex)
{
Logger.Error("Thread caught exception while processing : " + ex.Message, ex);
}
finally
{
try
{
instream.Close();
}
catch (Exception ex)
{
Logger.Error("Caught Error closing stream (" + instream + ") : " + ex.Message, ex);
}
try
{
outstream.Close();
}
catch (Exception ex)
{
Logger.Error("Caught Error closing stream (" + outstream + ") : " + ex.Message, ex);
}
}
}
private void ProxyThis(ISocket instream, ISocket outstream, AutoResetEvent readyToConnect)
{
Logger.Debug("Starting Proxy from " + instream + " to " + outstream);
int read = 1;
Closed = false;
try
{
var inBuffer = new byte[_bufferSize];
// listen for incoming connection
if (!instream.Connected)
{
readyToConnect.Set();
Logger.Debug("Listening for incoming connections");
instream.ListenOnce();
Logger.Debug("Connected incoming");
}
// connect to outgoing endpoint and start the reverse proxy
if (!outstream.Connected)
{
outstream.Connect();
Logger.Debug("Connected outgoing");
_outRunner.Start();
Logger.Debug("Started Reverse Proxy");
}
while (read > 0)
{
// Read from instream
if (read > 0)
{
try
{
read = instream.Read(inBuffer, _bufferSize);
#if DEBUG
// Logger.Debug("Read " + read + " bytes from " + instream);
#endif
}
catch (Exception ex)
{
Logger.Error("Failed to read data from stream (" + instream + "), closing proxy : " + ex.Message);
break;
}
if (read > 0)
{
try
{
outstream.Send(inBuffer, read);
#if DEBUG
//Logger.Debug("Wrote " + read + " bytes to " + outstream);
#endif
}
catch (Exception ex)
{
Logger.Error("Failed to send data through stream (" + instream + ") , closing proxy : " + ex.Message);
break;
}
}
}
else
{
Logger.Warn("Read no data from (" + instream + "), closing proxy");
}
}
}
catch (Exception ex)
{
Logger.Error("Thread caught exception while processing : " + ex.Message, ex);
}
finally
{
try
{
instream.Close();
}
catch (Exception ex)
{
Logger.Error("Caught Error closing stream (" + instream + ") : " + ex.Message, ex);
}
try
{
outstream.Close();
}
catch (Exception ex)
{
Logger.Error("Caught Error closing stream (" + outstream + ") : " + ex.Message, ex);
}
}
}
public bool Detect()
{
try
{
_socket = CreateSocket();
_working = true;
Log("start working");
_socket.Connect(new TcpAddress(IPAddress.Loopback, TShock.Config.ServerPort));
if (_socket.IsConnected())
{
Log("connected");
}
else
{
throw new SocketException(ConnectionRefusedCode);
}
}
catch (SocketException ex)
{
if (ex.ErrorCode == ConnectionRefusedCode)
{
Log("connection failed");
}
Log(ex.ToString());
CloseSocket();
return(true);
}
try
{
_socket.AsyncSend(_writeBuffer, 0, _versionStrLength, SendCallback);
_socket.AsyncReceive(_readBuffer, 0, _readBuffer.Length, ReceiveCallback);
for (var i = 0; i < 3; i++)
{
if (!_working)
{
break;
}
Thread.Sleep(1000);
}
}
catch (Exception ex)
{
Log("Unhandled exception in socket send & receive");
Log(ex.ToString());
}
finally
{
CloseSocket();
}
return(_working || _status);
}
