/// <summary> /// Handle client requests and receives /// </summary> private string Service(ref TcpConnection connection) { //receives and sends messages if (connection.client != null) { try { // Get a stream object for reading and writing if (connection.client.Connected && connection.stream.DataAvailable) { int length; // Buffer for reading data Byte[] bytes = new Byte[64]; string data = null; // Loop to receive all the data sent by the client. length = connection.stream.Read(bytes, 0, bytes.Length); //TODO: Find out exactly how many bytes to read per message // Translate data bytes to a ASCII string. data = System.Text.Encoding.ASCII.GetString(bytes, 0, bytes.Length); data = data.TrimEnd('\0'); return data; } } catch (System.Exception e) { Debug.Log("Failed in Service() client " + connection.clientID + ", err: " + e.ToString()); } } return "-500"; }
private void ClientOnConnectionEstablished(TcpConnection tcpConnection) { _totalReceived[tcpConnection] = 0; _totalSent[tcpConnection] = 0; tcpConnection.ReceiveAsync(ClientReceiveCallback); SendRandomData(tcpConnection, small: false); }
public static void Test_GetHashCode_01() { //packet no 3 192.168.0.1:52581 - 173.194.66.94:443 //packet no 4 173.194.66.94:443 - 192.168.0.1:52581 TcpConnection tcpConnection1 = new TcpConnection(new TcpAddress(new MacAddress("00:07:CB:C1:35:5D"), new IpV4Address("192.168.0.1"), 52581), new TcpAddress(new MacAddress("48:5B:39:C0:45:48"), new IpV4Address("173.194.66.94"), 443)); TcpConnection tcpConnection2 = new TcpConnection(new TcpAddress(new MacAddress("48:5B:39:C0:45:48"), new IpV4Address("173.194.66.94"), 443), new TcpAddress(new MacAddress("00:07:CB:C1:35:5D"), new IpV4Address("192.168.0.1"), 52581)); }
public void Add(TcpStreamPacket streamPacket) { if (_address == null) _address = streamPacket.Connection; if (streamPacket.Connection.OriginalOrder == _address.OriginalOrder) streamPacket.Direction = TcpDirection.SourceToDestination; else streamPacket.Direction = TcpDirection.DestinationToSource; _packets.Add(streamPacket); AnalyzePacket(streamPacket); }
public HttpResponseInfo(TcpConnection<int, ReplyRFC> AConnection) { _CloseContentStream = true; ContentLength = Http.ContentLength; RawHeaders.FoldLines = false; _Cookies = new ServerCookies(); ServerSoftware = Http.HttpServer_ServerSoftware; ContentType = Http.ContentType; _RemoteConnection = AConnection; ResponseNo = Http.ResponseNo; }
public IEnumerable<int> Execute(BookSearchCriterion criterion) { using (var connection = new TcpConnection("localhost", 9317)) { var command = new SearchCommand(connection); connection.Open(); command.Execute(); IEnumerable<int> result = null; return result; } }
public void TestLimitSMTPSessionCount() { _settings.MaxSMTPConnections = 2; using (var conn1 = new TcpConnection()) using (var conn2 = new TcpConnection()) using (var conn3 = new TcpConnection()) { CustomAssert.IsTrue(conn1.Connect(25)); conn1.Receive(); CustomAssert.IsTrue(conn2.Connect(25)); conn2.Receive(); CustomAssert.IsTrue(conn3.Connect(25)); CustomAssert.IsEmpty(conn3.Receive()); } var log2 = TestSetup.ReadCurrentDefaultLog(); CustomAssert.IsTrue(log2.Contains("Blocked either by IP range or by connection limit.")); }
public static async Task <bool> AddFavorite(string uname, string url) { string md5 = GetMD5FromUrl(url); TcpConnection con = new TcpConnection(); await con.Connect(ip, port); await con.Send(GetAddFavoriteMessage(uname, md5)); NetMessage mess = await con.ReceiveOnceAsync() as NetMessage; con.Close(); if (mess.Message == MessageType.Success) { return(true); } else { return(false); } }
public void TestLimitImapSessionCount() { _settings.MaxIMAPConnections = 2; using (var conn1 = new TcpConnection()) using (var conn2 = new TcpConnection()) using (var conn3 = new TcpConnection()) { Assert.IsTrue(conn1.Connect(143)); conn1.Receive(); Assert.IsTrue(conn2.Connect(143)); conn2.Receive(); Assert.IsTrue(conn3.Connect(143)); Assert.IsEmpty(conn3.Receive()); } var log2 = LogHandler.ReadCurrentDefaultLog(); Assert.IsTrue(log2.Contains("Blocked either by IP range or by connection limit.")); }
protected override void HandleNewConnection(TcpConnection newConnection) { if (newConnection == null) { throw new ArgumentNullException("newConnection"); } RLoginConnection TypedConnection = new RLoginConnection(); if (TypedConnection.Open(newConnection.GetSocket())) { ClientThread NewClientThread = new ClientThread(TypedConnection, _ConnectionType); NewClientThread.Start(); } else { RMLog.Info("Timeout waiting for RLogin header"); TypedConnection.Close(); } }
public void TestSMTPServerAuthLoginUsernameAsThirdParameter() { _settings.AllowSMTPAuthPlain = true; var sock = new TcpConnection(); sock.Connect(25); Assert.IsTrue(sock.Receive().StartsWith("220")); sock.Send("EHLO test.com\r\n"); Assert.IsTrue(sock.Receive().StartsWith("250")); string base64EncodedUsername = EncodeBase64(GetUsername()); sock.Send("AUTH LOGIN " + base64EncodedUsername + "\r\n"); Assert.IsTrue(sock.Receive().StartsWith("334")); sock.Send(EncodeBase64(GetPassword()) + "\r\n"); Assert.IsTrue(sock.Receive().StartsWith("535")); EnsureNoPassword(); }
public static bool ConnectToServer(string ip, int port) { try { TcpClient client = new TcpClient(ip, port); if (UseSsl) { Connection = new TcpConnection(client, true, Log, false, true); } else { Connection = new TcpConnection(client, true, Log, false); } Connection.ConnectionEnded += Connection_ConnectionEnded; return(true); } catch (Exception ex) { MessageBox.Show("Connection to " + ip + ":" + port + " failed!" + Environment.NewLine + ex.Message, "Connection failed!"); return(false); } }
public void StartTlsCommandShouldSwithToTls() { var smtpClientSimulator = new TcpConnection(); smtpClientSimulator.Connect(25002); var banner = smtpClientSimulator.Receive(); var capabilities1 = smtpClientSimulator.SendAndReceive("EHLO example.com\r\n"); Assert.IsTrue(capabilities1.Contains("STARTTLS")); smtpClientSimulator.SendAndReceive("STARTTLS\r\n"); smtpClientSimulator.HandshakeAsClient(); // Send a command over TLS. var capabilities2 = smtpClientSimulator.SendAndReceive("EHLO example.com\r\n"); Assert.IsFalse(capabilities2.Contains("STARTTLS")); // We're now on SSL. }
/// <summary> /// Handles when a <see cref="UdpConnection"/> successfully connects to the server. /// </summary> /// <param name="tcpConnection">The parent <see cref="TcpConnection"/>.</param> /// <param name="udpConnection">The connected <see cref="UdpConnection"/>.</param> private void udpConnectionReceived(TcpConnection tcpConnection, UdpConnection udpConnection) { if (!AllowUDPConnections || this[tcpConnection].Count >= UDPConnectionLimit) { CloseReason closeReason = (this[tcpConnection].Count >= UDPConnectionLimit) ? CloseReason.UdpLimitExceeded : CloseReason.InvalidUdpRequest; tcpConnection.Close(closeReason, true); return; } this[tcpConnection].Add(udpConnection); udpConnection.NetworkConnectionClosed += connectionClosed; KnownTypes.ForEach(udpConnection.AddExternalPackets); //Inform all subscribers. if (connectionEstablished != null && connectionEstablished.GetInvocationList().Length > 0) { connectionEstablished(udpConnection, ConnectionType.UDP); } }
public void TestLimitSMTPSessionCount() { _settings.MaxSMTPConnections = 2; using (var conn1 = new TcpConnection()) using (var conn2 = new TcpConnection()) using (var conn3 = new TcpConnection()) { CustomAssert.IsTrue(conn1.Connect(25)); string s1 = conn1.Receive(); CustomAssert.IsNotEmpty(s1, s1); CustomAssert.IsTrue(conn2.Connect(25)); string s2 = conn2.Receive(); CustomAssert.IsNotEmpty(s2, s2); CustomAssert.IsTrue(conn3.Connect(25)); string s3 = conn3.Receive(); CustomAssert.IsEmpty(s3, s3); } }
public void TcpFieldTest() { NetworkEndPoint ep = new NetworkEndPoint(IPAddress.Loopback, 4296); using (TcpConnectionListener listener = new TcpConnectionListener(IPAddress.Any, 4296)) using (TcpConnection connection = new TcpConnection(ep)) { listener.Start(); connection.Connect(); //Connection fields Assert.AreEqual(ep, connection.EndPoint); //TcpConnection fields Assert.AreEqual(new IPEndPoint(IPAddress.Loopback, 4296), connection.RemoteEndPoint); Assert.AreEqual(0, connection.Statistics.DataBytesSent); Assert.AreEqual(0, connection.Statistics.DataBytesReceived); } }
public void TestTooManyInvalidCommandsHELO() { Settings settings = _settings; settings.DisconnectInvalidClients = true; settings.MaxNumberOfInvalidCommands = 3; var sim = new TcpConnection(); sim.Connect(25); sim.Receive(); // banner sim.SendAndReceive("HELO\r\n"); sim.SendAndReceive("HELO\r\n"); sim.SendAndReceive("HELO\r\n"); sim.SendAndReceive("HELO\r\n"); var result = sim.SendAndReceive("HELO\r\n"); Assert.IsTrue(result.Contains("Too many invalid commands"), result); }
public static string LinkPrinter(string printerName, int port) { try { string ip = Printer.GetRegistryData(printerName + "\\DsSpooler", "portName"); if (ip == "" || ip.Split(new char[] { '.' }).Length != 4) { throw new ConnectionException("没找到IP"); } foreach (string s in ip.Split(new char[] { '.' })) { int.Parse(s); } Ping pingSender = new Ping(); PingReply reply = pingSender.Send(ip, 1); //第一个参数为ip地址,第二个参数为ping的时间 if (reply.Status != IPStatus.Success) { throw new ConnectionException("链接失败!"); } TcpConnection connection = new TcpConnection(ip, port); connection.Open(); printer = ZebraPrinterFactory.GetInstance(connection); } catch (ConnectionException e) { printer = null; FileTools.WriteLineFile(FileTools.exceptionFilePath, DateTime.Now.ToString() + " " + printerName + e.Message); return(printerName + e.Message); } catch (FormatException e) { printer = null; FileTools.WriteLineFile(FileTools.exceptionFilePath, DateTime.Now.ToString() + " " + printerName + "IP地址不正确!"); return(printerName + "IP地址不正确!"); } return(""); }
public void TestSendToTooManyRecipients() { hMailServer.Accounts accounts = _domain.Accounts; SingletonProvider <TestSetup> .Instance.AddAccount(accounts, string.Format("*****@*****.**"), "test"); var sock = new TcpConnection(); sock.Connect(25); sock.ReadUntil("\r\n"); string result; sock.Send("EHLO test.com\r\n"); result = sock.ReadUntil("\r\n"); Assert.IsTrue(result.StartsWith("250")); sock.Send("MAIL FROM: [email protected]\r\n"); result = sock.ReadUntil("\r\n"); Assert.IsTrue(result.StartsWith("250")); const int recipientCount = 51000; for (int i = 1; i <= recipientCount; i++) { string address = string.Format("test{0}@gmail.com", i); sock.Send(string.Format("RCPT TO: <{0}>\r\n", address)); result = sock.ReadUntil("\r\n"); if (i <= 50000) { Assert.IsTrue(result.StartsWith("250")); } else { Assert.IsFalse(result.StartsWith("250")); } if (i % 100 == 0) { TestTracer.WriteTraceInfo("{0}/{1}", i, recipientCount); } } }
public static void AssertClamDRunning() { Process[] processlist = Process.GetProcesses(); foreach (Process theprocess in processlist) { if (theprocess.ProcessName == "clamd") { return; } } // Check if we can launch it... var startInfo = new ProcessStartInfo(); startInfo.FileName = @"C:\clamav\clamd.exe"; startInfo.WorkingDirectory = @"C:\Clamav"; startInfo.Arguments = "--daemon"; try { Process.Start(startInfo); // Wait for clamav to start up. for (int i = 0; i < 10; i++) { var sock = new TcpConnection(); if (sock.Connect(3310)) { return; } Thread.Sleep(1000); } Assert.Fail("ClamD process not starting up."); } catch (Exception) { Assert.Inconclusive("Unable to start ClamD process. Is ClamAV installed?"); } }
public static VirtualMachine ConnectInternal(Socket dbg_sock, Socket con_sock, IPEndPoint dbg_ep, IPEndPoint con_ep) { if (con_sock != null) { try { con_sock.Connect(con_ep); } catch (Exception) { try { dbg_sock.Close(); } catch {} throw; } } try { dbg_sock.Connect(dbg_ep); } catch (Exception) { if (con_sock != null) { try { con_sock.Close(); } catch {} } throw; } Connection transport = new TcpConnection(dbg_sock); StreamReader console = con_sock != null? new StreamReader(new NetworkStream(con_sock)) : null; return(Connect(transport, console, null)); }
protected override void Execute() { while (!_Stop) { using (TcpConnection Connection = new TcpConnection()) { if (Connection.Listen(_LocalAddress, _LocalPort)) { while (!_Stop) { // Accept an incoming connection if (Connection.CanAccept(1000)) // 1 second { try { TcpConnection NewConnection = Connection.AcceptTCP(); if (NewConnection != null) { // TODOX Add check for flash socket policy request by doing a peek with a 1 second timeout or something // If peeked character is < then peek another character to see if it's the flash request string HandleNewConnection(NewConnection); } } catch (Exception ex) { RMLog.Exception(ex, "Error in ServerThread::Execute()"); } } } } else { RMLog.Error($"{_ConnectionType} Server Thread unable to listen on {_LocalAddress}:{_LocalPort}. Retry in 15 seconds."); for (int i = 1; i <= 15; i++) { Thread.Sleep(1000); if (_Stop) { break; } } } } } }
static void Main(string[] args) { using (TcpConnection connection = new TcpConnection()) { ManualResetEvent e = new ManualResetEvent(false); //Whenever we receive data print the number of bytes and how it was sent connection.DataReceived += (object sender, DataReceivedEventArgs a) => Console.WriteLine("Received {0} bytes via {1}!", a.Bytes.Length, a.SendOption); //When the end point disconnects from us then release the main thread and exit connection.Disconnected += (object sender, DisconnectedEventArgs a) => e.Set(); //Connect to a server connection.Connect(new NetworkEndPoint("127.0.0.1", 4296)); //Wait until the end point disconnects from us e.WaitOne(); } }
private void OnSocketAccepted(Socket socket, object userToken) { Task.Run(() => { try { var connection = new TcpConnection(Name, socket, Setting, _receivedBufferPool, _sendBufferPool, _tcpConnectionServerHandler); connection.RegisterConnectionEventListener(_connectionEventListeners); if (_connectionDict.TryAdd(connection.Id, connection)) { Log <ServerSocket> .Info(string.Format("Socket server new client accepted, name: {0}, listeningEndPoint: {1}, remoteEndPoint: {2}", Name, ListeningEndPoint, socket.RemoteEndPoint)); connection.Accepted(); } } catch (ObjectDisposedException) { } catch (Exception ex) { Log <ServerSocket> .Error(ex, string.Format("Socket server accept new client has unknown exception, name: {0}, listeningEndPoint: {1}", Name, ListeningEndPoint)); } }); }
public void Connect(string ip, int port) { Debug.Log("正在连接服务器:" + ip + ":" + port + " ...."); this.ip = ip; this.port = port; TcpConnection conn = new TcpConnection(ip, port, false); conn.Connect(); serverConnectionWorker = new ServerConnectionWorker(conn); serverConnectionWorker.Start(); isConnection = true; StartCoroutine(HandleReadPackage()); //连接成功后缓存当前人物的roleId roleId = GetRoleId(); LinkStatePackage package = PackageFactory.GetPackage(PackageType.LinkState) as LinkStatePackage; SendPackage(package); AddClientEvents(); }
public void StartTlsWithTrailingSpaceShouldBeAccepted() { var smtpClientSimulator = new TcpConnection(); smtpClientSimulator.Connect(25002); var banner = smtpClientSimulator.Receive(); var capabilities1 = smtpClientSimulator.SendAndReceive("EHLO example.com\r\n"); Assert.IsTrue(capabilities1.Contains("STARTTLS")); var startTlsResultText = smtpClientSimulator.SendAndReceive("STARTTLS \r\n"); StringAssert.Contains("220 Ready to start TLS", startTlsResultText); smtpClientSimulator.HandshakeAsClient(); // Send a command over TLS. var capabilities2 = smtpClientSimulator.SendAndReceive("EHLO example.com\r\n"); Assert.IsFalse(capabilities2.Contains("STARTTLS")); }
protected override void HandleNewConnection(TcpConnection newConnection) { if (newConnection == null) { throw new ArgumentNullException("newConnection"); } WebSocketConnection TypedConnection = new WebSocketConnection(); if (TypedConnection.Open(newConnection.GetSocket())) { // TODOX Start a proxy thread instead of a clientthread ClientThread NewClientThread = new ClientThread(TypedConnection, _ConnectionType); NewClientThread.Start(); } else { RMLog.Info("No carrier detected (probably a portscanner)"); TypedConnection.Close(); } }
public void HandshakeCompletionShouldBeLoggedWithCipherDetails() { var smtpClientSimulator = new TcpConnection(); smtpClientSimulator.Connect(25002); var banner = smtpClientSimulator.Receive(); var capabilities1 = smtpClientSimulator.SendAndReceive("EHLO example.com\r\n"); Assert.IsTrue(capabilities1.Contains("STARTTLS")); smtpClientSimulator.SendAndReceive("STARTTLS\r\n"); smtpClientSimulator.HandshakeAsClient(); var capabilities2 = smtpClientSimulator.SendAndReceive("EHLO example.com\r\n"); var default_log = LogHandler.ReadCurrentDefaultLog(); Assert.IsTrue(default_log.Contains("Version: TLS")); Assert.IsTrue(default_log.Contains("Cipher: ")); Assert.IsTrue(default_log.Contains("Bits: ")); }
protected override void HandleNewConnection(TcpConnection newConnection) { if (newConnection == null) { throw new ArgumentNullException("newConnection"); } TelnetConnection TypedConnection = new TelnetConnection(); if (TypedConnection.Open(newConnection.GetSocket())) { ClientThread NewClientThread = new ClientThread(TypedConnection, _ConnectionType); NewClientThread.Start(); } else { // TODOX Duplicated code. Maybe add method to base class and call it? RMLog.Info("No carrier detected (probably a portscanner)"); TypedConnection.Close(); } }
public void TestLongSMTPCommand() { var socket = new TcpConnection(); socket.Connect(25); // Build a large string... var sb = new StringBuilder(); sb.Append("A01"); for (int i = 0; i < 1000000; i++) { sb.Append("01234567890"); } sb.Append(Environment.NewLine); for (int i = 0; i < 100; i++) { try { socket.Send(sb.ToString()); } catch (Exception) { return; } if ((i % 10) == 0) { TestTracer.WriteTraceInfo("{0}/{1}", i, 100); } } socket.Send("\r\n"); socket.Receive(); socket.Disconnect(); }
public void TestTooManyInvalidCommandsTempError() { Account account = SingletonProvider <TestSetup> .Instance.AddAccount(_domain, "*****@*****.**", "test"); for (int i = 0; i < 10; i++) { SingletonProvider <TestSetup> .Instance.AddAccount(_domain, string.Format("test{0}@test.com", i), "test"); } Application application = SingletonProvider <TestSetup> .Instance.GetApp(); Settings settings = _settings; settings.DisconnectInvalidClients = true; settings.MaxNumberOfInvalidCommands = 5; settings.AntiSpam.GreyListingEnabled = true; var sim = new TcpConnection(); sim.Connect(25); string res = sim.Receive(); sim.Send("EHLO test.com\r\n"); res = sim.Receive(); sim.Send("MAIL FROM: <*****@*****.**>\r\n"); res = sim.Receive(); for (int i = 1; i < 10; i++) { string address = string.Format("test{0}@test.com", i); sim.Send("RCPT TO: " + address + "\r\n"); res = sim.Receive(); Assert.AreEqual("451 Please try again later.\r\n", res); } sim.Disconnect(); }
public void TestMailFromSyntaxValidation() { Account account1 = SingletonProvider <TestSetup> .Instance.AddAccount(_domain, "*****@*****.**", "test"); var smtpClientSimulator = new TcpConnection(); smtpClientSimulator.Connect(25); Assert.IsTrue(smtpClientSimulator.Receive().StartsWith("220")); smtpClientSimulator.Send("HELO test\r\n"); Assert.IsTrue(smtpClientSimulator.Receive().StartsWith("250")); // A few tests of invalid syntax. Assert.IsFalse(smtpClientSimulator.SendAndReceive("MAIL FROM: <[email protected]\r\n").StartsWith("250")); Assert.IsFalse(smtpClientSimulator.SendAndReceive("MAIL FROM: [email protected]>\r\n").StartsWith("250")); Assert.IsFalse(smtpClientSimulator.SendAndReceive("MAIL FROM: < [email protected] \r\n").StartsWith("250")); Assert.IsFalse(smtpClientSimulator.SendAndReceive("MAIL FROM: < \r\n").StartsWith("250")); Assert.IsFalse(smtpClientSimulator.SendAndReceive("MAIL FROM: > \r\n").StartsWith("250")); Assert.IsFalse(smtpClientSimulator.SendAndReceive("MAIL FROM: <[email protected]\r\n").StartsWith("250")); Assert.IsFalse(smtpClientSimulator.SendAndReceive("MAIL FROM <*****@*****.**>\r\n").StartsWith("250")); Assert.IsFalse(smtpClientSimulator.SendAndReceive("MAIL FROM [email protected]\r\n").StartsWith("250")); // Valid syntax, < and > Assert.IsTrue(smtpClientSimulator.SendAndReceive("MAIL FROM: <*****@*****.**>\r\n").StartsWith("250")); Assert.IsTrue(smtpClientSimulator.SendAndReceive("RSET\r\n").StartsWith("250")); Assert.IsTrue(smtpClientSimulator.SendAndReceive("MAIL FROM: [email protected]\r\n").StartsWith("250")); Assert.IsTrue(smtpClientSimulator.SendAndReceive("RSET\r\n").StartsWith("250")); Assert.IsTrue(smtpClientSimulator.SendAndReceive("MAIL FROM: [email protected] \r\n").StartsWith("250")); Assert.IsTrue(smtpClientSimulator.SendAndReceive("RSET\r\n").StartsWith("250")); Assert.IsTrue(smtpClientSimulator.SendAndReceive("MAIL FROM:[email protected]\r\n").StartsWith("250")); Assert.IsTrue(smtpClientSimulator.SendAndReceive("RSET\r\n").StartsWith("250")); Assert.IsTrue(smtpClientSimulator.SendAndReceive("MAIL FROM:<*****@*****.**>\r\n").StartsWith("250")); Assert.IsTrue(smtpClientSimulator.SendAndReceive("RSET\r\n").StartsWith("250")); smtpClientSimulator.Disconnect(); }
private async Task SocketPingProcess(TcpConnection connection) { var lastSendPingTime = DateTime.UtcNow; try { while (!connection.Disconnected) { await Task.Delay(500); if ((DateTime.UtcNow - SocketStatistic.LastReceiveTime).TotalSeconds > _disconnectInterval) { string disconnectMessage = $"There is no receive activity during {_disconnectInterval} seconds. Disconnecting..."; _log?.Warning( message: disconnectMessage, context: new { pingInterval = _pingInterval, disconnectInterval = _disconnectInterval }); _legacyLog?.Add(disconnectMessage); await connection.Disconnect(new Exception(disconnectMessage)); } else if ((DateTime.UtcNow - lastSendPingTime).TotalSeconds > _pingInterval) { var pingData = _service.GetPingData(); await connection.SendDataToSocket(pingData, CancellationToken.None); lastSendPingTime = DateTime.UtcNow; } } } catch (Exception exception) { await connection.Disconnect(exception); _log?.Error(exception); _legacyLog?.Add("Ping Thread Exception: " + exception.Message); } }
public void TestManyTCPIPConnections() { LogHandler.DeleteCurrentDefaultLog(); const int count = 1000; List <TcpConnection> sockets = new List <TcpConnection>(); for (int i = 1; i <= count; i++) { TcpConnection socket = new TcpConnection(); Assert.IsTrue(socket.Connect(25)); if ((i % 10) == 0) { TestTracer.WriteTraceInfo("{0}/{1}", i, 1000); } sockets.Add(socket); } foreach (TcpConnection socket in sockets) { socket.Disconnect(); } RetryHelper.TryAction(() => { string log = LogHandler.ReadCurrentDefaultLog(); string connectionCreated = "TCP - 127.0.0.1 connected to 127.0.0.1:25."; string connectionEnded = "Ending session "; var created = Regex.Matches(log, connectionCreated); var ended = Regex.Matches(log, connectionEnded); Assert.AreEqual(count, created.Count); Assert.AreEqual(count, ended.Count); }, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(30)); }
public void Data2() { TcpConnection c = new TcpConnection(null, "tcp://127.0.0.1:" + port, null); MyDataHandler dh = new MyDataHandler(c); Assert.IsFalse(c.IsStarted()); c.Start(); Assert.IsTrue(c.IsStarted()); c.WaitUp(TIMEOUT); Socket t = lh.accepted.WaitUntilNotEqAndSet(null, TIMEOUT, null); AssertWhat(What.UP, dh.what); Assert.IsNull(dh.xsender); Assert.IsNull(dh.xbuf); byte[] buf = { 21, 22, 23 }; t.Send(buf); // t.getOutputStream().flush(); AssertWhat(What.DATA, dh.what); Assert.IsNull(dh.xsender); Assert.IsNotNull(dh.xbuf); Assert.AreEqual(3, dh.xbuf.Length); Assert.AreEqual(( byte )21, dh.xbuf[0]); Assert.AreEqual(( byte )22, dh.xbuf[1]); Assert.AreEqual(( byte )23, dh.xbuf[2]); Assert.IsTrue(c.IsStarted()); c.Stop(); Assert.IsFalse(c.IsStarted()); AssertWhat(What.DOWN, dh.what); Assert.IsNull(dh.xsender); Assert.IsNull(dh.xbuf); t.Close(); }
//private static void PrintSortedTcpStreamPacket(IndexedTcpConnection tcpConnection, PPacket ppacket) private static void PrintSortedTcpStreamPacket(PPacket ppacket) { TcpConnection tcpConnection = ppacket.GetTcpConnection(); if (_currentTcpConnection == null || tcpConnection.Index != _currentTcpConnection.Index) { Trace.WriteLine(); Trace.WriteLine("group packet time source dir destination protocol flags data seq next seq ack window urg data"); //_LastStreamNumber = tcpConnection.Index; _currentTcpConnection = tcpConnection; } //TcpDirection direction = TcpDirection.SourceToDestination; //string s = GetTcpStreamPacketString1(tcpConnection, ppacket, _currentTcpConnection.GetTcpDirection(tcpConnection), true); string s = GetTcpStreamPacketString1(ppacket, _currentTcpConnection.GetTcpDirection(tcpConnection), true); //string s2 = null; //foreach (Pib.Pcap.Test.TcpPacketError error in streamPacket.Errors) // s2 = s2.zAddValue(streamPacket.GetErrorMessage(error)); //if (s2 != null) // s2 = " " + s2; //Trace.WriteLine("{0,-162}{1}{2}", s, ppacket.GetTcpDescription(), s2); Trace.WriteLine(s); }
public void TestTooManyInvalidCommandsHELOSuccesfullCommandDoesNotResetCounter() { Settings settings = _settings; settings.DisconnectInvalidClients = true; settings.MaxNumberOfInvalidCommands = 3; var sim = new TcpConnection(); sim.Connect(25); sim.Receive(); // banner sim.SendAndReceive("HELO\r\n"); sim.SendAndReceive("HELO\r\n"); sim.SendAndReceive("HELO\r\n"); var result = sim.SendAndReceive("HELO test.com\r\n"); Assert.IsTrue(result.Contains("250 Hello."), result); result = sim.SendAndReceive("HELO\r\n"); Assert.IsTrue(result.Contains("Too many invalid commands"), result); }
protected override async Task<ITcpConnection> ConnectAsync(string host, int port, bool useSsl, CancellationToken cancellationToken) { var tcp = new TcpConnection(useSsl); await tcp.ConnectAsync(host, port, cancellationToken); return tcp; }
private TcpConnection GetConnection(TcpServiceAddress address) { TcpConnection c; lock (connections) { // If there isn't, establish a connection, if (!connections.TryGetValue(address, out c)) { IPEndPoint endPoint = address.ToEndPoint(); Socket socket = new Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp); #if DEBUG socket.ReceiveTimeout = Int32.MaxValue; #else socket.ReceiveTimeout = 8 * 1000; // 8 second timeout, #endif socket.NoDelay = true; int curSendBufSize = socket.SendBufferSize; if (curSendBufSize < 256 * 1024) socket.SendBufferSize = 256 * 1024; int curReceiveBufSize = socket.ReceiveBufferSize; if (curReceiveBufSize < 256 * 1024) socket.ReceiveBufferSize = 256 * 1024; socket.Connect(endPoint); c = new TcpConnection(socket); c.Connect(password); connections.Add(address, c); } else { c.AddLock(); } } return c; }
public TcpStreamPacket(PPacket ppacket) { _direction = TcpDirection.SourceToDestination; //_connection = new TcpConnection(packet.Packet); _connection = ppacket.GetTcpConnection(); _ppacket = ppacket; _packet = ppacket.Packet; }
private void ReleaseConnection(TcpConnection c) { lock (connections) { c.RemoveLock(); } }
public TcpStream(TcpConnection tcpConnection) { _tcpConnection = tcpConnection; _streamSourceToDestination = new TcpMonoStream(); _streamSourceToDestination.WriteData = WriteDataSourceToDestination; _streamDestinationToSource = new TcpMonoStream(); _streamDestinationToSource.WriteData = WriteDataDestinationToSource; }
public Connection Connect() { try { var socket = new System.Net.Sockets.TcpClient(host, port); Connection connection = new TcpConnection(socket); return connection; } catch (System.IO.IOException e) { throw new FastConnectionException(e); } catch (System.Exception e) { throw new FastConnectionException(e); } }
void OnConnectRequest(IAsyncResult result) { try { Socket sock = (Socket)result.AsyncState; TcpConnection newConn = new TcpConnection(sock.EndAccept(result)); newConn.ReceivedMessage += new EventHandler<MessageEventArgs>(newConn_ReceivedMessage); newConn.Disconnected += new EventHandler<ConnectionEventArgs>(newConn_Disconnected); sock.BeginAccept(this.OnConnectRequest, sock); } catch { } }
private void removeConnection(TcpConnection connection) { lock (_tcpConnections) { try { if (connection.Connected()) { Log("Closing connection from " + connection.getRemoteEndpoint() + "."); } connection.Close(); _tcpConnections.Remove(connection); } catch (Exception ex) { Log("Error removing TcpConnection: " + ex); } } }
public NewPatientForm(TcpConnection tcpConnections) { InitializeComponent(); connection = tcpConnections; }
private void ClientOnConnectionFailed(TcpConnection tcpConnection, SocketError socketError) { Debug.Fail("Cannot establish connection: " + socketError); }
private void ServerListenCallback(TcpConnection tcpConnection) { _totalReceived[tcpConnection] = 0; _totalSent[tcpConnection] = 0; tcpConnection.ReceiveAsync(ServerReceiveCallback); SendRandomData(tcpConnection, small: false); //StartPing(tcpConnection); }
public TcpStreamReassembledPacket(TcpStream tcpStream) { _tcpConnection = tcpStream.TcpConnection; tcpStream.WriteData += WriteData; }
//private static void PrintIpAdressList(Packet packet) private static void PrintIpAdressList(PPacket ppacket) { Packet packet = ppacket.Packet; //if (packet.Ethernet == null) // return; //IpV4Datagram ip = packet.Ethernet.IpV4; IpV4Datagram ip = ppacket.Ipv4; if (ip == null) return; uint ipAdress = ip.Source.ToValue(); if (!_ipAdressList.ContainsKey(ipAdress)) { _ipAdressList.Add(ipAdress, null); Trace.WriteLine("new ip adress {0}", ip.Source.ToString()); } ipAdress = ip.Destination.ToValue(); if (!_ipAdressList.ContainsKey(ipAdress)) { _ipAdressList.Add(ipAdress, null); Trace.WriteLine("new ip adress {0}", ip.Destination.ToString()); } //TcpDatagram tcp = ip.Tcp; TcpDatagram tcp = ppacket.Tcp; if (tcp == null) return; TcpConnection tcpConnection = new TcpConnection(packet); if (!_tcpStreamList.ContainsKey(tcpConnection)) { _tcpStreamList.Add(tcpConnection, null); //_tr.WriteLine("new tcp stream {0}:{1} {2}:{3}", tcpConnection.Source.IpAddress, tcpConnection.Source.Port, // tcpConnection.Destination.IpAddress, tcpConnection.Destination.Port); Trace.WriteLine("new tcp stream {0}", tcpConnection.GetConnectionName()); } }
private void Poll() { try { Logger.Info("Node started on " + Address); while (polling) { if (!listener.Pending()) { Thread.Sleep(500); continue; } Socket s; try { // The socket to run the service, s = listener.AcceptSocket(); s.NoDelay = true; int cur_send_buf_size = s.SendBufferSize; if (cur_send_buf_size < 256 * 1024) { s.SendBufferSize = 256 * 1024; } // Make sure this ip address is allowed, IPAddress ipAddress = ((IPEndPoint)s.RemoteEndPoint).Address; Logger.Info("Connection from " + ipAddress); bool authorized = IPAddress.IsLoopback(ipAddress) || IsAddressAllowed(ipAddress.ToString()); if (OnClientConnect(ipAddress.ToString(), authorized)) { // Dispatch the connection to the thread pool, TcpConnection c = new TcpConnection(this, s); if (connections == null) connections = new List<TcpConnection>(); connections.Add(c); ThreadPool.QueueUserWorkItem(c.Work, null); } else { Logger.Error("Connection refused from " + ipAddress + ": not allowed"); } } catch (SocketException e) { Logger.Warning("Socket Errot while processing a connection.", e); } } } catch(Exception e) { Logger.Error("Error while polling.", e); } }
/** * 切断した */ private void OnDisconnected(TcpConnection conn, Result result) { result.Log(); Debug.Log("切断した"); }
private void StartPing(TcpConnection tcpConnection) { WaitCallback callBack = null; callBack = state => { //var outData = new List<ArraySegment<byte>>(); //outData.Add(new ArraySegment<byte>(_data, 0, 4)); //Interlocked.Add(ref _sent, 4); //tcpConnection.TotalSent += 4; //tcpConnection.EnqueueSend(outData); Thread.Sleep(2000); ThreadPool.QueueUserWorkItem(callBack); }; ThreadPool.QueueUserWorkItem(callBack); }
public GameSession(TcpConnection c) { _connection = c; }
private TcpConnection GetConnection(TcpServiceAddress address) { TcpConnection c; lock (connectionPool) { // If there isn't, establish a connection, if (!connectionPool.TryGetValue(address, out c)) { Socket socket = new Socket(address.IsIPv4 ? AddressFamily.InterNetwork : AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.IP); socket.Connect(address.ToIPAddress(), address.Port); socket.ReceiveTimeout = (30*1000); // 30 second timeout, socket.NoDelay = true; int curSendBufSize = socket.SendBufferSize; if (curSendBufSize < 256*1024) socket.SendBufferSize = 256*1024; int curReceiveBufSize = socket.ReceiveBufferSize; if (curReceiveBufSize < 256*1024) socket.ReceiveBufferSize = 256*1024; c = new TcpConnection(this, socket); c.Connect(); connectionPool[address] = c; } else { c.AddLock(); } } return c; }
internal IInnerConnection CreateInnerConnection (ConnectionOptions options, bool enlist) { Debug.WriteLineIf (CLI.FnTrace.Enabled, "VirtuosoConnection.CreateInnerConnection()"); IInnerConnection conn; #if UNMANAGED_ODBC if (options.UseOdbc) conn = new OdbcConnection (); else #endif conn = new TcpConnection (); conn.OuterConnectionWeakRef = new WeakReference (this); conn.Open (options); #if MTS if (enlist && options.Enlist && ContextUtil.IsInTransaction) EnlistInnerConnection (conn); #endif return conn; }
public TcpStreamPacket(Packet packet) { _direction = TcpDirection.SourceToDestination; _connection = new TcpConnection(packet); _packet = packet; }
private void Poll() { polling = true; try { //TODO: INFO log ... while (polling) { Socket s; try { // The socket to run the service, s = listener.AcceptSocket(); s.NoDelay = true; int cur_send_buf_size = s.SendBufferSize; if (cur_send_buf_size < 256 * 1024) { s.SendBufferSize = 256 * 1024; } //TODO: INFO log ... TcpConnection c = new TcpConnection(this); ThreadPool.QueueUserWorkItem(c.Work, s); } catch (IOException) { //TODO: WARN log ... } } } catch(Exception) { //TODO: WARN log ... } }
public TcpConnection GetTcpConnection() { if (_tcpConnection == null && _tcp != null) _tcpConnection = new TcpConnection(_packet); return _tcpConnection; }
/** * 接続失敗した */ private void OnConnectFailed(TcpConnection conn, Result result) { result.Log(); Debug.Log("接続失敗した"); }