protected override async Task <CommandMessage> ReadMessageAsync() { if (this.sread == null) { await this.WaitForAttachAsync(); } ReadAgain: var msg = await CommandMessage.ReadFromStreamAsync(this.sread); if (msg == null || msg.Name == "data") { return(msg); } //TcpMapService.LogMessage("ServerSession:get message " + msg); switch (msg.Name) { case "_ping_": await this.swrite.WriteAsync(new CommandMessage("_ping_result_").Pack()); break; case "_ping_result_": break; default: TcpMapService.LogMessage("Error: 6 Ignore message " + msg); break; } goto ReadAgain; }
async Task SessionToStreamAsync(Stream stream) { try { while (true) { //TcpMapService.LogMessage(this.GetType().Name + " ReadMessageAsync"); var msg = await ReadMessageAsync(); //TcpMapService.LogMessage(this.GetType().Name + " ReadMessageAsync DONE : " + msg); if (msg == null) { return; } if (msg.Name == "data") { await stream.WriteAsync(msg.Data); } else { TcpMapService.LogMessage("Warning:this message shall not pass to BaseSession : " + msg); } //TcpMapService.LogMessage(this.GetType().Name + " WriteAsync DONE : " + msg); } } catch (Exception x) { //TcpMapService.OnError(x); } finally { //TcpMapService.LogMessage(this.GetType().Name + " EXITING SessionToStreamAsync"); } }
protected override async Task <CommandMessage> ReadMessageAsync() { ReadAgain: CommandMessage msg; CancellationTokenSource cts = null; if (DateTime.Now - _lastwritetime > TimeSpan.FromMilliseconds(12000)) { _lastwritetime = DateTime.Now; await _swrite.WriteAsync(new CommandMessage("_ping_", "forwrite").Pack()); } else { cts = new CancellationTokenSource(); _ = Task.Run(async delegate { if (await cts.Token.WaitForSignalSettedAsync(16000)) { return; } _lastwritetime = DateTime.Now; await _swrite.WriteAsync(new CommandMessage("_ping_", "forread").Pack()); }); } try { msg = await CommandMessage.ReadFromStreamAsync(_sread); } finally { if (cts != null) { cts.Cancel(); } } if (msg == null || msg.Name == "data") { return(msg); } //TcpMapService.LogMessage("ClientSession:get message " + msg); switch (msg.Name) { case "_ping_": await _swrite.WriteAsync(new CommandMessage("_ping_result_").Pack()); break; case "_ping_result_": break; default: TcpMapService.LogMessage("Error: 2 Ignore message " + msg); break; } goto ReadAgain; }
public void LogMessage(string msg) { this.logMessages.Enqueue(msg); while (this.logMessages.Count > 200) { this.logMessages.TryDequeue(out _); } TcpMapService.LogMessage(msg); }
static public void CloseSocket(this Socket socket) { try { //socket.Close(); //socket.Disconnect(false); socket.Dispose(); } catch (Exception x) { TcpMapService.OnError(x); } }
internal void Stop() { _cts_wait_upgrade?.Cancel(); if (_socket != null) { try { _socket.CloseSocket(); } catch (Exception x) { TcpMapService.OnError(x); } } }
protected override async Task<CommandMessage> ReadMessageAsync() { ReadAgain: CommandMessage msg; var cts = new CancellationTokenSource(); _ = Task.Run(async delegate { if (await cts.Token.WaitForSignalSettedAsync(16000)) return; try { await _swrite.WriteAsync(new CommandMessage("_ping_", "forread").Pack()); } catch (Exception x) { OnError(x); } }); try { msg = await CommandMessage.ReadFromStreamAsync(_sread); } finally { cts.Cancel(); } if (msg == null || msg.Name == "data") return msg; //TcpMapService.LogMessage("ServerSession:get message " + msg); switch (msg.Name) { case "_ping_": await _swrite.WriteAsync(new CommandMessage("_ping_result_").Pack()); break; case "_ping_result_": break; default: TcpMapService.LogMessage("Error: 3 Ignore message " + msg); break; } goto ReadAgain; }
private async Task SessionToStreamAsync(Stream stream) { try { while (true) { //TcpMapService.LogMessage(this.GetType().Name + " ReadMessageAsync"); var msg = await this.ReadMessageAsync(); if (msg == null) { return; } if (msg.Name == "data") { //TcpMapService.LogMessage(this.GetType().Name + " ReadMessageAsync DONE : " + msg); //TcpMapService.LogMessage("Data:" + Encoding.UTF8.GetString(msg.Data.ToArray())); await stream.WriteAsync(msg.Data); } else { TcpMapService.LogMessage("Warning:this message shall not pass to BaseSession : " + msg); } //TcpMapService.LogMessage(this.GetType().Name + " WriteAsync DONE : " + msg); } } catch (ObjectDisposedException) { //no log } catch (Exception) { //TcpMapService.OnError(x); } finally { //TcpMapService.LogMessage(this.GetType().Name + " EXITING SessionToStreamAsync"); } }
static async Task CopyToAsync(Socket src, Socket dst) { try { byte[] buffer = new byte[65536]; while (true) { var rc = await src.ReceiveAsync(buffer, SocketFlags.None); if (rc == 0) { return; } var sc = await dst.SendAsync(new ArraySegment <byte>(buffer, 0, rc), SocketFlags.None); Debug.Assert(rc == sc); } } catch (Exception x) { TcpMapService.OnError(x); } }
private async Task WorkAsync() { this.IsConnected = false; this.LogMessage("ClientWorker WorkAsync start"); int connectedTimes = 0; try { int againTimeout = 125; StartAgain: this.socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); this.socket.InitTcp(); this.cts_connect = new CancellationTokenSource(); try { await this.socket.ConnectAsync(this.Client.ServerHost, 6022); this.LogMessage("connected to 6022"); } catch (Exception x) { this.OnError(x); this.socket.CloseSocket(); this.socket = null; this.cts_connect = new CancellationTokenSource(); if (!this.IsStarted) { return; } if (againTimeout < 4) { againTimeout *= 2; } if (await this.cts_connect.Token.WaitForSignalSettedAsync(againTimeout)) { return; } goto StartAgain; } try { bool supportEncrypt = this.Client.UseEncrypt; byte[] clientKeyIV; { CommandMessage connmsg = new CommandMessage { Name = "ClientConnect" }; List <string> arglist = new List <string> { this.Client.License.Key, this.Client.ServerPort.ToString() }; this.Client.License.GenerateSecureKeyAndHash(out clientKeyIV, out byte[] encryptedKeyIV, out byte[] sourceHash); arglist.Add(Convert.ToBase64String(encryptedKeyIV)); arglist.Add(Convert.ToBase64String(sourceHash)); arglist.Add(supportEncrypt ? "1" : "0"); connmsg.Args = arglist.ToArray(); await this.socket.SendAsync(connmsg.Pack(), SocketFlags.None); //LogMessage("wait for conn msg"); connmsg = await CommandMessage.ReadFromSocketAsync(this.socket); if (connmsg == null) { TcpMapService.LogMessage("no message ? Connected:" + this.socket.Connected); return; } this.LogMessage("connmsg : " + connmsg.Name + " : " + string.Join(",", connmsg.Args)); if (connmsg.Name != "ConnectOK") { this.IsStarted = false;//don't go until start it again. throw new Exception(connmsg.Name + " : " + string.Join(",", connmsg.Args)); } if (supportEncrypt && connmsg.Args[1] == "0") { supportEncrypt = false; this.LogMessage("Warning:server don't support encryption."); } } this.IsConnected = true; connectedTimes++; this.LogMessage("ConnectOK #" + connectedTimes); if (supportEncrypt) { this.Client.License.OverrideStream(this.socket.CreateStream(), clientKeyIV, out this.sread, out this.swrite); } else { this.sread = this.swrite = this.socket.CreateStream(); } for (int i = 0; i < Math.Min(5, this.Client.PreSessionCount); i++)//TODO:const of 5 { _ = Task.Run(this.ProvidePreSessionAsync); } _ = Task.Run(this.MaintainSessionsAsync); if (this.Client.RouterClientPort > 0) { _ = this.swrite.WriteAsync(new CommandMessage("SetOption", "RouterClientPort", this.Client.RouterClientPort.ToString()).Pack()); } byte[] readbuff = new byte[TcpMapService.defaultBufferSize]; while (this.IsStarted) { CommandMessage msg; var cts = new CancellationTokenSource(); _ = Task.Run(async delegate { if (await cts.Token.WaitForSignalSettedAsync(16000)) { return; } try { await this.swrite.WriteAsync(new CommandMessage("_ping_", "forread").Pack()); } catch (Exception x) { this.OnError(x); } }); try { msg = await CommandMessage.ReadFromStreamAsync(this.sread); } finally { cts.Cancel(); } if (msg == null) { TcpMapService.LogMessage("no message ? Connected:" + this.socket.Connected); return; } //this.LogMessage("TcpMapClientWorker get msg " + msg); switch (msg.Name) { case "StartSession": Task.Run(async delegate { try { await this.DoStartSessionAsync(msg); } catch (Exception x) { this.OnError(x); } }).ToString(); break; case "CloseSession": Task.Run(async delegate { try { await this.DoCloseSessionAsync(msg); } catch (Exception x) { this.OnError(x); } }).ToString(); break; case "CreateUDPNat": Task.Run(async delegate { try { await this.DoCreateUDPNatAsync(msg); } catch (Exception x) { this.OnError(x); } }).ToString(); break; case "_ping_": await this.swrite.WriteAsync(new CommandMessage("_ping_result_").Pack()); break; case "_ping_result_": break; default: this.LogMessage("Error: 4 Ignore message " + msg); break; } } } catch (SocketException) { //no log } catch (Exception x) { this.OnError(x); } if (this.IsStarted) { this.socket.CloseSocket();//logic failed.. againTimeout = 125; goto StartAgain; } } catch (Exception x) { this.OnError(x); } this.IsStarted = false; this.IsConnected = false; if (this.socket != null) { try { this.socket.CloseSocket(); } catch (Exception x) { this.OnError(x); } this.socket = null; } }
public void OnError(Exception x) { this.Error = x; TcpMapService.OnError(x); }
async Task WorkAsync() { IsStarted = true; IsConnected = false; //LogMessage("ClientSession WorkAsync start"); int connectedTimes = 0; try { int againTimeout = 125; StartAgain: _sock_server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); _sock_server.InitTcp(); _cts_connect = new CancellationTokenSource(); try { await _sock_server.ConnectAsync(Client.ServerHost, 6022); //LogMessage("connected to 6022"); } catch (Exception x) { OnError(x); _sock_server.CloseSocket(); _sock_server = null; _cts_connect = new CancellationTokenSource(); if (!IsStarted) { return; } if (againTimeout < 4) { againTimeout = againTimeout * 2; } if (await _cts_connect.Token.WaitForSignalSettedAsync(againTimeout)) { return; } goto StartAgain; } try { bool supportEncrypt = false; byte[] clientKeyIV; { CommandMessage connmsg = new CommandMessage(); connmsg.Name = "SessionConnect"; List <string> arglist = new List <string>(); arglist.Add(this.Client.License.Key); arglist.Add(this.Client.ServerPort.ToString()); byte[] encryptedKeyIV, sourceHash; Client.License.GenerateSecureKeyAndHash(out clientKeyIV, out encryptedKeyIV, out sourceHash); arglist.Add(Convert.ToBase64String(encryptedKeyIV)); arglist.Add(Convert.ToBase64String(sourceHash)); arglist.Add(supportEncrypt ? "1" : "0"); arglist.Add(SessionId); //sessionid at [5] connmsg.Args = arglist.ToArray(); await _sock_server.SendAsync(connmsg.Pack(), SocketFlags.None); //LogMessage("wait for conn msg"); connmsg = await CommandMessage.ReadFromSocketAsync(_sock_server); if (connmsg == null) { TcpMapService.LogMessage("no message ? Connected:" + _sock_server.Connected); return; } //LogMessage("connmsg : " + connmsg.Name + " : " + string.Join(",", connmsg.Args)); if (connmsg.Name != "ConnectOK") { IsStarted = false; //don't go until start it again. throw new Exception(connmsg.Name + " : " + string.Join(",", connmsg.Args)); } if (connmsg.Args[1] == "0") { supportEncrypt = false; } } IsConnected = true; connectedTimes++; //LogMessage("ConnectOK #" + connectedTimes); if (supportEncrypt) { Client.License.OverrideStream(_sock_server.CreateStream(), clientKeyIV, out _sread, out _swrite); } else { _sread = _swrite = _sock_server.CreateStream(); } if (string.IsNullOrEmpty(SessionId)) { //wait for Upgrade while (SessionId == null) { CommandMessage msg; var cts = new CancellationTokenSource(); _ = Task.Run(async delegate { if (await cts.Token.WaitForSignalSettedAsync(16000)) { return; } await _swrite.WriteAsync(new CommandMessage("_ping_", "forread").Pack()); }); try { msg = await CommandMessage.ReadFromStreamAsync(_sread); } finally { cts.Cancel(); } if (msg == null) { throw (new SocketException(995)); } switch (msg.Name) { case "UpgradeSession": try { _sock_local = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); _sock_local.InitTcp(); await _sock_local.ConnectWithTimeoutAsync(Client.ClientHost, Client.ClientPort, 12000); } catch (Exception x) { TcpMapService.OnError(x); await _swrite.WriteAsync(new CommandMessage("UpgradeSessionResult", "Failed").Pack()); continue; } SessionId = msg.Args[0]; if (_cts_upgrade != null) { _cts_upgrade.Cancel(); } await _swrite.WriteAsync(new CommandMessage("UpgradeSessionResult", "OK").Pack()); break; case "_ping_": await _swrite.WriteAsync(new CommandMessage("_ping_result_").Pack()); break; case "_ping_result_": break; default: LogMessage("Error: 1 Ignore message " + msg); break; } } } await WorkAsync(_sock_local.CreateStream()); } catch (Exception x) { OnError(x); } } catch (SocketException) { } catch (Exception x) { OnError(x); } IsStarted = false; IsConnected = false; _sock_server?.CloseSocket(); _sock_local?.CloseSocket(); _workend = true; }
async Task WorkAsync(CommandMessage connmsg) { if (connmsg.Name == "SessionConnect") { _is_client = false; _is_session = true; } byte[] clientKeyIV; _worker = TcpMapService.FindServerWorkerByKey(connmsg.Args[0], int.Parse(connmsg.Args[1])); string failedreason = null; if (_worker == null) { failedreason = "NotFound"; } else if (!_worker.Server.IsValidated) { failedreason = "NotValidated"; } else if (_worker.Server.IsDisabled) { failedreason = "NotEnabled"; } if (_worker == null || !string.IsNullOrEmpty(failedreason)) { var failedmsg = new CommandMessage("ConnectFailed", failedreason); await _socket.SendAsync(failedmsg.Pack(), SocketFlags.None); return; } bool supportEncrypt = _worker.Server.UseEncrypt; if (connmsg.Args[4] == "0") { supportEncrypt = false; } try { _worker.Server.License.DescriptSourceKey(Convert.FromBase64String(connmsg.Args[2]), Convert.FromBase64String(connmsg.Args[3]), out clientKeyIV); } catch (Exception x) { _worker.OnError(x); var failedmsg = new CommandMessage("ConnectFailed", "InvalidSecureKey"); await _socket.SendAsync(failedmsg.Pack(), SocketFlags.None); return; } var successMsg = new CommandMessage("ConnectOK", "ConnectOK", supportEncrypt ? "1" : "0"); await _socket.SendAsync(successMsg.Pack(), SocketFlags.None); if (supportEncrypt) { _worker.Server.License.OverrideStream(_socket.CreateStream(), clientKeyIV, out _sread, out _swrite); } else { _sread = _swrite = _socket.CreateStream(); } if (_is_session) { this.SessionId = connmsg.Args[5]; if (SessionId == null) { _cts_wait_upgrade = new CancellationTokenSource(); } } _worker.AddClientOrSession(this); try { if (_is_client) { _ = _swrite.WriteAsync(new CommandMessage("SetOption", "ClientEndPoint", _socket.RemoteEndPoint.ToString()).Pack()); while (true) { var msg = await CommandMessage.ReadFromStreamAsync(_sread); //process it... if (msg == null) { //TcpMapService.LogMessage("no message ? Connected:" + _socket.Connected); throw new SocketException(995); } //_worker.LogMessage("TcpMapServerClient get msg " + msg); switch (msg.Name) { case "SetOption": string optvalue = msg.Args[1]; switch (msg.Args[0]) { case "RouterClientPort": this.OptionRouterClientPort = int.Parse(optvalue); break; default: _worker.LogMessage("Error:Ignore option " + msg); break; } break; case "StartSessionResult": case "CloseSessionResult": case "CreateUDPNatResult": long reqid = long.Parse(msg.Args[0]); if (reqmap.TryGetValue(reqid, out var ritem)) { ritem.Response = msg; ritem.cts.Cancel(); } else { _worker.LogMessage("Request Expired : " + msg); } break; case "_ping_": this._lastPingTime = DateTime.Now; await _swrite.WriteAsync(new CommandMessage("_ping_result_").Pack()); break; case "_ping_result_": break; default: _worker.LogMessage("Error: 5 Ignore message " + msg); break; } } } else if (_is_session) { if (SessionId == null) { _worker.LogMessage($"Warning:ServerClient*{_scid} Wait for Upgrade To Session "); while (SessionId == null) { if (await _cts_wait_upgrade.Token.WaitForSignalSettedAsync(28000)) //check the presession closed or not every 28 seconds { if (SessionId != null) { break; //OK, session attached. } throw new SocketException(995); //_cts_wait_upgrade Cancelled , by SessionId is not seted } //if (!_socket.Connected) //NEVER useful.. //{ // _worker.LogMessage("Warning:presession exit."); // throw new SocketException(995); //} if (!_socket.Poll(0, SelectMode.SelectRead)) //WORKS.. { continue; } if (_socket.Available == 0) { _worker.LogMessage("Warning:presession exit!"); throw new SocketException(995); } //_worker.LogMessage("Warning:presession send message before upgrade ?"+_socket.Available); if (!_cts_wait_upgrade.IsCancellationRequested) { //TODO:not locked/sync, not so safe it the presession is upgrading var msg = await CommandMessage.ReadFromSocketAsync(_socket); if (msg.Name == "_ping_") { byte[] resp = new CommandMessage("_ping_result_").Pack(); await _socket.SendAsync(resp, SocketFlags.None); } else { _worker.LogMessage("Warning:presession unexpected msg : " + msg); } } } _worker.LogMessage($"Warning:ServerClient*{_scid} SessionId:" + SessionId); } int waitMapTimes = 0; TryGetMap: if (_attachedSession != null) { _worker.LogMessage($"ServerClient*{_scid} use attached Session : {SessionId} *{waitMapTimes}"); await _attachedSession.UseThisSocketAsync(_sread, _swrite); } else if (_worker.sessionMap.TryGetValue(SessionId, out var session)) { _worker.LogMessage($"ServerClient*{_scid} session server ok : {SessionId} *{waitMapTimes}"); await session.UseThisSocketAsync(_sread, _swrite); } else { if (waitMapTimes < 5) { waitMapTimes++; await Task.Delay(10); //wait sessionMap be added.. goto TryGetMap; } _worker.LogMessage($"Warning:ServerClient*{_scid} session not found : {SessionId}"); throw new Exception($"ServerClient*{_scid} session not found : {SessionId}"); } } else { throw new InvalidOperationException(); } } catch (SocketException) { //no log } catch (Exception x) { _worker.OnError(x); } finally { _worker.RemoveClientOrSession(this); } _worker.LogMessage($"ServerClient*{_scid} WorkAsync END " + SessionId); }
static public async Task ForwardToAndWorkAsync(this Socket socket, string ipaddr, int port) { Socket target = null; bool funcexited = false; try { target = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); target.InitTcp(); { CancellationTokenSource cts_connect_wait = new CancellationTokenSource(); _ = Task.Run(async delegate { if (!await cts_connect_wait.Token.WaitForSignalSettedAsync(5000)) { target.CloseSocket(); } }); await target.ConnectAsync(ipaddr, port); cts_connect_wait.Cancel(); } async Task CopyToAsync(Socket src, Socket dst) { try { byte[] buffer = new byte[65536]; while (true) { var rc = await src.ReceiveAsync(buffer, SocketFlags.None); if (rc == 0) { return; } var sc = await dst.SendAsync(new ArraySegment <byte>(buffer, 0, rc), SocketFlags.None); Debug.Assert(rc == sc); } } catch (Exception x) { TcpMapService.OnError(x); } } var t1 = Task.Run(async delegate { await CopyToAsync(socket, target); }); var t2 = Task.Run(async delegate { await CopyToAsync(target, socket); }); await Task.WhenAny(t1, t2); } catch (Exception x) { TcpMapService.OnError(x); socket.CloseSocket(); target?.CloseSocket(); } finally { funcexited = true; } }