|
public BeginConnect ( |
||
| remoteEP | ||
| callback | AsyncCallback | |
| state | object | |
| return | IAsyncResult | |
private void button1_Click(object sender, EventArgs e)
{
System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
var ControllerIPAddress = new IPAddress(new byte[] { 192, 168, 0, 2 });
var ControllerPort = 40001;
var ControllerEndPoint = new IPEndPoint(ControllerIPAddress, ControllerPort);
_client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
var header = "@";
var command = "00C";
var checksum = "E3";
var end = "\r\n";
var data = header + command + checksum + end;
byte[] bytes = new byte[1024];
//Start Connect
_connectDone.Reset();
watch.Start();
_client.BeginConnect(ControllerIPAddress, ControllerPort, new AsyncCallback(ConnectCallback), _client);
//wait 2s
_connectDone.WaitOne(2000, false);
var text = (_client.Connected) ? "ok" : "ng";
richTextBox1.AppendText(text + "\r\n");
watch.Stop();
richTextBox1.AppendText("Consumer time: " + watch.ElapsedMilliseconds + "\r\n");
}
private Boolean BindConnection(IPAddress TerminalAddress, Int16 TerminalPort)
{
System.Net.IPEndPoint _remoteEndPoint = new System.Net.IPEndPoint(TerminalAddress, TerminalPort);
IAsyncResult result = TerminalSocket.BeginConnect(TerminalAddress, TerminalPort, null, null);
return(result.AsyncWaitHandle.WaitOne(new TimeSpan(0, 0, 10), true));
}
private static bool IsPortOpen(IPAddress ipAddress, int currentPort, int connectTimeout)
{
bool portIsOpen = false;
//use raw Sockets
//using TclClient along with IAsyncResult can lead to ObjectDisposedException on Linux+Mono
Socket socket = null;
try
{
socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontLinger, false);
IAsyncResult result = socket.BeginConnect(ipAddress.ToString(), currentPort, null, null);
result.AsyncWaitHandle.WaitOne(TimeSpan.FromMilliseconds(connectTimeout), true);
portIsOpen = socket.Connected;
}
catch
{
}
finally
{
if (socket != null)
socket.Close();
}
return portIsOpen;
}
/// <summary>
/// 异步连接服务器
/// </summary>
public void Connect(IPEndPoint ipEndPoint)
{
if (_connectState != NetworkClientState.Closed)
{
if (onConnected != null)
{
onConnected.Invoke();
}
Debug.Log("客户端非关闭状态，无法进行该操作!");
return;
}
_currentIpEndPoint = ipEndPoint;
_connectState = NetworkClientState.Connecting;
_unityInvoke = new UnityInvoke("SocketClient");
Debug.Log("connect Start");
try
{
_msgCounter = 0;
_socket = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_socket.BeginConnect(ipEndPoint, DoConnect, _socket);
}
catch (Exception ex)
{
Debug.Log(ex.ToString());
}
}
public PooledSocket(IPEndPoint endpoint, TimeSpan connectionTimeout, TimeSpan receiveTimeout)
{
var socket = new Socket(endpoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
// all operations are "atomic", we do not send small chunks of data
socket.NoDelay = true;
var mre = new ManualResetEvent(false);
var timeout = connectionTimeout == TimeSpan.MaxValue
? Timeout.Infinite
: (int)connectionTimeout.TotalMilliseconds;
socket.ReceiveTimeout = (int)receiveTimeout.TotalMilliseconds;
socket.SendTimeout = (int)receiveTimeout.TotalMilliseconds;
socket.BeginConnect(endpoint, iar =>
{
try { using (iar.AsyncWaitHandle) socket.EndConnect(iar); }
catch { }
mre.Set();
}, null);
if (!mre.WaitOne(timeout) || !socket.Connected)
{
using (socket)
throw new TimeoutException("Could not connect to " + endpoint);
}
this.socket = socket;
this.endpoint = endpoint;
this.inputStream = new BufferedStream(new BasicNetworkStream(socket));
}
Task<ActiveConnectResult> IActiveConnector.ActiveConnect(EndPoint targetEndPoint)
{
var taskSource = new TaskCompletionSource<ActiveConnectResult>();
var socket = new Socket(targetEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
socket.BeginConnect(targetEndPoint, OnActiveConnectCallback, new ActiveConnectState(taskSource, socket));
return taskSource.Task;
}
//public Socket communicateSocket = null;
//客户端重载Access函数
public override void Access(string IP, string Port, string PortSelf, System.Action AccessAction)
{
communicateSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
communicateSocket.Bind(new IPEndPoint(IPAddress.Any, int.Parse(PortSelf)));
//服务器的IP和端口
IPEndPoint serverIP;
try
{
serverIP = new IPEndPoint(IPAddress.Parse(IP), int.Parse(Port));
}
catch
{
throw new Exception(String.Format("{0} is not a valid IP Address!", IP));
}
//客户端只用来向指定的服务器发送信息,不需要绑定本机的IP和端口,不需要监听
try
{
communicateSocket.BeginConnect(serverIP, ar =>
{
AccessAction();
}, null);
}
catch
{
throw new Exception(string.Format("Fail to connect {0}!", IP));
}
}
/// <summary>
/// Starts the auth-server connection
/// </summary>
/// <returns>true on success, false otherwise</returns>
public bool Start()
{
Socket socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
try
{
// Parse string IP Address
IPAddress ip;
if (!IPAddress.TryParse(Settings.AuthServerIP, out ip))
{
ConsoleUtils.ShowFatalError("Failed to parse Server IP ({0})", Settings.ServerIP);
return false;
}
// Connect
socket.BeginConnect(new IPEndPoint(ip, Settings.AuthServerPort), new AsyncCallback(ConnectCallback), socket);
}
catch (Exception e)
{
ConsoleUtils.ShowError(e.Message);
ConsoleUtils.ShowError("At AuthManager.Start()");
socket.Close();
return false;
}
return true;
}
public void Start(byte[] firstPacket, int length, Socket socket, int targetPort)
{
this._firstPacket = firstPacket;
this._firstPacketLength = length;
this._local = socket;
try
{
// TODO async resolving
IPAddress ipAddress;
bool parsed = IPAddress.TryParse("127.0.0.1", out ipAddress);
IPEndPoint remoteEP = new IPEndPoint(ipAddress, targetPort);
_remote = new Socket(ipAddress.AddressFamily,
SocketType.Stream, ProtocolType.Tcp);
_remote.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, true);
// Connect to the remote endpoint.
_remote.BeginConnect(remoteEP,
new AsyncCallback(ConnectCallback), null);
}
catch (Exception e)
{
Logging.LogUsefulException(e);
this.Close();
}
}
public static ScanMessage Connect(EndPoint remoteEndPoint, int timeout)
{
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
TcpConnectCall connectCall = new TcpConnectCall(socket);
// Need for controlling timeout period introduces us to asynccallback methods
AsyncCallback connectedCallback = new AsyncCallback(connectCall.ConnectedCallback);
try
{
IAsyncResult result = socket.BeginConnect(remoteEndPoint, connectedCallback, socket);
// wait for timeout to connect
if (result.AsyncWaitHandle.WaitOne(timeout, false) == false)
{
return ScanMessage.Timeout;
}
else
{
Exception connectException = connectCall.connectFailureException;
if (connectException != null)
{
return ScanMessage.PortClosed;
}
return ScanMessage.PortOpened;
}
}
finally
{
socket.Close();
}
}
internal static void Join(IPAddress ip, int nPort)
{
Connection_attempt = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
IPEndPoint ipRemote = new IPEndPoint(ip, nPort);
Connection_attempt.BeginConnect(ipRemote, new AsyncCallback(OnRemoteConnect), null);
Connecting = true;
}
private void Client_Form_Load(object sender, EventArgs e)
{
try
{
clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPAddress ipAddress = IPAddress.Parse("127.0.0.1");
//Server is listening on port 1000
IPEndPoint ipEndPoint = new IPEndPoint(ipAddress, 1000);
//Connect to the server
clientSocket.BeginConnect(ipEndPoint, new AsyncCallback(OnConnect), null);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "SGSclient", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
byteData = new byte[1024];
//Start listening to the data asynchronously
clientSocket.BeginReceive(byteData,
0,
byteData.Length,
SocketFlags.None,
new AsyncCallback(OnReceive),
null);
}
/// <summary>
/// Initializes a new instance of the <see cref="ProScanMobile.NetworkConnection"/> class.
/// </summary>
/// <description>
/// Creates a new _tcpSocket and tries to connect to Host/Port
/// </description>
/// <param name="host">Host</param>
/// <param name="port">Port</param>
public NetworkConnection(string host, int port)
{
_connectDone.Reset ();
try
{
IPHostEntry ipHostInfo = Dns.GetHostEntry (host);
IPAddress ipAddress = ipHostInfo.AddressList [0];
IPEndPoint remoteEP = new IPEndPoint (ipAddress, port);
_tcpSocket = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_tcpSocket.Blocking = true;
var result = _tcpSocket.BeginConnect (remoteEP, null, null);
bool success = result.AsyncWaitHandle.WaitOne (5000, true);
if (success) {
_tcpSocket.EndConnect (result);
_connectionStatus = ConnectionStatus.Connected;
_connectionStatusMessage = "Connected.";
} else {
_tcpSocket.Close ();
_connectionStatus = ConnectionStatus.Error;
_connectionStatusMessage = "Connection timed out.";
}
} catch {
_connectionStatus = ConnectionStatus.Error;
_connectionStatusMessage = string.Format("An error occured connecting to {0} on port {1}.", host, port);
_connectDone.Set();
return;
} finally {
_connectDone.Set ();
}
}
public void init()
{
try
{
Console.WriteLine("Init");
//set up socket
Socket client = new Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
//IPHostEntry hostInfo = Dns.Resolve("localhost:8000");
//IPAddress address = hostInfo.AddressList[0];
//IPAddress ipAddress = Dns.GetHostEntry("localhost:8000").AddressList[0];
IPAddress ipAddress = new IPAddress(new byte[] { 128, 61, 105, 215 });
IPEndPoint ep = new IPEndPoint(ipAddress, 8085);
client.BeginConnect(ep, new AsyncCallback(ConnectCallback), client);
connectDone.WaitOne();
//receiveForever(client);
byte[] msg = Encoding.ASCII.GetBytes("This is a test<EOF>");
StateObject state = new StateObject();
state.workSocket = client;
client.BeginReceive(buffer, 0, StateObject.BufferSize, 0,
new AsyncCallback(ReceiveCallback), state);
client.Send(msg);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
private System.Net.IPAddress getLocalConnectibleIP(string remoteIP, int remotePort)
{
string text = "127.0.0.1";
System.Net.Sockets.Socket socket = null;
try
{
socket = new System.Net.Sockets.Socket(System.Net.Sockets.AddressFamily.InterNetwork, System.Net.Sockets.SocketType.Stream, System.Net.Sockets.ProtocolType.Tcp);
System.IAsyncResult asyncResult = socket.BeginConnect(remoteIP, remotePort, null, null);
bool flag = asyncResult.AsyncWaitHandle.WaitOne(5000, true);
if (flag && socket.Connected)
{
text = this.GetLocalEndPoint(socket);
int length = text.IndexOf(":");
text = text.Substring(0, length);
}
}
catch (System.Exception)
{
}
finally
{
if (socket != null)
{
socket.Close();
}
}
return(System.Net.IPAddress.Parse(text));
}
private void tp_TrackerUpdate(ArrayList peers, bool success, string errorMessage)
{
Config.LogDebugMessage("Tracker update: Success: " + success + " : Num Peers : " + (peers != null ? peers.Count.ToString() : "0"));
// attempt to connect to each peer given
if (success)
{
if (peers != null)
{
foreach (PeerInformation peerinfo in peers)
{
Config.LogDebugMessage("Peer : " + peerinfo.IP + ":" + peerinfo.Port + " ID: " + (peerinfo.ID != null ? peerinfo.ID.ToString() : "NONE"));
try
{
Sockets.Socket socket = new Sockets.Socket(Sockets.AddressFamily.InterNetwork, Sockets.SocketType.Stream, Sockets.ProtocolType.Tcp);
socket.BeginConnect(new Net.IPEndPoint(Net.IPAddress.Parse(peerinfo.IP), peerinfo.Port),
new System.AsyncCallback(StartPeerConnectionThread), new object[] { socket, peerinfo });
}
catch (System.Exception e)
{
Config.LogException(e);
}
}
}
}
else
{
if (this.TrackerError != null)
{
this.TrackerError(this, errorMessage);
}
}
}
/**
* Asynchronously connects to the localhost server on the cached port number.
* Sets up a TCP socket attempting to contact localhost:outPort, and a
* corresponding UDP server, bound to the inPort.
*
* UNDONE: Think about establishing TCP communication to request what port to set up,
* in case ports can't be directly forwarded, etc. and Unity doesn't know.
*
* Returns True if the connection was successful, false otherwise.
*/
public bool connectAsync(){
try {
/* Create TCP socket for authenticated communication */
endpt = new IPEndPoint(IPAddress.Parse(host), outPort);
clientAuth = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
clientAuth.BeginConnect(endpt, new AsyncCallback(connectCallback), clientAuth);
/* Set up nondurable UDP server for receiving actions*/
server = new Socket (AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
server.Blocking = false;
/*Set up nondurable UDP client to send gamestate */
IPEndPoint RemoteEndPoint= new IPEndPoint(IPAddress.Parse(host), outPort);
clientGameState = new Socket(AddressFamily.InterNetwork,SocketType.Dgram, ProtocolType.Udp);
/* Bind to UDP host port */
IPEndPoint inpt = new IPEndPoint(IPAddress.Parse(host), inPort);
server.Bind (inpt);
return true;
} catch (Exception e){
Debug.Log (e);
return false;
}
}
/**
* Creates a new socket and connects to the specified host and port.
*
* @param strHost
* Host to connect to.
* @param intPort
* Port to connect to.
*/
public void BeginConnect(string strHost, int intPort, PenguinConnectCallback connectCallback)
{
penguinSocks = new Sockets.Socket(Sockets.AddressFamily.InterNetwork, Sockets.SocketType.Stream, Sockets.ProtocolType.Tcp);
ConnectState connectionState = new ConnectState(strHost, intPort, connectCallback);
penguinSocks.BeginConnect(System.Net.IPAddress.Parse(strHost), intPort, ConnectionCallback, connectionState);
}
public void Send(string message, bool isFile)
{
try
{
SerializationClass serCl = new SerializationClass();
if (isFile)
{
serCl.FileName = message.Substring(message.LastIndexOf('\\')+1);
serCl.Command = "SendFile";
using (FileStream file = new FileStream(message, FileMode.Open))
{
StreamReader sr = new StreamReader(file);
string cont = sr.ReadToEnd();
serCl.Content = Encoding.UTF8.GetBytes(cont);
}
}
else
{
serCl.FileName = message;
serCl.Content = Encoding.UTF8.GetBytes(message);
serCl.Command = "SendMessage";
}
string msg = JsonConvert.SerializeObject(serCl);
bytes = Encoding.UTF8.GetBytes(msg);
sSender = new Socket(ipAddr.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
AsyncCallback acConn = new AsyncCallback(OnConnect);
sSender.BeginConnect(ipEnd, acConn, sSender);
}
catch (Exception exc)
{
}
}
public void Connect(int port, string host = null,
Action connectListener = null)
{
if (port < 1 || port > 65535)
{
throw new ArgumentOutOfRangeException("port");
}
host = host ?? "127.0.0.1";
if (connectListener != null)
{
OnConnect += connectListener;
}
Core.EventLoop.Instance.Push(() =>
{
endPoint = new Wininet.IPEndPoint(
Wininet.IPAddress.Parse(host),
port);
});
Core.EventLoop.Instance.Push(() =>
{
nativeSocket.BeginConnect(endPoint,
_static_endConnect, this);
});
}
public telnetClient(string ip, int p, TextBox tb)
{
address = ip;
port = p;
textBox1=tb;
IPHostEntry IPHost = Dns.Resolve(address);
string []aliases = IPHost.Aliases;
IPAddress[] addr = IPHost.AddressList;
try
{
// Create New Socket
s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
// Create New EndPoint
iep = new IPEndPoint(addr[0],port);
// This is a non blocking IO
s.Blocking = false ;
// Assign Callback function to read from Asyncronous Socket
callbackProc = new AsyncCallback(ConnectCallback);
// Begin Asyncronous Connection
s.BeginConnect(iep , callbackProc, s ) ;
}
catch(Exception eeeee )
{
MessageBox.Show(eeeee.Message , "Application Error!!!" , MessageBoxButtons.OK , MessageBoxIcon.Stop );
Application.Exit();
}
}
private ActiveIO(Socket ssc, NetSession session, String hostName, int port)
{
(assoc_session = session).InitSession();
//connectDone = new ManualResetEvent(false);
//在 Unity 中 BeginConnect 解析域名阻塞，所以起线程
new Thread(()=>ssc.BeginConnect(hostName, port, new AsyncCallback(ConnectCallback), ssc)).Start();
}
protected virtual void OnBtnConnectClicked(object sender, System.EventArgs e)
{
try {
clientSocket = new System.Net.Sockets.Socket(AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
IPAddress ipAddress = IPAddress.Parse(txtIp.Text);
log(txtIp.Text);
IPEndPoint ipEndPoint = new IPEndPoint(ipAddress,
int.Parse(txtPort.Text));
clientSocket.BeginConnect(ipEndPoint,
new AsyncCallback(OnConnect),
null);
btnConnect.Sensitive = false;
btnDisconnect.Sensitive = true;
btnMsg.Sensitive = true;
}
catch (Exception ex) {
log("Not able to connect to server:");
log(ex.Message);
btnConnect.Sensitive = true;
btnDisconnect.Sensitive = false;
btnMsg.Sensitive = false;
}
}
public static void StartClient()
{
// Connect to a remote device.
try
{
// Establish the remote endpoint for the socket.
// The name of the
// remote device is "host.contoso.com".
IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName());
IPAddress ipAddress = ipHostInfo.AddressList[0];
IPEndPoint remoteEP = new IPEndPoint(ipAddress, port);
// Create a TCP/IP socket.
Socket client = new Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
socket = client;
running = true;
// Connect to the remote endpoint.
client.BeginConnect(remoteEP,
new AsyncCallback(ConnectCallback), client);
connectDone.WaitOne();
SendReceive(client, "Handshake<EOF>");
}
catch (Exception e)
{
ClientLog(null, new Logging.LogEventArgs(e.ToString()));
}
}
public bool Connect( string address, int remotePort )
{
if ( _socket != null && _socket.Connected )
{
return true;
}
//解析域名
IPHostEntry hostEntry = Dns.GetHostEntry( address );
foreach(IPAddress ip in hostEntry.AddressList)
{
try
{
//获得远程服务器的地址
IPEndPoint ipe = new IPEndPoint( ip, remotePort );
//创建socket
_socket = new Socket( ipe.AddressFamily, SocketType.Stream, ProtocolType.Tcp );
//开始连接
_socket.BeginConnect( ipe, new System.AsyncCallback( ConnectionCallback ), _socket );
break;
}
catch(System.Exception e)
{
//连接失败 将消息传入逻辑处理队列
PushPacket( (ushort)MessageIdentifiers.ID.CONNECTION_ATTEMPT_FAILED, e.Message );
}
}
return true;
}
public void Connect()
{
lock (_lock)
{
if (Connected) return;
var connectEndEvent = new ManualResetEvent(false);
_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
_socket.BeginConnect(_config.GatewayIp, _config.GatewayPort, delegate(IAsyncResult result)
{
try
{
var socket = (Socket)result.AsyncState;
socket.EndConnect(result);
}
catch (Exception ex)
{
Console.WriteLine("Unbale to connect, error: {0}.", ex);
}
connectEndEvent.Set();
}, _socket);
if (connectEndEvent.WaitOne(10000) && Connected)
{
_state.Size = CmppConstants.HeaderSize;
_state.PackageType = typeof(CmppHead);
_state.Header = null;
return;
}
Console.WriteLine("Fail to connect to remote host {0}:{1}", _config.GatewayIp, _config.GatewayPort);
Disconnect();
}
}
public PooledSocket(SocketPool socketPool, IPEndPoint endPoint, int sendReceiveTimeout, int connectTimeout)
{
this.socketPool = socketPool;
Created = DateTime.Now;
//Set up the socket.
socket = new Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendTimeout, sendReceiveTimeout);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, sendReceiveTimeout);
socket.ReceiveTimeout = sendReceiveTimeout;
socket.SendTimeout = sendReceiveTimeout;
//Do not use Nagle's Algorithm
socket.NoDelay = true;
//Establish connection asynchronously to enable connect timeout.
IAsyncResult result = socket.BeginConnect(endPoint, null, null);
bool success = result.AsyncWaitHandle.WaitOne(connectTimeout, false);
if (!success) {
try { socket.Close(); } catch { }
throw new SocketException();
}
socket.EndConnect(result);
//Wraps two layers of streams around the socket for communication.
stream = new BufferedStream(new NetworkStream(socket, false));
}
private void Client_Load(object sender, EventArgs e)
{
Socket socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
// Start connecting on load
IAsyncResult result = socket.BeginConnect("cse3461-server.cloudapp.net", 34567, null, null);
// Wait up to 5 seconds
bool success = result.AsyncWaitHandle.WaitOne(5000, true);
// Exit if failed
if (!success)
{
socket.Close();
MessageBox.Show("Unable to Connect", "Unable to connect", MessageBoxButtons.OK, MessageBoxIcon.Error);
this.Close();
return;
}
// success, so create a transceiver and hook up events
_xcvr = new MessageXcvr(socket);
_xcvr.Disconnected += _xcvr_Disconnected;
_xcvr.MessageReceived += _xcvr_MessageReceived;
}
public void StartClient()
{
try
{
IPHostEntry ipHostInfo = Dns.GetHostEntry("localhost");
IPAddress ipAddress = ipHostInfo.AddressList[0];
IPEndPoint remoteEP = new IPEndPoint(ipAddress, 11000);
Socket client = new Socket(ipAddress.AddressFamily,
SocketType.Stream, ProtocolType.Tcp);
client.BeginConnect(remoteEP,
new AsyncCallback(ConnectCallback), client);
connectDone.WaitOne();
Send(client, Message);
sendDone.WaitOne();
Receive(client);
receiveDone.WaitOne();
mainStr += "Response received : " + response + "\n";
client.Shutdown(SocketShutdown.Both);
client.Close();
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
}
public void connect(String Ip, UInt16 port)
{
// Connect to a remote device.
// Establish the remote endpoint for the socket.
// The name of the remote device is Ip.
//Change to these 2 line for Dns resolve
//IPHostEntry ipHostInfo = Dns.GetHostEntry(Ip);
//IPAddress ipAddress = ipHostInfo.AddressList[0];
IPAddress ipAddress = IPAddress.Parse(Ip);
IPEndPoint remoteEP = new IPEndPoint(ipAddress, port);
// Create a TCP/IP socket.
tcpClientSocket = new Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
// Connect to the remote endpoint.
tcpClientSocket.BeginConnect(remoteEP,
new AsyncCallback(connectCallback), tcpClientSocket);
connectDone.WaitOne(6000);
// Receive the response from the remote device.
// receiveDone.WaitOne();
// Write the response to the console.
// Console.WriteLine("Response received : {0}", response);
// Release the socket.
//client.Shutdown(SocketShutdown.Both);
// client.Close();
receive(tcpClientSocket);
}
public void StartListening()
{
byte[] bytes = new Byte[BufferSize];
IPHostEntry ipHostInfo = new IPHostEntry();
ipHostInfo.AddressList = new IPAddress[] { _serverIP};
IPAddress ipAddress = ipHostInfo.AddressList[0];
IPEndPoint remoteEndPoint = new IPEndPoint(ipAddress, port);
// Create a TCP/IP socket.
Socket listener = new Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
try
{
listener.BeginConnect(remoteEndPoint, new AsyncCallback(ConnectCallback), listener);
connectDone.WaitOne();
// receive data
receiveDone.Reset();
Receive(listener);
receiveDone.WaitOne();
Console.WriteLine("Disconnecting from feed");
listener.Shutdown(SocketShutdown.Both);
listener.Close();
}
catch (Exception e)
{
Console.WriteLine("Feed Error " + e.ToString());
}
}
private void btnOK_Click(object sender, EventArgs e)
{
try
{
clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPAddress ipAddress = IPAddress.Parse(txtServerIP.Text);
//Server is listening on port
IPEndPoint ipEndPoint = new IPEndPoint(ipAddress, Convert.ToInt32(txtPort.Text));
//Connect to the server
clientSocket.BeginConnect(ipEndPoint, new AsyncCallback(OnConnect), null);
byteData = new byte[1024];
//Start listening to the data asynchronously
clientSocket.BeginReceive(byteData,
0,
byteData.Length,
SocketFlags.None,
new AsyncCallback(OnReceive),
null);
btnOK.Enabled = false;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "ChatClient", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public override bool Create()
{
{
try
{
// Close the socket if it is still open
if (m_sock != null && m_sock.Connected)
return true;
// Create the socket object
m_sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
// Define the Server address and port
IPEndPoint epServer = new IPEndPoint(IPAddress.Parse(m_szIP), m_iPort);
// Connect to the server blocking method and setup callback for recieved data
// m_sock.Connect( epServer );
// SetupRecieveCallback( m_sock );
// Connect to server non-Blocking method
m_sock.Blocking = false;
AsyncCallback onconnect = new AsyncCallback(OnConnect);
m_sock.BeginConnect(epServer, onconnect, m_sock);
return true;
}
catch (Exception e)
{
MessageBox.Show(e.Message, "Server Connect failed!");
return false;
}
}
}
public void Start()
{
try
{
// TODO async resolving
IPAddress ipAddress;
bool parsed = IPAddress.TryParse(config.server, out ipAddress);
if (!parsed)
{
IPHostEntry ipHostInfo = Dns.GetHostEntry(config.server);
ipAddress = ipHostInfo.AddressList[0];
}
IPEndPoint remoteEP = new IPEndPoint(ipAddress, config.server_port);
remote = new Socket(ipAddress.AddressFamily,
SocketType.Stream, ProtocolType.Tcp);
// Connect to the remote endpoint.
remote.BeginConnect(remoteEP,
new AsyncCallback(connectCallback), null);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
this.Close();
}
}
public void Connect(string hostname, int port)
{
// Connect to a remote device.
try
{
// Establish the remote endpoint for the socket.
IPHostEntry ipHostInfo = Dns.Resolve(hostname);
IPAddress ipAddress = ipHostInfo.AddressList[0];
IPEndPoint remoteEP = new IPEndPoint(ipAddress, port);
// Create a TCP/IP socket.
m_sock = new Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
// Connect to the remote endpoint.
m_sock.BeginConnect( remoteEP,
new AsyncCallback(ConnectCallback), m_sock);
}
catch (Exception e)
{
m_lasterror = e.Message;
ErrorNotify("DataAsyncSocket.Connect");
}
}
public static IEnumerable<int> Scan(string ip, int startPort, int endPort)
{
openPorts.Clear();
//List<int> openPorts = new List<int>();
for (int port = startPort; port <= endPort; port++)
{
Debug.WriteLine(string.Format("Scanning port {0}", port));
Socket scanSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
try
{
//scanSocket.Connect(new IPEndPoint(IPAddress.Parse(ip), port));
//scanSocket.Disconnect(false);
//openPorts.Add(port);
//scanSocket.BeginConnect(new IPEndPoint(ip, port), ScanCallBack, new ArrayList() { scanSocket, port });
scanSocket.BeginConnect(new IPEndPoint(IPAddress.Parse(ip), port), ScanCallBack, new ArrayList() { scanSocket, port });
}
catch (Exception ex)
{
//bury exception since it means we could not connect to the port
}
}
//Computers.comp1.Add(ip, openPorts);
return openPorts;
}
public void Connect(string message)
{
// Connect to a remote device.
try
{
var ipHostInfo = Dns.Resolve(Dns.GetHostName());
IPAddress ipAddress = ipHostInfo.AddressList[0];
IPEndPoint remoteEP = new IPEndPoint(ipAddress, 12000);
Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
// Connect to the remote endpoint.
client.BeginConnect(remoteEP, ConnectCallback, client);
connectDone.WaitOne();
// Send test data to the remote device.
Send(client, message);
sendDone.WaitOne();
// Receive the response from the remote device.
Receive(client);
receiveDone.WaitOne();
// Release the socket.
client.Shutdown(SocketShutdown.Both);
client.Close();
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
public void Connect()
{
try
{
// Do nothing if connected
if (m_sock != null && m_sock.Connected)
{
return;
}
// Try to connect
m_sock = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
// TODO: Input check
m_server_ip = ip_entry.Text;
m_server_port = Convert.ToInt16(port_entry.Text);
// Define the Server address and port
IPEndPoint epServer = new IPEndPoint(IPAddress.Parse(m_server_ip), m_server_port);
// Connect to server non-Blocking method
m_sock.Blocking = false;
m_sock.BeginConnect(epServer, new AsyncCallback(OnConnected), m_sock);
}
catch (Exception e)
{
WriteLog("Unable to connect to " + m_server_ip + ":" + m_server_port + "\n", tagInfo);
}
}
/// <summary>
/// ConnectToServer
/// </summary>
/// <returns></returns>
private bool SyncConnectToServer()
{
System.Net.Sockets.Socket socketClient = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
connectDone.Reset();
socketClient.BeginConnect(locEndpoint, new AsyncCallback(AsyncConnectCallback), socketClient);
connectDone.WaitOne();
return(socketClient == null ? false : socketClient.Connected);
}
/// <summary>
/// 开启客户端socket
/// </summary>
public static void ClientSocketStarting(SocketConnectConfig sktconfig)
{
Sktconfig = sktconfig;
if (ServerSocketEndPoint != null && (SocketClient == null || !SocketClient.Connected))
{
SocketClient = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
SocketClientConnection = new SocketConnectionReConnectClient(SocketClient);
SocketClient.BeginConnect(ServerSocketEndPoint, ConnectCallback, SocketClientConnection);
}
}
public void Connect(string ip, int port, int timeout = 5000)
{
try
{
if (IsConnect())
return;
this.ip = ip;
this.port = port;
_remoteEP = new IPEndPoint(IPAddress.Parse(ip), port);
if (_stateObject.Socket == null)
{
System.Net.Sockets.Socket handler = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IAsyncResult asyncResult = handler.BeginConnect(_remoteEP, null, null);
if (asyncResult.AsyncWaitHandle.WaitOne(timeout, true))
{
handler.EndConnect(asyncResult);
_stateObject.Socket = handler;
var option = new TcpKeepAlive
{
OnOff = 1,
KeepAliveTime = 5000,
KeepAliveInterval = 1000
};
_stateObject.Socket.IOControl(IOControlCode.KeepAliveValues, option.GetBytes(), null);
BeginReceive(_ioEvent);
OnConnected(_stateObject);
}
else
{
_stateObject.Init();
throw new SocketException(10060);
}
}
else
{
_stateObject.Init();
}
}
catch (ArgumentNullException arg)
{
throw new Exception.Exception(arg.Message);
}
catch (SocketException se)
{
throw new Exception.Exception(se.Message);
}
catch (System.Exception e)
{
throw new Exception.Exception(e.Message);
}
}
public void Connect(EndPoint endPoint)
{
ConnectingEvent();
try
{
Socket = new System.Net.Sockets.Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
Socket.BeginConnect(endPoint, ConnectCallback, Socket);
}
catch (Exception e)
{
ExceptionEvent(e);
return;
}
}
/// <summary>
/// Will create a local socket and try to connect remote socket with specific ipendpoint
/// </summary>
/// <param name="IP"></param>
/// <param name="Port"></param>
public void Connect(string IP, int Port)
{
try
{
Socket connectorSock = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
connectorSock.BeginConnect(new IPEndPoint(IPAddress.Parse(IP), Port), new AsyncCallback(outgoingConnect), connectorSock);
this.LocalSockets.Add(connectorSock);
this.ChannelLog?.Invoke(ChannelLogTypes.ConnectionStarted, "Client connection started to outgoing socket " + IP + ":" + Port);
}
catch (Exception ex)
{
this.ChannelError?.Invoke(ChannelErrorTypes.ConnectError, ex.Message.ToString(), ex, null);
}
}
void StartConnectingSocket(IPAddress addr, int port)
{
socket = new System.Net.Sockets.Socket(addr.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
try {
socket.BeginConnect(addr, port, (ar) => {
try {
socket.EndConnect(ar);
loop.NonBlockInvoke(connectedCallback);
} catch {
}
}, null);
} catch {
}
}
/// <summary>
/// Connects the specified socket.
/// </summary>
/// <param name="socket">The socket.</param>
/// <param name="endpoint">The IP endpoint.</param>
/// <param name="timeout">The timeout.</param>
public static void Connect(this System.Net.Sockets.Socket socket, EndPoint endpoint, TimeSpan timeout)
{
var result = socket.BeginConnect(endpoint, null, null);
bool success = result.AsyncWaitHandle.WaitOne(timeout, true);
if (success)
{
socket.EndConnect(result);
}
else
{
socket.Close();
throw new SocketException(10060); // Connection timed out.
}
}
public static void Connect(this System.Net.Sockets.Socket socket, EndPoint endpoint, int timeout)
{
var result = socket.BeginConnect(endpoint, null, null);
bool success = result.AsyncWaitHandle.WaitOne(timeout, true);
if (socket.Connected)
{
socket.EndConnect(result);
}
else
{
socket.Close();
throw new SocketException(ConnectionTimedOutStatusCode);
}
}
public void Open()
{
var result = _clientSocket.BeginConnect(IPAddress.Parse(_remoteIp), _remotePort, null, null);
bool success = result.AsyncWaitHandle.WaitOne(5000, true);
if (_clientSocket.Connected)
{
_clientSocket.EndConnect(result);
}
else
{
_clientSocket.Close();
throw new SocketException(10060);
}
//_clientSocket.Connect(IPAddress.Parse(_remoteIp), _remotePort);
}
void StartConnectingSocket(IPAddress addr, int port)
{
socket = new System.Net.Sockets.Socket(addr.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
try {
socket.BeginConnect(addr, port, (ar) => {
Enqueue(delegate {
try {
socket.EndConnect(ar);
connectedCallback();
} catch {
}
});
}, null);
} catch {
}
}
/// <summary>
/// 开始连接服务器
/// </summary>
/// <param name="port"></param>
/// <param name="ip"></param>
public void StartConnect(int port, string ip = "127.0.0.1")
{
try
{
mySocket = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPAddress address = IPAddress.Parse(ip);
IPEndPoint endPoint = new IPEndPoint(address, port);
//开始异步连接
mySocket.BeginConnect(endPoint, asyncResult =>
{
try
{
mySocket.EndConnect(asyncResult); //结束异步连接
// localEndPointIp = mySocket.LocalEndPoint.ToString(); //得到ip地址
OnSuccess?.Invoke(this); //连接成功的回调
recThread = new Thread(RecMsg);
recThread.IsBackground = true;
recThread.Start(mySocket);
Task.Run(() =>
{
while (true)
{
if (mySocket != null && IsReceive)
{
string ss = EndPointIp;
SendMsg("hear," + ss);
}
Thread.Sleep(HeartbeatCheckInterval);
}
});
}
catch (Exception ex)
{
OnError?.Invoke(ex);
}
}, null);
}
catch (Exception ex)
{
OnError?.Invoke(ex); //报错的回调
}
}
/// <summary>
/// Connect to server
/// </summary>
public void Connect(IPEndPoint iep)
{
lock (_locker)
{
AssertThat.IsFalse(IsConnected, "Already Connected");
AssertThat.IsNotNull(iep, "iep is null");
ConnectingEvent();
try
{
Socket = new System.Net.Sockets.Socket(iep.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
}
catch (Exception e)
{
throw new Exception(e.ToString());
}
try
{
Socket.BeginConnect(iep, delegate(IAsyncResult ar)
{
try
{
var socket = ar.AsyncState as System.Net.Sockets.Socket;
AssertThat.IsNotNull(socket, "Socket is null when end connect");
socket.EndConnect(ar);
if (IsConnected)
{
ConnectedEvent();
Receive();
}
else
{
AssertThat.Fail("Connect faild");
}
}
catch (Exception e)
{
throw new Exception(e.ToString());
}
}, Socket);
}
catch (Exception e)
{
throw new Exception(e.ToString());
}
}
}
/// <summary>
/// Connects the socket to the endpoint
/// </summary>
/// <exception cref="Exception">Socket already bound or connected</exception>
public void Connect()
{
if (_socket.IsBound || _socket.Connected)
{
throw new Exception("Unable to connect. Socket already bound or connected.");
}
try
{
CreateEndPoint();
_socket.BeginConnect(IpEndPoint, OnConnectCallback, _socket);
_connectedEvent.WaitOne();
}
catch (Exception e)
{
throw new Exception("Couldn't connect.\n" + e.Message);
}
}
/// <summary>
/// 异步连接服务器
/// </summary>
public virtual bool Connect()
{
if (IsConnection)
{
return(true);
}
//判断是否设置服务器IP地址,和端口
if (string.IsNullOrEmpty(this.Ip))
{
CutConnection("服务器IP地址为空");
return(false);
}
if (this.Port == 0)
{
CutConnection("服务器IP服务器端口为空");
return(false);
}
try
{
//实例化Socket通讯对象
sock = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//生成一个网络端口
IPEndPoint iep = new IPEndPoint(IPAddress.Parse(this.Ip), this.Port);
//开始异步请求连接
sock.BeginConnect(iep, new AsyncCallback(Connected), sock);
}
catch (SocketException ex)
{
//服务器断开
CutConnection(ex.Message);
}
catch (ObjectDisposedException ex)
{
//服务器断开
CutConnection(ex.Message);
}
catch (Exception ex)
{
//服务器断开
CutConnection(ex.Message);
}
return(false);
}
public int StartClient(string ipv4Add)
{
// Connect to a remote device.
int connectionPort = Utils.getUnusedPort(PORT_START, PORT_END);
try
{
// Establish the remote endpoint for the socket.
// The name of the
IPHostEntry ipHostInfo = Dns.GetHostEntry(ipv4Add);
IPAddress ipAddress = ipHostInfo.AddressList[0];
IPEndPoint remoteEP = new IPEndPoint(ipAddress, connectionPort);
// Create a TCP/IP socket.
System.Net.Sockets.Socket client = new System.Net.Sockets.Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
// Connect to the remote endpoint.
client.BeginConnect(remoteEP,
new AsyncCallback(ConnectCallback), client);
connectDone.WaitOne();
// Send test data to the remote device.
Send(client, "This is a test<EOF>");
sendDone.WaitOne();
// Receive the response from the remote device.
Receive(client);
receiveDone.WaitOne();
// Write the response to the console.
Console.WriteLine("Response received : {0}", response);
// Release the socket.
client.Shutdown(SocketShutdown.Both);
client.Close();
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
return(connectionPort);
}
/// <summary>
/// Setup connection to server.
/// </summary>
/// <param name="host"></param>
/// <param name="port"></param>
/// <returns></returns>
public System.Net.Sockets.Socket Connect(string host, int port)
{
// Establish the remote endpoint for the socket.
// The name of the
// remote device is "host.contoso.com".
IPHostEntry ipHostInfo = Dns.GetHostEntry(host);
IPAddress ipAddress = ipHostInfo.AddressList[0];
IPEndPoint remoteEP = new IPEndPoint(ipAddress, port);
// Create a TCP/IP socket.
var client = new System.Net.Sockets.Socket(ipAddress.AddressFamily,
SocketType.Stream, ProtocolType.Tcp);
// Connect to the remote endpoint.
client.BeginConnect(remoteEP, new AsyncCallback(ConnectCallback), client);
connectDone.WaitOne();
return(client);
}
private void StartClient()
{
// Connect to a remote device.
try
{
// Establish the remote endpoint for the socket.
// The name of the
// remote device is "host.contoso.com".
IPHostEntry ipHostInfo = Dns.GetHostEntry(ip);
IPAddress ipAddress = ipHostInfo.AddressList[0];
IPEndPoint remoteEP = new IPEndPoint(ipAddress, this.port);
// Create a TCP/IP socket.
this.client = new System.Net.Sockets.Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
// Connect to the remote endpoint.
IAsyncResult result = client.BeginConnect(remoteEP,
new AsyncCallback(ConnectCallback), client);
bool success = result.AsyncWaitHandle.WaitOne(5000, true);
if (!success)
{
// NOTE, MUST CLOSE THE SOCKET
this.client.Close();
Debug.Log("Failed to connect server.");
throw new ApplicationException("Failed to connect server.");
}
}
catch (Exception e)
{
Debug.Log(e.ToString());
}
}
public void ConnectToServer()
{
// create the TcpListener which will listen for and accept new client connections asynchronously
cClientSocket = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
// convert the server address and port into an ipendpoint
IPAddress[] mHostAddresses = Dns.GetHostAddresses(cServerAddress);
IPEndPoint mEndPoint = null;
foreach (IPAddress mHostAddress in mHostAddresses)
{
if (mHostAddress.AddressFamily == AddressFamily.InterNetwork)
{
mEndPoint = new IPEndPoint(mHostAddress, cServerPort);
}
}
// connect to server async
try {
cClientSocket.BeginConnect(mEndPoint, new AsyncCallback(ConnectToServerCompleted), new SocketGlobals.AsyncSendState(cClientSocket));
} catch (Exception ex) {
MessageBox.Show("ConnectToServer error: " + ex.Message);
}
}
System.IAsyncResult Utils.Wrappers.Interfaces.ISocket.BeginConnect(System.Net.EndPoint remoteEP, System.AsyncCallback callback, object state)
{
return(InternalSocket.BeginConnect(remoteEP, callback, state));
}
IEnumerator RestoreUpdate()
{
if (Application.internetReachability == NetworkReachability.NotReachable)
{
Log.LogInfo("connect time out");
MainLoader.ChangeStep(LoadStep.NotNeedUpdate);
yield break;
}
else if (Application.internetReachability == NetworkReachability.ReachableViaCarrierDataNetwork)
{
//3G Tip
}
//Restore DownLoad From Progress.xml
System.Net.Sockets.Socket sClient = new System.Net.Sockets.Socket(System.Net.Sockets.AddressFamily.InterNetwork, System.Net.Sockets.SocketType.Stream, System.Net.Sockets.ProtocolType.IP);
System.Net.EndPoint server = new System.Net.IPEndPoint(Dns.GetHostAddresses(GameData.Domain)[0], System.Convert.ToInt32(strPort));
System.Threading.ManualResetEvent connectDone = new System.Threading.ManualResetEvent(false);
try
{
connectDone.Reset();
sClient.BeginConnect(server, delegate(IAsyncResult ar) {
try
{
System.Net.Sockets.Socket client = (System.Net.Sockets.Socket)ar.AsyncState;
client.EndConnect(ar);
}
catch (System.Exception e)
{
Log.LogInfo(e.Message + "|" + e.StackTrace);
}
finally
{
connectDone.Set();
}
}
, sClient);
//timeout
if (!connectDone.WaitOne(2000))
{
Log.LogInfo("connect time out");
MainLoader.ChangeStep(LoadStep.CannotConnect);
yield break;
}
else
{
if (!sClient.Connected)
{
Log.LogInfo("connect disabled by server");
MainLoader.ChangeStep(LoadStep.CannotConnect);
yield break;
}
}
}
catch
{
sClient.Close();
MainLoader.ChangeStep(LoadStep.CannotConnect);
yield break;
}
finally
{
connectDone.Close();
}
//Log.LogInfo("download:" + string.Format(strVFile, strHost, strPort, strProjectUrl, strPlatform, strVFileName));
using (WWW vFile = new WWW(string.Format(strVFile, strHost, strPort, strProjectUrl, strPlatform, strVFileName)))
{
//Log.LogInfo("error:" + vFile.error);
yield return(vFile);
if (vFile.error != null && vFile.error.Length != 0)
{
//Log.LogInfo("error " + vFile.error);
vFile.Dispose();
//not have new version file
//can continue game
MainLoader.ChangeStep(LoadStep.NotNeedUpdate);
yield break;
}
if (vFile.bytes != null && vFile.bytes.Length != 0)
{
File.WriteAllBytes(strUpdatePath + "/" + "v.zip", vFile.bytes);
DeCompressFile(strUpdatePath + "/" + "v.zip", strUpdatePath + "/" + "v.xml");
vFile.Dispose();
}
else
{
MainLoader.ChangeStep(LoadStep.NotNeedUpdate);
yield break;
}
}
XmlDocument xmlVer = new XmlDocument();
xmlVer.Load(strUpdatePath + "/" + "v.xml");
XmlElement ServerVer = xmlVer.DocumentElement;
if (ServerVer != null)
{
string strServer = ServerVer.GetAttribute("ServerV");
UpdateClient = HttpManager.AllocClient(string.Format(strDirectoryBase, strHost, strPort, strProjectUrl, strPlatform, strServer, ""));
//if (strServer != null && GameData.Version().CompareTo(strServer) == -1)
//{
// strServerVer = strServer;
// foreach (XmlElement item in ServerVer)
// {
// string strClientV = item.GetAttribute("ClientV");
// if (strClientV == GameData.Version())
// {
// strUpdateFile = item.GetAttribute("File");
// break;
// }
// }
// if (strUpdateFile != null && strUpdateFile.Length != 0)
// StartCoroutine("DownloadNecessaryData");
//}
//else
//{
// Log.LogInfo("not need update");
// MainLoader.ChangeStep(LoadStep.NotNeedUpdate);
//}
}
}
protected void OnBoopBtnClicked(object sender, EventArgs e)
{
//TODO: Check network connection
try
{
//Fastest check first.
if (!FilesToBoop.Any())
{
//TODO: Throw error
return;
}
if (NetUtils.Validate(targetIP.Text) == false)
{
//TODO: Throw error
return;
}
string DSip = targetIP.Text;
int ServerPort = Int32.Parse(Port.Text);
// THE FIREWALL IS NO LONGER POKED!
// THE SNEK IS FREE FROM THE HTTPLISTENER TIRANY!
// setStatusLabel("Opening the new and improved snek server...");
// enableControls(false);
Console.WriteLine("Active Dir");
Console.WriteLine(ActiveDir);
Console.WriteLine("Port");
Console.WriteLine(ServerPort.ToString());
string SafeDir = ActiveDir + "/";
HTTPServer = new MyServer(ServerPort, ActiveDir);
HTTPServer.Start();
System.Threading.Thread.Sleep(100);
// setStatusLabel("Opening socket to send the file list...");
s = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IAsyncResult result = s.BeginConnect(DSip, 5000, null, null);
result.AsyncWaitHandle.WaitOne(5000, true);
if (!s.Connected)
{
s.Close();
HTTPServer.Stop();
// MessageBox.Show("Failed to connect to 3DS" + Environment.NewLine + "Please check:" + Environment.NewLine + "Did you write the right IP adress?" + Environment.NewLine + "Is FBI open and listening?", "Connection failed", MessageBoxButtons.OK, MessageBoxIcon.Error);
// lblIPMarker.Visible = true;
// setStatusLabel("Ready");
// enableControls(true);
return;
}
// setStatusLabel("Sending the file list...");
String message = "";
String formattedPort = ":" + Port.Text + "/";
foreach (var CIA in FilesToBoop)
{
message += NetUtils.GetLocalIPAddress() + formattedPort + System.Web.HttpUtility.UrlEncode(System.IO.Path.GetFileName(CIA)) + "\n";
}
//boop the info to the 3ds...
byte[] Largo = BitConverter.GetBytes((uint)Encoding.ASCII.GetBytes(message).Length);
byte[] Adress = Encoding.ASCII.GetBytes(message);
Array.Reverse(Largo); //Endian fix
s.Send(AppendTwoByteArrays(Largo, Adress));
// setStatusLabel("Booping files... Please wait");
s.BeginReceive(new byte[1], 0, 1, 0, new AsyncCallback(GotData), null); //Call me back when the 3ds says something.
//#if DEBUG
}
catch (Exception ex)
{
//Hopefully, some day we can have all the different exceptions handled... One can dream, right? *-*
// MessageBox.Show("Something went really wrong: " + Environment.NewLine + Environment.NewLine + "\"" + ex.Message + "\"" + Environment.NewLine + Environment.NewLine + "If this keeps happening, please take a screenshot of this message and post it on our github." + Environment.NewLine + Environment.NewLine + "The program will close now", "Error!", MessageBoxButtons.OK, MessageBoxIcon.Error);
Application.Quit();
}
//#endif
}
public void ConnectAsync(IPAddress addr, int port)
{
_tcpSock.BeginConnect(new IPEndPoint(addr, port), EndConnect, _tcpSock);
}
