public static TcpClient Connect( string ip, ushort port, int timeoutMSec)
{
TimeoutObject.Reset(); // 이벤트 상태를 초기화
socketexception = null; // 예외발생
string serverip = ip; // IP
int serverport = port;
TcpClient tcpclient = new TcpClient();
// 비동기 접속, CallBackMethod
tcpclient.BeginConnect( serverip, serverport, new AsyncCallback( CallBackMethod), tcpclient);
if ( TimeoutObject.WaitOne( timeoutMSec, false)) // 동기화시킨다. timeoutMSec 동안 기다린다.
{
if ( IsConnectionSuccessful) // 접속되는 소켓을
return tcpclient;
else
throw socketexception; // 안되면, 안된 예외를
}
else // 시간이 초과되면
{
tcpclient.Close();
throw new TimeoutException( "TimeOut Exception");
}
}
public TCPClient(string ipAddress, int port, AsyncCallback connectionHandler)
{
client = new TcpClient();
Debug.Log("lool");
client.BeginConnect(ipAddress, port, connectionHandler, client);
Debug.Log("begin");
}
public static bool Connect(IPEndPoint remoteEndPoint, int timeoutMSec)
{
TimeoutObject.Reset();
socketexception = null;
string serverip = Convert.ToString(remoteEndPoint.Address);
int serverport = remoteEndPoint.Port;
TcpClient tcpclient = new TcpClient();
tcpclient.BeginConnect(serverip, serverport, new AsyncCallback(CallBackMethod), tcpclient);
if (TimeoutObject.WaitOne(timeoutMSec, false))
{
if (IsConnectionSuccessful)
{
tcpclient.Close();
return true;
}
else
{
tcpclient.Close();
return false;
}
}
else
{
tcpclient.Close();
return false;
}
}
private void HandleConnectionPingCompleted(object sender, PingCompletedEventArgs e)
{
if (m_TcpClient != null)
{
Disconnect();
}
m_TcpClient = new TcpClient();
m_TcpClient.BeginConnect(Hostname, Port, ConnectComplete, null);
}
/// <summary>
/// 连接服务器
/// </summary>
void ConnectServer(string host, int port) {
client = null;
client = new TcpClient();
client.SendTimeout = 1000;
client.ReceiveTimeout = 1000;
client.NoDelay = true;
try {
client.BeginConnect(host, port, new AsyncCallback(OnConnect), null);
} catch (Exception e) {
Close(); Debug.LogError(e.Message);
}
}
private bool TestConnection(){
TcpClient client = new TcpClient();
bool result = false;
try
{
client.BeginConnect(ip, port, null, null).AsyncWaitHandle.WaitOne(3000);
result = client.Connected;
}
catch { }
finally {
client.Close ();
}
return result;
}
public void setupSocket()
{
// try {
// host = hostField.text;
// if (string.IsNullOrEmpty(host))
// host = "localhost";
// port = int.Parse(portField.text);
// mySocket = new TcpClient(host, port);
// theStream = mySocket.GetStream();
// theWriter = new StreamWriter(theStream);
// theReader = new StreamReader(theStream);
// theReader.BaseStream.ReadTimeout = 1000;
// socketReady = true;
// Debug.Log ("Connected");
// menu.SetActive(false);
// world.SetActive(true);
// EventsManager.em.speedController.SetActive (true);
// }
try {
host = hostField.text;
if (string.IsNullOrEmpty(host))
host = "localhost";
port = int.Parse(portField.text);
mySocket = new TcpClient();
var result = mySocket.BeginConnect(host, port, null, null);
bool success = result.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(2));
if (!success)
throw new Exception("Connection timed out.");
mySocket.EndConnect(result);
theStream = mySocket.GetStream();
theWriter = new StreamWriter(theStream);
theReader = new StreamReader(theStream);
theReader.BaseStream.ReadTimeout = 1000;
socketReady = true;
Debug.Log ("Connected");
menu.SetActive(false);
world.SetActive(true);
EventsManager.em.speedController.SetActive (true);
EventsManager.em.dallesPanels.SetActive (true);
}
catch (Exception e) {
Debug.Log("Socket error: " + e);
EventsManager.em.msgBox.ServerMessage("Connection failed: " + e.Message, Color.red);
//Application.LoadLevel(0);
}
}
public void Connect(string host,int port)
{
this.Host = host;
this.Port = port;
begin = DateTime.Now;
callConnectioneFun = false;
callTimeOutFun = false;
isConnectioned = false;
isbegin = true;
isConnectCall = true;
//Debug.Log("begin connect:" + host + " :" + port + " time:" + begin.ToString());
if (client != null)
client.Close();
client = new TcpClient();
client.BeginConnect(host, port, new AsyncCallback(OnConnected), client);
}
internal void Connect()
{
try
{
if (mSystemStop)
{
return;
}
m_Client = new TcpClient();
m_Client.BeginConnect(mDev.ip, mDev.port, new AsyncCallback(ConnectCallback), null);
SendMsg(SocketMsgTypeE.Connection, SocketConnectStatusE.连接中, null);
_mLog.Status(true, "连接中");
}
catch (Exception e)
{
//Console.WriteLine("连接失败" + DateTime.Now.ToString() + e.StackTrace);
}
}
private void btnVerbind_Click(object sender, EventArgs e)
{
/*try
* {
* IPAddress[] ent = Dns.GetHostAddresses("pieterjandeclippel.be");
* return;*/
myTcpClient = new TcpClient();
myTcpClient.BeginConnect(IPAddress.Parse(txtServerAdres.Text), 8001, new AsyncCallback(GetConnectedToServerCallback), myTcpClient);
btnVerbind.Enabled = false;
btnInloggen.Enabled = true;
btnRegistreren.Enabled = true;
this.AcceptButton = btnInloggen;
/*}
* catch(Exception ex)
* {
* txtOntvangen.AppendText(ex.Message + Environment.NewLine);
* }*/
}
/// <summary>
/// Establishes a connection with the server and initiates callback methods.
/// </summary>
void ConnectGameServer()
{
//Check for disconnect.
if (playerSocket != null)
{
if (playerSocket.Connected || isConnected)
{
return;
}
playerSocket.Close();
playerSocket = null;
}
playerSocket = new TcpClient();
playerSocket.ReceiveBufferSize = 4096;
playerSocket.SendBufferSize = 4096;
playerSocket.NoDelay = false;
Array.Resize(ref asyncBuff, 8192);
playerSocket.BeginConnect(serverIP, serverPort, new AsyncCallback(ConnectCallback), playerSocket);
isConnected = true;
}
public void connect()
{
try
{
IPEndPoint ipEndPoint = (IPEndPoint) new IPEndPoint(0, 0).Create(_remoteAddress);
tcpClient.BeginConnect(ipEndPoint.Address, ipEndPoint.Port, new AsyncCallback(ConnectCallback), tcpClient);
}
catch (SocketException e)
{
logger.Warn(e.Message);
Init();
}
catch (ObjectDisposedException e)
{
logger.Warn(e.Message);
Init();
}
catch (NullReferenceException)
{
}
}
public void login(string host, int port)
{
PasswordAuthentication auth = listener.GetPasswordAuthentication();
if (null != auth)
{
try
{
socketConnection = new TcpClient();
socketConnection.BeginConnect(host, port, new AsyncCallback(OnConnect), auth);
}
catch (Exception e)
{
throw e;
}
}
else
{
throw new Exception("Password Authentication was null");
}
}
/// <summary>
/// Copy to
/// </summary>
/// <param name="stream">Stream</param>
/// <param name="endPoint">End Point</param>
/// <param name="timeout">Timeout</param>
public static bool ConnectoAndCopyTo(this Stream stream, IPEndPoint endPoint, TimeSpan timeout)
{
using (var client = new TcpClient())
{
var result = client.BeginConnect(endPoint.Address, endPoint.Port, null, null);
var success = result.AsyncWaitHandle.WaitOne(timeout);
if (success)
{
client.EndConnect(result);
var s = client.GetStream();
stream.CopyTo(s);
s.Flush();
return(true);
}
}
return(false);
}
/// <summary>
/// 连接到服务器
/// </summary>
/// <param name="ip">服务器IP</param>
/// <returns></returns>
public void Connect()
{
//disCountTimer ();
try
{
tcpclient = new TcpClient();
//防止延迟,即时发送!
tcpclient.NoDelay = true;
tcpclient.BeginConnect(APIS.socketUrl, 10122, new AsyncCallback(ConnectCallback), tcpclient);
}
catch (Exception ex)
{
//设置标志,连接服务端失败!
showMessageTip("服务器断开连接，请重新运行程序或稍后再试");
MyDebug.Log("11111111111111111111111111111111");
// ReConnectScript.getInstance().ReConnectToServer();
Debug.Log(ex.ToString());
isConnected = false;
}
}
/// <summary>
/// 连接服务器
/// </summary>
void ConnectServer(string host, int port)
{
OnRegister();
string newHost;
AddressFamily af;
getIPType(host, out newHost, out af);
client = null;
client = new TcpClient(af);
client.SendTimeout = 1000;
client.ReceiveTimeout = 1000;
client.NoDelay = true;
try
{
client.BeginConnect(newHost, port, new AsyncCallback(OnConnect), null);
}
catch (Exception e)
{
OnDisconnected(DisType.Exception, e.Message);
}
}
/// <summary>
/// 异步方式与服务器进行连接
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void connectWork_DoWork(object sender, DoWorkEventArgs e)
{
client = new TcpClient();
IAsyncResult result = client.BeginConnect(serverIP, 8889, null, null);
while (!result.IsCompleted)
{
Thread.Sleep(100);
AddStatus(".");
}
try
{
client.EndConnect(result);
e.Result = "success";
}
catch (Exception ex)
{
e.Result = ex.Message;
return;
}
}
public void Process(IStreamServer server)
{
var client = new TcpClient();
client.BeginConnect(Address, Port, ar =>
{
try
{
client.EndConnect(ar);
server.Streams[StreamIndex] = client.GetStream();
var connectResult = new ConnectResponse(StreamIndex, LocalEndPoint, client.Client.RemoteEndPoint.ToString());
connectResult.Process(server);
server.WriteMessage(connectResult);
}
catch (Exception ex)
{
Debug.Print(DateTime.Now + " " + Environment.MachineName + ": " + ex);
server.WriteMessage(new StreamError(StreamIndex, ex));
}
}, null);
}
void ConnectToGameServer()
{
if (PlayerSocket != null)
{
if (PlayerSocket.Connected || IsConnected)
{
return;
}
PlayerSocket.Close();
PlayerSocket = null;
}
PlayerSocket = new TcpClient();
PlayerSocket.ReceiveBufferSize = 4096;
PlayerSocket.SendBufferSize = 4096;
PlayerSocket.NoDelay = false;
Array.Resize(ref asyncBuff, 8192);
PlayerSocket.BeginConnect(ServerIP, ServerPort, new AsyncCallback(ConnectCallback), PlayerSocket);
IsConnected = true;
MenuManager.instance._menu = MenuManager.Menu.Home;
}
public static bool CheckHostPort(string hostname, int port, int PortScanTimeout = 2000)
{
using (var client = new TcpClient())
{
try
{
var result = client.BeginConnect(hostname, port, null, null);
var success = result.AsyncWaitHandle.WaitOne(PortScanTimeout);
if (!success)
{
return(false);
}
client.EndConnect(result);
}
catch
{
return(false);
}
return(true);
}
}
public async Task <bool> IsPortOpen(string host, int port)
{
using (var client = new TcpClient())
{
try
{
var res = client.BeginConnect(host, port, null, null);
var ok = await Task.Run(() => res.AsyncWaitHandle.WaitOne(TimeOut));
if (ok)
{
client.EndConnect(res);
}
return(ok);
}
catch
{
return(false);
}
}
}
private void Connect()
{
_tcpClient = new TcpClient();
IAsyncResult asyncResult = _tcpClient.BeginConnect(RemoteAddress, RemotePort, null, null);
System.Threading.WaitHandle waitHandle = asyncResult.AsyncWaitHandle;
try
{
if (!asyncResult.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(_timeout), false))
{
_tcpClient.Close();
throw new TimeoutException(string.Format("Failed to connect to {0}:{1} within {2} seconds.", RemoteAddress, RemotePort, _timeout));
}
_tcpClient.EndConnect(asyncResult);
}
finally
{
waitHandle.Close();
}
}
/// <summary>
/// 采用Socket方式，测试数据库服务器能否建立连接
/// </summary>
/// <param name="host">服务器主机名或IP</param>
/// <param name="port">端口号</param>
/// <param name="millisecondsTimeout">等待时间，单位：毫秒</param>
/// <returns>返回一个结果表示该地址能否建立连接</returns>
public static bool TestConnection(string host, int port, int millisecondsTimeout)
{
//判断是不是本机
host = _localhost.Contains(host) ? "127.0.0.1" : host;
//创建TcpClient对象
using (var client = new TcpClient())
{
try
{
//开始连接
var ar = client.BeginConnect(host, port, null, null);
//设置等待时间
ar.AsyncWaitHandle.WaitOne(millisecondsTimeout);
return(client.Connected);
}
catch (Exception)
{
return(false);
}
}
}
public void Awake()
{
instance = this;
Debug.Log("hellllooooo?");
if (serverIp == null)
{ // Server: start listening for connections
this.isServer = true;
listener = new TcpListener(System.Net.IPAddress.Any, Globals.port);
listener.Start();
listener.BeginAcceptTcpClient(OnServerConnect, null);
Debug.Log("on wig?");
}
else
{ // Client: try connecting to the server
TcpClient client = new TcpClient();
TcpConnectedClient connectedClient = new TcpConnectedClient(client);
clientList.Add(connectedClient);
client.BeginConnect(serverIp, Globals.port, (ar) => connectedClient.EndConnect(ar), null);
Debug.Log("oy bruv we in");
}
}
public static bool TryConnect(this TcpClient tcpClient, IPEndPoint endPoint, int timeout)
{
IAsyncResult ar = tcpClient.BeginConnect(endPoint.Address, endPoint.Port, null, null);
var wh = ar.AsyncWaitHandle;
try
{
if (!ar.AsyncWaitHandle.WaitOne(TimeSpan.FromMilliseconds(timeout), false))
{
tcpClient.Close();
return(false);
}
tcpClient.EndConnect(ar);
return(true);
}
finally
{
wh.Close();
}
}
public override void Establish()
{
if (IsConnected)
{
return;
}
try
{
m_oNetObject.BeginConnect(Address, Port, new AsyncCallback(ConnectCallback), this);
NetworkAction?.StateChanged(State.Connecting, new StateObject(this));
return;
}
catch (Exception)
{
}
NetworkAction?.StateChanged(State.Error, new StateObject(this));
}
public void Connect()
{
if (_tcp != null)
{
return;
}
_tcp = new TcpClient();
try
{
Debug.Log("NS: Connecting");
_tcp.BeginConnect(Host, Port, new AsyncCallback(ConnectCallback), null);
}
catch (Exception ex)
{
_tcp = null;
Debug.LogError($"NS: {ex.Message}");
Message(this, new StateChangedEventArgs(State.FAILED_TO_CONNECT, "failed to connect"));
}
}
/// <summary>
/// Connects to server with specified IP.
/// </summary>
/// <returns>Hostname of server</returns>
public string ConnectToServer(int timeout = 0)
{
try
{
client = new TcpClient();
client.NoDelay = true;
Stopwatch stp = Stopwatch.StartNew();
if (timeout > 0)
{
var result = client.BeginConnect(IP, Port, null, null);
var success = result.AsyncWaitHandle.WaitOne(TimeSpan.FromMilliseconds(timeout));
if (!success)
{
//client.EndConnect(result);
client.Close();
throw new Exception("Failed to connect.");
}
else
{
client.EndConnect(result);
}
}
else
{
client.Connect(IP, Port);
}
stp.Restart();
IsConnectedToServer = true;
client.SendBufferSize = BufferSize;
client.ReceiveBufferSize = BufferSize;
Debug.WriteLine("Succesfully Connected to: " + IP + " on Port: " + Port + " time: " + stp.Elapsed.TotalMilliseconds + " ms");
return(IP);
}
catch (Exception e)
{
//Debug.WriteLine("Connection Failed: " + e.ToString());
return("");
}
}
void CreateConnection(string host, int port)
{
try
{
client = new TcpClient();
client.NoDelay = true;
//client.Connect(IPAddress.Parse(host), port);
IAsyncResult result = client.BeginConnect(IPAddress.Parse(host), port, null, null);
__connected = result.AsyncWaitHandle.WaitOne(1000, false);
Debug.Log("tryed");
if (__connected)
{
Debug.Log("connect");
client.EndConnect(result);
}
else
{
client.Close();
}
}
catch (SocketException ex)
{
__connected = false;
Debug.Log("connect error: " + ex.Message);
client.Close();
return;
}
if (__connected)
{
stream = client.GetStream();
if (recvProcess == null)
{
recvProcess = new Thread(new ThreadStart(RecvProcess));
recvProcess.IsBackground = true;
recvProcess.Start();
}
}
}
public static bool p(string url, int port)
{
int timeout = 1000;
var result = false;
using (var client = new TcpClient())
{
try
{
client.ReceiveTimeout = timeout * 1000;
client.SendTimeout = timeout * 1000;
var asyncResult = client.BeginConnect(url, port, null, null);
var waitHandle = asyncResult.AsyncWaitHandle;
try
{
if (!asyncResult.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(timeout), false))
{
// wait handle didn't came back in time
client.Close();
}
else
{
// The result was positiv
result = client.Connected;
}
// ensure the ending-call
client.EndConnect(asyncResult);
}
finally
{
// Ensure to close the wait handle.
waitHandle.Close();
}
}
catch
{
}
}
return(result);
}
/// <summary>
/// 驗證LDAP Server 是否 Alive
/// </summary>
/// <returns></returns>
public bool isLdapServerConnected(string serverip, string ldapport)
{
//bool result = Authenticate.Instance.isLdapServerConnected();
bool validated = false;
int port;
if (string.IsNullOrEmpty(ldapport))
{
port = 389;
}
else
{
int.TryParse(ldapport, out port);
}
var client = new TcpClient();
try
{
var result = client.BeginConnect(serverip, port, null, null);
result.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(2)); //wait 2 second
if (client.Connected)
{
//throw new Exception("Failed to connect.");
validated = true;
}
}
catch (Exception e)
{
validated = false;
}
finally
{
// we have connected
//client.EndConnect(result);
client.Close();
}
return(validated);
}
public void Connect()
{
if (iBeginWait == 2)
{
return;
}
try
{
this._client = new TcpClient();
_client.ReceiveTimeout = 10;
connectDone.Reset();
LogInfo.SetText("Establishing Connection to " + _remote.ToString());
_client.BeginConnect(_remote, _port, new AsyncCallback(ConnectCallback), _client); //异步连接
if (iBeginWait != 2)
{
iBeginWait = 1;
}
connectDone.WaitOne(); //当在派生类中重写时，阻止当前线程，直到当前的 WaitHandle 收到信号
if (iBeginWait != 2)
{
iBeginWait = 0;
}
if (_client?.Client != null && (_client.Connected))
{
workStream = _client.GetStream();
LogInfo.SetText("Connection established " + _remote.ToString());
AsyncRead(_client); //异步读取数据
}
}
catch (Exception e)
{
LogInfo.SetText("连接服务器失败，错误为： " + e.Message);
Thread.Sleep(100);
Connected = false;
}
}
public static IEnumerator ConnectServer()
{
_client = new TcpClient();
//异步连接
IAsyncResult async = _client.BeginConnect("101.200.220.209", 60002, null, null);
while (!async.IsCompleted)
{
Debug.Log("连接服务器中");
yield return(null);
}
try
{
_client.EndConnect(async);
}
catch (Exception ex)
{
isConnected = false;
yield break;
}
//获取通信流
try
{
_stream = _client.GetStream();
}
catch (Exception ex)
{
isConnected = false;
yield break;
}
if (_stream == null)
{
isConnected = false;
yield break;
}
// 连接成功
isConnected = true;
}
public void TcpOpen()
{
IsTCPLink = false;
if (_MASTER != null)
{
_MASTER.Dispose();
}
if (tcpClient != null)
{
tcpClient.Close();
}
if (LAN.IsLanLink)
{
try
{
tcpClient = new TcpClient();
//开始一个对远程主机连接的异步请求
IAsyncResult asyncResult = tcpClient.BeginConnect(DefaultBase.IPAddress, DefaultBase.TCPPort, null, null);
asyncResult.AsyncWaitHandle.WaitOne(500, true);
if (!asyncResult.IsCompleted)
{
tcpClient.Close();
IsTCPLink = false;
Logger.Info("连接服务器失败!:IP" + DefaultBase.IPAddress + ",port:" + DefaultBase.TCPPort);
return;
}
//由TCP客户端创建Modbus TCP的主
_MASTER = ModbusIpMaster.CreateIp(tcpClient);
_MASTER.Transport.Retries = 0; //不必调试
_MASTER.Transport.ReadTimeout = 1500; //读取超时
IsTCPLink = true;
}
catch (Exception ex)
{
Logger.Error(ex);
IsTCPLink = false;
tcpClient.Close();
}
}
}
public void Connect()
{
int origin = Interlocked.Exchange(ref _state, _connecting);
if (!(origin == _none || origin == _closed))
{
Close(false); // connecting with wrong state
throw new InvalidOperationException("This tcp socket client is in invalid state when connecting.");
}
Clean(); // force to clean
_tcpClient = _localEndPoint != null ? new TcpClient(_localEndPoint) :
new TcpClient(_remoteEndPoint.Address.AddressFamily);
SetSocketOptions();
if (_receiveBuffer == default(ArraySegment <byte>))
{
_receiveBuffer = _configuration.BufferManager.BorrowBuffer();
}
_receiveBufferOffset = 0;
var ar = _tcpClient.BeginConnect(_remoteEndPoint.Address, _remoteEndPoint.Port, null, _tcpClient);
if (!ar.AsyncWaitHandle.WaitOne(ConnectTimeout))
{
Close(false); // connect timeout
throw new TimeoutException(string.Format(
"Connect to [{0}] timeout [{1}].", _remoteEndPoint, ConnectTimeout));
}
_tcpClient.EndConnect(ar);
if (Interlocked.CompareExchange(ref _state, _connected, _connecting) != _connecting)
{
Close(false);// connected with wrong state
throw new InvalidOperationException("This tcp socket client is in invalid state when connected.");
}
HandleTcpServerConnected();
}
/// <summary>
/// Starts the network handler. (Connects to a minecraft server)
/// </summary>
public void Start()
{
try {
_baseSock = new TcpClient();
var ar = _baseSock.BeginConnect(_mainMc.ServerIp, _mainMc.ServerPort, null, null);
using (var wh = ar.AsyncWaitHandle) {
if (!ar.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(5), false))
{
_baseSock.Close();
RaiseSocketError(this, "Failed to connect: Connection Timeout");
return;
}
_baseSock.EndConnect(ar);
}
} catch (Exception e) {
RaiseSocketError(this, "Failed to connect: " + e.Message);
return;
}
_mainMc.Running = true;
RaiseSocketInfo(this, "Connected to server.");
RaiseSocketDebug(this, string.Format("IP: {0} Port: {1}", _mainMc.ServerIp, _mainMc.ServerPort.ToString()));
// -- Create our Wrapped socket.
_baseStream = _baseSock.GetStream();
WSock = new Wrapped(_baseStream);
RaiseSocketDebug(this, "Socket Created");
DoHandshake();
_packetHandlers = new PacketEventHandler(this);
// -- Start network parsing.
_handler = new Thread(NetworkPacketHandler);
_handler.Start();
RaiseSocketDebug(this, "Handler thread started");
}
private T TryConnect <T>(Func <TcpClient, T> doOperation)
{
IAsyncResult asyncResult = null;
var result = default(T);
try
{
var client = new TcpClient();
try
{
asyncResult = client.BeginConnect(this.Host, this.Port, null, null);
var success = asyncResult.AsyncWaitHandle.WaitOne(100);
if (success)
{
result = doOperation(client);
}
}
finally
{
if (asyncResult != null && client.Connected)
{
client.EndConnect(asyncResult);
}
}
}
catch (ObjectDisposedException)
{
// already disposed
}
catch (SocketException)
{
// no listener
}
return(result);
}
bool Check(string ip, string host, int port, int timeout)
{
try
{
var client = new TcpClient();
var result = client.BeginConnect(ip, port, null, null);
var success = result.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(timeout));
if (!success)
{
return(false);
}
// we have connected
client.EndConnect(result);
return(true);
}
catch (Exception ex)
{
return(false);
}
//using (TcpClient tcpClient = new TcpClient())
//{
// try
// {
// tcpClient.Connect(ip, port);
// return true;
// // Console.WriteLine("Port open");
// }
// catch (Exception)
// {
// // Console.WriteLine("Port closed");
// return false;
// }
//}
}
//public CNj
//public BotControlScript botControllScript;
// Use this for initialization
void Start () {
//init
commandList = new ArrayList ();
if (UsingProxy)
{
proxySocket = new TcpClient ();
proxySocket.BeginConnect (ProxyURL, ProxyPort, new System.AsyncCallback (ProxySuccess),proxySocket);
}
else
{
this.tcpListener = new TcpListener(IPAddress.Any, serverPort);
this.listenThread = new Thread(new ThreadStart(ListenForClients));
this.listenThread.Start();
}
string localIP = LocalIPAddress ();
Debug.Log ("Server Start on:"+localIP);
ParseObject testObject = new ParseObject("GlassGame");
testObject["ip"] = localIP;
testObject.SaveAsync().ContinueWith(temp=>
{
var query = ParseObject.GetQuery("GlassGame").OrderByDescending("createdAt").Limit(1);
query.FirstAsync().ContinueWith(t =>
{
ParseObject obj = t.Result;
Debug.Log("Insert Parse ip:"+obj["ip"]);
Debug.Log("Parse Date:"+obj.CreatedAt);
});
});
}
/// <summary>
/// 异步连接
/// </summary>
public void Connect()
{
if ((tcp == null) || (!tcp.Connected))
{
try
{
new Thread(() =>
{
tcp = new TcpClient();
tcp.ReceiveTimeout = 10;
connectDone.Reset();
SetText("Establishing Connection to Server");
tcp.BeginConnect("218.244.145.129", 12345,
new AsyncCallback(ConnectCallback), tcp);
connectDone.WaitOne();
if ((tcp != null) && (tcp.Connected))
{
workStream = tcp.GetStream();
SetText("Connection established");
asyncread(tcp);
}
}).Start();
}
catch (Exception se)
{
Console.WriteLine(se.Message + " Conn......." + Environment.NewLine);
}
}
}
/// <summary>
/// 连接服务器
/// </summary>
void ConnectServer(string host, int port) {
client = null;
client = new TcpClient();
client.SendTimeout = 1000;
client.ReceiveTimeout = 1000;
client.NoDelay = true;
try {
client.BeginConnect(host, port,new AsyncCallback(OnConnect),null);
} catch (Exception e) {
Close();
//Debug.LogError(e.Message);
sockteClientState = netState.None;
lock (NetworkManager.sEvents)
{
NetworkManager.AddEvent(Protocal.ConnectFailer, new ByteBuffer());
}
}
}
void ConnectTo(string ip)
{
if (usingProxy)
{
Debug.Log ("Connecting to " + ip);
client = new TcpClient ();
client.BeginConnect (proxyHost, proxyPort, new System.AsyncCallback (ProcessDnsInformation), client);
}
else
{
Debug.Log ("Connecting to " + ip);
client = new TcpClient ();
client.BeginConnect (ip, port, new System.AsyncCallback (ProcessDnsInformation), client);
}
}
/*
* this method iterates through each known server,
* issues a GETS to each server, and then if any line contains
* new server info, it is added into knownServers.
*/
public void updateServers()
{
TcpClient c = new TcpClient();
for (int i = 0; i < GameMatchingServer.knownServers.Count; i++) {
Server s = (Server) GameMatchingServer.knownServers[i];
// to avoid connecting to self, which would cause an infinite loop.
if (s.port != GameMatchingServer.port) {
try {
c = new TcpClient();
var result = c.BeginConnect(s.IP, s.port, null, null);
var success = result.AsyncWaitHandle.WaitOne(5000, true);
if(!success) {
c.Close();
continue;
} else if (c.Connected) {
//c.Connect(s.IP, s.port);
Stream str = c.GetStream();
StreamWriter strW = new StreamWriter(str);
StreamReader strR = new StreamReader(str);
strW.AutoFlush = true;
// Login as ourselves.
strW.WriteLine("SERVER {0}:{1}", GameMatchingServer.port,
GameMatchingServer.nickName);
strR.ReadLine();
string TwoHundredTest = strR.ReadLine();
while (TwoHundredTest.StartsWith("100")) {
TwoHundredTest = strR.ReadLine();
}
// loop reads all responses from client so far.
// while (!strR.EndOfStream) {
// Console.WriteLine(strR.ReadLine());
// }
strW.WriteLine("GETS");
ArrayList responses = new ArrayList();
string[] getSResp;
int k = 0;
responses.Add(strR.ReadLine());
while (((string)responses[k]).StartsWith("-200")) {
k++;
responses.Add(strR.ReadLine());
} // all -200's should be in string array.
getSResp = (String[]) responses.ToArray(typeof(string));
parseAndAdd(getSResp);
str.Close();
c.Close();
}
} catch (SocketException ex) {
Console.WriteLine(ex);
Console.WriteLine("Connection Error with server at {0}:{1}", s.IP, s.port);
} catch (Exception e) {
c.Close();
Console.WriteLine(e);
}
}
}
}
public ProxyAsyncState BeginConnect(IPAddress address, AsyncCallback callback, object state)
{
AsyncConnection conn;
lock (_connections)
if (_connections.TryGetValue(new IPEndPoint(address, PortNumber), out conn))
{
return new ProxyAsyncState(conn.Proxy, state);
}
TcpClient client = new TcpClient();
try
{
lock (_unfinishedConnections)
_unfinishedConnections.Add(address, client);
}
catch (ArgumentException)
{
throw new InvalidOperationException("Connection is under way.");
}
PeerProxy proxy = CreateProxy();
try
{
client.BeginConnect(address, PortNumber, callback,
Tuple.Create(new ConnectionAsyncResult(client, proxy, state), address));
}
catch (Exception)
{
lock (_unfinishedConnections)
_unfinishedConnections.Remove(address);
throw new CannotConnectException();
}
return new ProxyAsyncState(proxy, state);
}
// Coroutine for managing the connection.
IEnumerator ConnectionCoroutine ()
{
// "Active Sense" message for heartbeating.
var heartbeat = new byte[4] {0xfe, 0xff, 0xff, 0xff};
while (true) {
// Try to open the connection.
for (var retryCount = 0;; retryCount++) {
// Start to connect.
var tempClient = new TcpClient ();
tempClient.BeginConnect (IPAddress.Loopback, portNumber, ConnectCallback, null);
// Wait for callback.
isConnecting = true;
while (isConnecting) {
yield return null;
}
// Break if the connection is established.
if (tempClient.Connected) {
tcpClient = tempClient;
break;
}
// Dispose the connection.
tempClient.Close ();
tempClient = null;
// Show warning and wait a second.
if (retryCount % 3 == 0) {
Debug.LogWarning ("Failed to connect to MIDI Bridge. Make sure to run MidiBridge.exe");
}
yield return new WaitForSeconds (1.0f);
}
// Watch the connection.
while (tcpClient.Connected) {
yield return new WaitForSeconds (1.0f);
// Send a heartbeat and break if it failed.
try {
tcpClient.GetStream ().Write (heartbeat, 0, heartbeat.Length);
} catch (System.IO.IOException exception) {
Debug.Log (exception);
}
}
// Show warning.
Debug.LogWarning ("Disconnected from MIDI Bridge.");
// Close the connection and retry.
tcpClient.Close ();
tcpClient = null;
}
}
public void Connect(string host, int port)
{
this.Host = host;
this.Port = port;
begin = DateTime.Now;
callConnectioneFun = false;
callTimeOutFun = false;
isConnectioned = false;
isbegin = true;
isConnectCall = true;
Debug.LogFormat("<color=green>begin connect:{0} :{1} time:{2}</color>", host, port, begin.ToString());
if (client != null)
client.Close();
client = new TcpClient();
client.BeginConnect(host, port, new AsyncCallback(OnConnected), client);
}
static bool TestConnection(string ipAddress, int Port, TimeSpan waitTimeSpan)
{
Debug.Log("testing server connection");
using (TcpClient tcpClient = new TcpClient())
{
IAsyncResult result = tcpClient.BeginConnect(ipAddress, Port, null, null);
WaitHandle timeoutHandler = result.AsyncWaitHandle;
try
{
if (!result.AsyncWaitHandle.WaitOne(waitTimeSpan, false))
{
tcpClient.Close();
return false;
}
tcpClient.EndConnect(result);
}
catch (Exception ex)
{
Debug.Log("connection to server not made");
return false;
}
finally
{
timeoutHandler.Close();
}
return true;
}
}
